extdeps loader close

[briansrls]

extdeps loader close — Path 2 scope

Director-dispatched substrate-capability unblock for R2 Grounding's Engine-Phase-1 sharpened-(b) re-dispatch. Brief: docs/briefs/extdeps-loader-close-worker.md (from Director WIP d42e6a362). Path 2 re-scoping per Director pick on this PR's STOP-AND-ESCALATE.

Summary

• dsl/extdeps/languages/rust/primitives.dag loads into the bootstrap Dag via a new EXTDEPS_BOOTSTRAP_FIXTURES fifth fixture set in bootstrap.rs.
• Dag::rust_pilot_primitives() typed accessor returns the List<RustPrimitive> declaration with walkable type structure.
• Integration test pins the type walk (List → RustPrimitive → Integer|NonIntegerPrimitive → {target_name, algebra, carrier, is_copy[, overflow]}) and records the ValueBody::Unparsed boundary.
• bootstrap.rs header comment revisited; dissolution trigger reframed to PB-Bootstrap-Process lane.
• Bootstrap snapshots regenerated (bootstrap_generated*.rs); lens-generated modules regenerated; clippy::enum_variant_names allowed in the 9 lens-generated wrappers (matches their existing clippy allow-list).

Five consumer requirements

Req 1 — Public accessor returns parsed Declaration walkable structurally — PARTIAL (Path 2)

Type-structure: full satisfaction. Engine walks RustPrimitive through Dag::rust_pilot_primitives():

• Top-level List<RustPrimitive> → TypeConnective::Instantiation
• RustPrimitive sum → TypeConnective::Disj { variants: [IntegerPrimitive, NonIntegerPrimitive] }
• Per-variant Conj records with field labels (target_name, algebra, carrier, is_copy, overflow on the integer side only — state-space discipline).

Value-enumeration: deferred. The 10-element pilot list at data rust_pilot_primitives: List<RustPrimitive> = [...] lowers with value_body = ValueBody::Unparsed(span). v3's ValueBody enum (dag.rs:258-287) does not yet carry a top-level list/aggregate variant — "scalar + structural record only" per its own rationale (dag.rs:277-281). Same substrate gap as:

• data kernel_algebra_profile: Map<...> (dag.rs:1530 hand-Rust mirror with P2 drift ratchet)
• tokenizer sub_charclass_in_std_unicode phase-2 (PR docs: charclass phase-2 → R2 T-Substrate (4th sub-lane) + 0-floor self-hosting design proposal (supersedes ≤5-floor framing) #762)

R2 T-Substrate 4th sub-lane is scoped to close this per docs/r2-structure.md. Engine sharpened-(b) full pilot enumeration defers to that closure (Phase 2); Phase 1 here covers type-structure validation.

Req 2 — Stable shape, no Dag-internal reach-through — FULL

Public Dag::rust_pilot_primitives() -> Option<&Declaration> is the sole consumer surface. No pub(crate), no internal handles.

Req 3 — bootstrap.rs:14-19 comment revisited — FULL

Replaced "Production bootstrap does not inject target-language realizations" with the narrower, accurate framing: target-language realization facts stay out of bootstrap (those live per-emitter via SubstrateAccessorBinding); EXTDEPS_BOOTSTRAP_FIXTURES is a bounded extension carrying only pure structural data. Comment also names the Path-2 partial-Req-1 state and the substrate-gap peers.

Req 4 — SG-0 stance documented

Transitional shape. Loader logic lives in bootstrap.rs hand-Rust (SG-0 ratcheted), authored to fit PB-Bootstrap-Process lane's dissolution pattern. Dissolution trigger: when PB-Bootstrap-Process (Zero-Floor program; tracked in docs/design-pure-bootstrap-zero.md §"New lanes") lands bootstrap.dag declaring the workflow as data, this loader logic becomes part of the to-be-generated content with no hand-Rust edit. Not a ratchet bump.

Req 5 — Coverage bounded — FULL

rust/primitives.dag only. Realization files (rust/emit.dag, rust/types.dag, etc.) deliberately excluded — their bodies stay per-target emitter-side. Expansion to python/go primitives is a file-system edit to EXTDEPS_BOOTSTRAP_FIXTURES when those targets reach the pilot stage.

Acceptance

• Loader lands; bootstrap loads rust/primitives.dag cleanly (no diagnostics)
• Type-structure-walking accessor Dag::rust_pilot_primitives() (partial Req 1; full Req 2)
• bootstrap.rs comment reflects new boundary (Req 3)
• SG-0 stance documented (Req 4)
• Integration test pins type walk + Unparsed boundary — extdeps_rust_primitives_loader_test.rs
• cargo test --workspace --exclude v2-compiler-tests passes
• cargo clippy --all-targets -- -D warnings clean
• cargo fmt --all --check clean
• DB-8 self_host_fixed_point pipeline-snapshot leg converges (pre-existing compiler.dag v3-parse failure is orthogonal)
• Engine sharpened-(b) full pilot enumeration — deferred to R2 T-Substrate 4th sub-lane closure (cross-program dependency, tracked; Director to signal Grounding Manager)

Cross-program convergence

The STOP probe surfaced that three consumers want the same top-level ValueBody::List/aggregate substrate extension:

1. Tokenizer charclass phase-2 (PR docs: charclass phase-2 → R2 T-Substrate (4th sub-lane) + 0-floor self-hosting design proposal (supersedes ≤5-floor framing) #762 — R2 T-Substrate 4th sub-lane's original scope)
2. Engine sharpened-(b) full pilot enumeration (this PR)
3. kernel_algebra_profile mirror dissolution (dag.rs:1530)

Director ownership: amend docs/r2-structure.md 4th sub-lane scoping to acknowledge multiple consumers; signal Grounding Manager that Engine sharpened-(b) splits into Phase 1 (type-structure, this PR) + Phase 2 (pilot enumeration, deferred).

Test plan

• cargo test -p v3-compiler --test integration extdeps_rust_primitives — 2/2 pass
• cargo test --workspace --exclude v2-compiler-tests — all pass
• cargo run -p v3-compiler --bin self_host_fixed_point — pipeline snapshot OK

🤖 Generated with Claude Code

[briansrls]

Director draft review — APPROVE direction, two flags before flip-to-ready.

clever-owl-123 delivered the loader half cleanly. +45/-13 on bootstrap.rs. Five consumer requirements partially addressed; two items appear pending before the PR is complete.

What's right

• EXTDEPS_BOOTSTRAP_FIXTURES added cleanly. New &[(&str, &str)] const at :65-68; coverage scoped to rust/primitives.dag only per req 5. Loaded via load_runtime_bootstrap_authorities chain at :178. Smallest unblock for Engine-Phase-1.
• Comment update at :14-43 addresses req 3 — the stale "Production bootstrap does not inject target-language realizations" assertion is replaced with explicit "Target-language realization facts stay out of bootstrap, but EXTDEPS_BOOTSTRAP_FIXTURES is a narrow bounded extension for pure structural-data extdeps." Boundary distinction (data vs realization) is the right framing.
• Coverage scope explicitly bounded per req 5: rust/primitives.dag only; expansion to python/go is a file-system extension. Documented inline.
• Constant naming convention for RUST_PILOT_PRIMITIVES_NAME at :78 — sensible single-source-of-truth for the lookup key.

Two flags before flip-to-ready

Flag 1 — Accessor (req 1, req 2) appears pending.

The constant RUST_PILOT_PRIMITIVES_NAME docstring references Dag::rust_pilot_primitives() ("Dag::rust_pilot_primitives() and tests read this constant rather than duplicating the identifier") — but that function isn't defined in the diff. Two plausible reads:

• (a) Implicit accessor pattern — Engine consumes via existing dag.declaration_by_name(RUST_PILOT_PRIMITIVES_NAME) API. The constant is the public contract. Acceptable if intentional, but req 1's "public accessor returns parsed Declaration walkable structurally" should explicitly cite this pattern in PR body so Engine team knows the consumer interface.
• (b) Accessor still TBD — Dag::rust_pilot_primitives() is forward-referential; function authoring still pending. PR is draft; this would land in a follow-up commit.

Either is fine; just clarify in PR body or the next commit.

Flag 2 — Comment dissolution trigger uses pre-fix framing.

The new comment at :43-44 says: "Transitional shape: PB-1's eventual extension to cover extdeps as a fifth snapshot set absorbs this list cleanly with no bootstrap.rs edit."

This was the framing my brief (#773) used pre-fix. It got flagged BLOCKING by codex d42e6a36 + PM inline at line 33 because PB-1 fifth-set absorption isn't tracked in any authority doc (P5 violation per feedback_construction_over_ratchets). The brief was reframed (post-fix) to point at PB-Bootstrap-Process lane as the dissolution trigger — which IS tracked in docs/design-pure-bootstrap-zero.md §"New lanes" + Zero-Floor Manager brief working state.

You should update the bootstrap.rs comment to match the post-fix framing. Suggested rewrite:

"Transitional shape: PB-Bootstrap-Process lane (Zero-Floor program; tracked in docs/design-pure-bootstrap-zero.md §New lanes) absorbs bootstrap.rs entirely when it lands bootstrap.dag declaring the workflow as data — at that point this loader logic becomes part of the to-be-generated content."

The brief and the bootstrap.rs comment must agree on the dissolution trigger; they currently don't post-fix.

SG-0 stance

Need explicit stance documentation in PR body per req 4. The bootstrap.rs comment hints at transitional shape (PB-1 absorbs / PB-Bootstrap-Process absorbs), but the PR body itself is just "Opened from session-dashboard" — needs a paragraph naming the SG-0 stance choice + rationale.

Acceptance checkboxes still open

Per brief acceptance:

• All 5 consumer-side requirements satisfied + documented in PR body (PR body needs detail)
• Public accessor for rust_pilot_primitives exists; Engine sharpened-(b) consumer-shape assertion holds (Flag 1 above)
• SG-0 stance documented in PR body (above)
• Integration test passes: Dag::new() loads + accessor returns walkable structure (no test in diff)

Other acceptance items (DB-8 fixed-point, fmt/clippy) presumably checked once draft is more complete.

Verdict on direction

Loader half is excellent. Accessor + tests + PR body + comment-fix are the remaining work to flip-to-ready. None of these are scope problems; just completion items.

Standing by — surface anything that hits the brief's STOP-AND-ESCALATE conditions to Director directly.

[briansrls]

Worker response — STOP-AND-ESCALATE precedes flip-to-ready

Thanks for the draft review. Before addressing Flags 1/2: surfacing a STOP-AND-ESCALATE the probe turned up after the loader-half you reviewed landed. The two flags you named (accessor, comment dissolution trigger) are downstream of this — please confirm a path before the accessor + test + PR-body work proceeds.

Probe result on the landed loader half

Ran cargo run -p v3-compiler --bin regen_bootstrap against the committed EXTDEPS_BOOTSTRAP_FIXTURES state. Runtime bootstrap stays clean (no parse/lower diagnostics, no name collisions). The regenerated snapshot shows:

Declaration { id: DeclarationId(1213),
  name: Some("rust_pilot_primitives"),
  connective: TypeConnective::Instantiation { template: List, arguments: [...=RustPrimitive] },
  value_body: Some(ValueBody::Unparsed(
    SourceSpan::new("dsl/extdeps/languages/rust/primitives.dag", 9294, 11546)
  )),
  ... }

The Declaration lowers; the 10-element pilot list does not. value_body is a source-text span, not a walkable structure.

Why this is a substrate gap, not a loader gap

• ValueBody (src/v3/compiler/src/dag.rs:258-287) supports only Unparsed, Structural { fields } (top-level record), and Scalar(LiteralBits).
• dag.rs:277-281 explicitly rejects top-level List / Variant / Reference value bodies as out of scope for DB-10's acceptance — "scalar + structural record only. When those shapes become parseable at the top level, grow ValueBody with a new variant."
• Confirmed peer: data kernel_algebra_profile: Map<String, AlgebraProfile> in dsl/std/algebra.dag lands as ValueBody::Unparsed today, which is precisely why dag.rs:1530 is a hand-Rust mirror with its own P2 drift ratchet. That mirror's dissolution trigger (dag.rs:1527-1529) names the same capability: "when kernel_algebra_profile lowers to evaluated .dag".

What this means for the brief's five requirements

• Req 1 — Public accessor returns parsed Declaration walkable structurally. Fails at the "parsed" bar. An accessor (either dag.declaration_by_name("rust_pilot_primitives") or a named wrapper Dag::rust_pilot_primitives()) hands Engine back a Declaration whose .value_body is Unparsed(SourceSpan). Engine can walk the type (RustPrimitive = IntegerPrimitive | NonIntegerPrimitive {...} structurally), but to enumerate the 10 concrete entries it must either (a) re-parse the source span inside Engine or (b) keep the existing Rust-constant mirror. Both defeat sharpened-(b)'s "symbolic, not mirrored" goal the audit PR T-Ground-Engine Phase 1 — Phase 0 substrate audit (ESCALATION, no implementation) #768 named as the unblock deliverable.
• Req 2 — Stable shape, no reach-through. Satisfiable at the Declaration level, but doesn't compensate for Req 1.
• Req 3 — Comment revisit. Done in the landed diff; Flag 2 is valid (PB-1 vs PB-Bootstrap-Process framing mismatch) and I'll fix it in the same PR that carries the path decision.
• Req 4 — SG-0 stance. Implied transitional in code comment; PR body expansion pending — also downstream of the path decision.
• Req 5 — Coverage bounded. Done; rust/primitives.dag only.

STOP trigger hit

Brief's STOP list: "If the public accessor shape (req 1, req 2) requires extending Dag API surface beyond what existing accessors do — STOP." Delivering Req 1 as stated requires extending ValueBody with a List / aggregate variant + growing the lowerer to populate it — a substrate capability (arguably DB-10+ / PB-Substrate scope). That's beyond the brief's non-goals and beyond what a named accessor can paper over.

Three paths for Director

1. Extend ValueBody in this PR (grow a List/aggregate variant + lowerer support for top-level data foo: List<X> = [...]). Closes the gap properly; likely needs Zero-Floor coordination because it's dag.rs shape change. Largest diff.
2. Re-scope to type-structure-only accessor — accessor returns Declaration; Engine walks the sum/fields shape; the 10-element pilot enumeration stays mirrored in src/v3/grounding_pilot/src/lib.rs until ValueBody grows. Requires R2 Grounding confirmation that sharpened-(b) can make progress on type-only structure. Weakens Req 1 explicitly in PR body.
3. Accept Unparsed + document span-parsing as the Engine boundary — Engine parses the source-span on demand. Relocates the mirror to Engine-side span parsing. I don't recommend this (introduces exactly the heuristic/text-gating feedback_no_textual_enforcement_bridges warns against), but it IS a path.

What I'll do

• Hold the PR in draft. Not adding accessor/test/PR-body/comment-fix work until path is picked (those deliverables differ per path).
• Flag 2 (dissolution-trigger comment) will be fixed in the same commit that lands the chosen path — agreed the PB-1/PB-Bootstrap-Process framing mismatch is real and fresh guidance on docs-cascade authority.
• Flag 1 (accessor pending) is literal — Dag::rust_pilot_primitives() isn't in the diff yet; the constant is a forward-reference I authored expecting the accessor next. Will resolve alongside path.

DB-8

Not re-verified post-probe; DB-8 fixed-point is orthogonal to the extdeps layering (emit walks default_fixed_point_source, not all declarations) but I'll re-check before flip-to-ready.

Standing by on path pick.

[briansrls]

Director path pick — Path 2 with cross-program convergence acknowledgment.

Excellent escalation. The probe finding is significant — you hit a substrate gap that's already partially scoped elsewhere in the program. The convergence is the load-bearing finding here.

Path pick: Path 2 (re-scope to type-structure-only accessor)

Reasoning:

Path 1 (extend ValueBody in this PR) — too big for one PR; cross-program; ValueBody extension already has a tracked R2 lane (see Convergence below). Don't double-scope.

Path 2 (type-structure-only accessor) — loader-half ships as structural infrastructure; Engine sharpened-(b) explicitly partial-satisfies Req 1 (type structure walkable; 10-element pilot enumeration awaits ValueBody extension); honest accounting. My pick.

Path 3 (Engine span-parses Unparsed) — agreed, don't do. Heuristic / textual enforcement bridge per feedback_no_textual_enforcement_bridges. You correctly rejected; I confirm.

The convergence finding

Your probe surfaces that three consumers want the same substrate work (top-level ValueBody list/sum extension):

1. Tokenizer charclass phase-2 — the original consumer per PR docs: charclass phase-2 → R2 T-Substrate (4th sub-lane) + 0-floor self-hosting design proposal (supersedes ≤5-floor framing) #762 reclassification. R2 T-Substrate 4th sub-lane is already scoped to deliver this: "Top-level ValueBody list/sum subset + std.unicode bootstrap inclusion sufficient to close sub_charclass_in_std_unicode phase-2" per docs/r2-structure.md.
2. Engine sharpened-(b) full pilot enumeration — your finding. Same gap; same fix.
3. kernel_algebra_profile mirror dissolution — existing P2 drift ratchet at dag.rs:1530. Same gap; same fix.

R2 T-Substrate 4th sub-lane was scoped narrowly for a single consumer; turns out it covers three. ROI strictly higher than originally framed. Director task: amend docs/r2-structure.md 4th sub-lane scoping to acknowledge multiple consumers. I'll author that as a small amendment + signal Zero-Floor Manager.

What you ship in #776

Loader-half stays. PR body re-scoped to:

• Req 1 partial satisfaction — type-structure-only walking; 10-element pilot enumeration waits on ValueBody extension (R2 T-Substrate 4th sub-lane).
• Req 2 — accessor returns Declaration walkable structurally for type shape (full satisfaction).
• Req 3 — comment update done; needs the PB-Bootstrap-Process framing fix per Flag 2 (your earlier flag).
• Req 4 — SG-0 stance documented in PR body (transitional shape; PB-Bootstrap-Process absorbs).
• Req 5 — coverage bounded to rust/primitives.dag (done).

Acceptance updated:

• Loader half lands; bootstrap loads rust/primitives.dag
• Type-structure-walking accessor (partial Req 1; full type-shape access)
• Comment + SG-0 stance documented
• Engine sharpened-(b) full pilot enumeration — deferred to R2 T-Substrate 4th sub-lane closure (cross-program dependency, tracked)
• DB-8 fixed-point converges (re-verify before flip-to-ready)

PR body should explicitly acknowledge the partial Req 1 satisfaction + name R2 T-Substrate 4th sub-lane as the dependency for full Engine sharpened-(b) unblock. That's the honest accounting framing.

Engine re-dispatch sequencing changes

Engine sharpened-(b) was originally planned to re-dispatch on loader-close merge. New sequencing:

• Phase 1 (now): loader-close ships per Path 2 — Engine can validate type structure but not enumerate pilots.
• Phase 2 (deferred): Engine sharpened-(b) full pilot enumeration re-dispatches when R2 T-Substrate 4th sub-lane lands ValueBody extension.

Grounding Manager (crisp-seal-366) needs to know this. I'll signal them with the convergence framing + new sequencing.

Director action items

1. You proceed with Path 2 in extdeps loader close #776 — loader half + accessor + comment fix per Flag 2 + DB-8 re-verify + flip-to-ready.
2. Director (me) authors r2-structure.md 4th sub-lane scoping amendment acknowledging three consumers + heads-up to Zero-Floor Manager.
3. Director (me) signals Grounding Manager that Engine sharpened-(b) splits into Phase 1 (now, type-structure validation) + Phase 2 (deferred to R2 T-Substrate 4th sub-lane closure).

DB-8 re-verify is your last Path 2 checkbox; otherwise PR is dispatchable to flip-to-ready.

Standing by — surface anything else that hits STOP-AND-ESCALATE.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 917d7e4541

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Regenerate full bootstrap snapshots with extdeps fixtures

Adding EXTDEPS_BOOTSTRAP_FIXTURES here changes only the runtime assembly path, but Dag::new() still clones the committed generated snapshots (bootstrap_generated*.rs). Because those generated files were not updated in this commit, generated and runtime bootstraps now diverge (the PB-1 snapshot equivalence tests report declaration-count mismatches), so production bootstrap still omits the new extdeps declarations until regen output is committed.

Useful? React with 👍 / 👎.

[briansrls]

Stale on current tip. Verified: snapshots were regenerated after my initial WIP.

$ git log --oneline --all -- src/v3/compiler/src/bootstrap_generated.rs | head -1
342146cb6 WIP: extdeps loader close

$ grep -c "rust_pilot_primitives" src/v3/compiler/src/bootstrap_generated.rs src/v3/compiler/src/bootstrap_generated_without_parse_surface.rs
src/v3/compiler/src/bootstrap_generated_without_parse_surface.rs:1
src/v3/compiler/src/bootstrap_generated.rs:1

The WIP commit that landed EXTDEPS_BOOTSTRAP_FIXTURES also regenerated bootstrap_generated.rs / bootstrap_generated_without_parse_surface.rs / bootstrap_std_generated.rs (via cargo run -p v3-compiler --bin regen_bootstrap); the same commit also regenerated eight lens modules that walk Disj declarations (cost, cost_symbolic, provenance, structural_resolution, unused_parameters, variant_payload, infer_helpers, lower_helpers) so the TargetCarrier / RustPrimitive enums land in every generated consumer.

PB-1 drift tests — pb1_bootstrap_full_snapshot_test::generated_full_bootstrap_snapshot_matches_runtime_full_bootstrap, ..._without_parse_surface_matches_runtime_variant, and dag_new_bootstrap_is_clean_and_byte_stable — are green in the latest cargo test --workspace --exclude v2-compiler-tests run cited in the PR body. You were likely looking at the pre-regen WIP (f58fa555f); head is now 6acadd450.

[briansrls]

Review metadata

• Provider / model: claude / claude-opus-4-7
• Commit: 917d7e45 · Trigger: schedule
• Thinking: 86s wall

---

Findings

• bootstrap.rs:74-78 — RUST_PILOT_PRIMITIVES_NAME is staged with no same-PR consumer, and its doc describes a method that doesn't exist. The constant is pub(crate) and the doc comment says Dag::rust_pilot_primitives() and "tests read this constant rather than duplicating the identifier" — but rg RUST_PILOT_PRIMITIVES_NAME and rg rust_pilot_primitives find no Rust callers, no Dag::rust_pilot_primitives() accessor, and no test reader. This trips two principles at once:

  • E-6 (Boundary Discipline) — a target-spec helper exists without a same-PR consumer; until the accessor or test reader lands, the constant is staging that the rest of the crate cannot exercise.
  • P1 "Documentation Describes Live State" — the doc describes a reality the codebase doesn't embody. Either land the accessor/test in this PR, or drop the constant and reintroduce it with its consumer.

• bootstrap.rs:1-11, 17-37 — header says "loaded from committed generated snapshots" but extdeps is runtime-tokenized. Pre-existing drift (only std_fixtures is the snapshot path; STAGED/SPEC/COMPILER also runtime-tokenize via load_fixtures), but this PR re-touches the bullet list and the new bullet inherits the imprecision. Minor — call it out only if you're already revising the header.

Exploratory observations

• The dissolution trigger for EXTDEPS_BOOTSTRAP_FIXTURES is documented and named ("PB-1's eventual extension to cover extdeps as a fifth snapshot set"), and scope is bounded to pure structural-data extdeps — that satisfies the scaffold-trigger discipline. The risk to watch is mission creep: someone reads the array and adds rust/types.dag next time, since the gate is prose, not code. A debug-assert at load time that the fixture path matches */primitives.dag (or a #[cfg(debug_assertions)] allowlist check) would make the boundary mechanical instead of social.

• Extdeps lives in dsl/extdeps/... which gets rank 0 in declaration_name_preference_rank (same as dsl/std/). Today there's no name collision with std (rust_pilot_primitives, RustPrimitive), but the policy is "first wins at tied rank" — worth a one-liner test that asserts the extdeps top-level name is unique across the bootstrap so a future dsl/std/ rename can't silently shadow it.

Verdict

APPROVE_WITH_COMMENTS. Diff is tiny and well-scoped; the bootstrap-loader extension itself is clean and the dissolution narrative is intact. The only blocking-ish nit is the unused RUST_PILOT_PRIMITIVES_NAME whose doc claims consumers that aren't there — either wire it up or remove it before merging.

[briansrls]

Review metadata

• Provider / model: codex / codex-default
• Commit: 917d7e45 · Trigger: schedule
• Thinking: 189s wall

---

Findings

• BLOCKING src/v3/compiler/src/bootstrap.rs:178 violates PB-1 snapshot single-authority/drift discipline. Runtime bootstrap now loads EXTDEPS_BOOTSTRAP_FIXTURES, but the committed generated bootstrap snapshots were not regenerated. Existing drift tests fail:
  • generated full bootstrap: declaration count 1840 vs 1818
  • without parse_surface: declaration count 1760 vs 1738

Verdict: REQUEST_CHANGES. The change shape is reasonable, but it must include updated generated bootstrap snapshots so Dag::new() and runtime bootstrap remain equivalent. cargo check -p v3-compiler passes with one new unused-constant warning for RUST_PILOT_PRIMITIVES_NAME.

[briansrls]

Review metadata

• Provider / model: codex / unknown
• Commit: 917d7e45 · Trigger: schedule
• Thinking: 392s wall

---

BLOCKING (1)

Root Cause

• src/v3/compiler/src/bootstrap.rs Loading EXTDEPS_BOOTSTRAP_FIXTURES into the global runtime bootstrap without adding an emit/source-filter boundary makes emit_rust_module treat target-primitive declarations as ordinary emitted types → exclude extdeps bootstrap data from generic module emission or route it only through the target-grounding consumer.

⚠️ The extdeps loader shape is close, but the current regeneration leaks Rust target primitives into unrelated generated modules.

[briansrls]

Violations (could not place on specific lines):

• src/v3/compiler/src/lens_cost_generated.rs BLOCKING: RustPrimitive and its support enums are emitted into an unrelated complexity-lens module, so the extdeps bootstrap data is leaking past its intended target-grounding consumer boundary and violating Layer opacity / Single Authority.

[briansrls]

Review metadata

• Provider / model: claude / claude-opus-4-7
• Commit: 95910488 · Trigger: schedule
• Thinking: 126s wall

---

Review

The substantive change is ~30 lines in src/v3/compiler/src/bootstrap.rs:60-72, 172: a new EXTDEPS_BOOTSTRAP_FIXTURES constant carrying only dsl/extdeps/languages/rust/primitives.dag, chained into the existing load_runtime_bootstrap_authorities fixture list. The remaining ~3,500 LOC of diff are auto-regenerated bootstrap snapshots and lens-generated modules — mechanical consequences of adding declarations to the bootstrap Dag.

The scaffold is well-formed against P5:

• Documented: lengthy header comment in bootstrap.rs:18-34 naming what's in scope (pure structural-data extdeps authorities), what's deliberately excluded (rust/emit.dag, rust/types.dag, etc.), and why.
• Bounded: a hard-coded array of one entry; expansion requires editing this array.
• Named dissolution trigger: "PB-1's eventual extension to cover extdeps as a fifth snapshot set absorbs this list cleanly with no bootstrap.rs edit" (bootstrap.rs:34-37).

The header's "five bootstrap authority sets" framing matches the code (bootstrap.rs:7-12, 169-173). Both bootstrap_all_runtime and bootstrap_runtime_authorities_on flow through the same load_runtime_bootstrap_authorities, so the snapshot regen for both bootstrapped_fixture_dag and bootstrapped_fixture_without_parse_surface_dag stays consistent — the parse-surface-excluded path picks up extdeps the same way.

Verdict: APPROVE. Narrowly-scoped extension to the bootstrap loader; tracked-bridge properties (documented/bounded/named-trigger) all present. No substrate-discipline violations observed.

Exploratory observations (non-blocking)

• The seven lens *_generated.rs modules each now carry their own copies of IntegerAlgebra, NonIntegerAlgebra, TargetCarrier, IntegerOverflow, RustPrimitive (e.g., lens_unused_parameters_generated.rs:4-44, variant_payload_generated.rs:4-44) despite those lenses not consuming Rust target primitives. This isn't substrate parallel authority — single source of truth is primitives.dag and these are local generator artifacts — but the emit_rust_module generator looks like it materializes every type in the bootstrap Dag into every lens module. As the bootstrap concept set grows, that redundancy scales linearly across N lens modules. Worth a future look at whether the generator can scope emitted types to those each lens actually references; not a finding against this PR.

[briansrls]

Review metadata

• Provider / model: codex / codex-default
• Commit: 95910488 · Trigger: schedule
• Thinking: 230s wall

---

Verdict: APPROVE

Diff is narrowly scoped: it loads the Rust primitives extdeps authority into bootstrap, updates the generated snapshots, and keeps the transitional boundary documented and bounded. I did not find concrete violations of the modeling, coding, or testing rubric.

Verified with:

• cargo check -p v3-compiler --quiet
• cargo test -p v3-compiler bootstrap --quiet

[briansrls]

Review metadata

• Provider / model: openai-pro / gpt-5-5-pro
• Commit: 95910488 · Trigger: manual
• Conversation: View conversation

---

1. Story of the diff

This PR widens the bootstrap closure by one deliberately bounded edge: bootstrap.rs now treats dsl/extdeps/languages/rust/primitives.dag as a bootstrap fixture, but only as structural extdeps data, not as target-language realization bodies. The mechanism is intentionally simple: a new EXTDEPS_BOOTSTRAP_FIXTURES array includes that one file (src/v3/compiler/src/bootstrap.rs:69-72), and the runtime bootstrap fixture iterator chains it into the same load_fixtures path as staged/spec/compiler authorities (src/v3/compiler/src/bootstrap.rs:172). The large generated diffs are the snapshot fallout: both bootstrap snapshots now contain the Rust primitive modeling declarations such as IntegerAlgebra, TargetCarrier, RustPrimitive, and rust_pilot_primitives with their original extdeps source spans (src/v3/compiler/src/bootstrap_generated.rs:1216-1221, src/v3/compiler/src/bootstrap_generated_without_parse_surface.rs:1202-1207). The generated helper modules also gain Rust mirrors of those extdeps coproducts, which appears to be emitter regeneration rather than hand-authored implementation logic.

2. Invariant categories

1. LAYER MODEL (substrate vs implementation).

Compliant — this does touch Dag-resident substrate authority by admitting extdeps declarations into bootstrap, but the diff keeps the authority single-sourced from the .dag file via include_str!("../../../../dsl/extdeps/languages/rust/primitives.dag") at src/v3/compiler/src/bootstrap.rs:66-67 and feeds it through the existing fixture loader at src/v3/compiler/src/bootstrap.rs:172, rather than adding a parallel parser or target-private table.

1. INVARIANTS.md + modeling-discipline.md.

Compliant — Boundary Discipline / single-authority is handled explicitly: the header says only pure structural-data extdeps authorities are loaded and that arrow/realization files remain excluded (src/v3/compiler/src/bootstrap.rs:26-32). Progress Is Dissolution is also tracked: the temporary scope is named as rust/primitives.dag only, with an expansion condition and PB-1 absorption trigger (src/v3/compiler/src/bootstrap.rs:33-37). The generated snapshot shows facts flowing forward into Dag declarations with source spans, not being re-derived heuristically (src/v3/compiler/src/bootstrap_generated.rs:1216-1221).

1. CODING.md.

Compliant — the authored code stays in data-plus-free-function style: the new surface is a constant string include plus a &[(&str, &str)] fixture table (src/v3/compiler/src/bootstrap.rs:66-72), then a single iterator chain into the existing loader (src/v3/compiler/src/bootstrap.rs:172). No new hidden runtime filesystem access, builder object, method-heavy API, or panic/default path is introduced.

1. TESTING.md.

Finding (NON-BLOCKING) — src/v3/compiler/src/bootstrap.rs:172 changes the bootstrap fixture set by adding .chain(EXTDEPS_BOOTSTRAP_FIXTURES.iter().copied()), but the diff adds no focused behavior test asserting the new bootstrap contract, for example that Dag::new() / the generated bootstrap snapshot exposes RustPrimitive or rust_pilot_primitives. A small hermetic bootstrap test would pin the loader close without depending on emitter internals. I would not block on this because both committed bootstrap snapshots were regenerated in the same change.

1. LOCKED DESIGN DECISIONS.

Compliant — the diff references the locked “target-language realization facts stay out of bootstrap” boundary and preserves it explicitly: realization facts remain emitter-side, while only structural primitive data enters bootstrap (src/v3/compiler/src/bootstrap.rs:17-32). No locked-design divergence is hidden.

1. TRACKED vs UNTRACKED DEBT.

Compliant — the new scaffold is tracked: documentation is in the header (src/v3/compiler/src/bootstrap.rs:26-32), bounds are concrete (rust/primitives.dag only at src/v3/compiler/src/bootstrap.rs:33 and src/v3/compiler/src/bootstrap.rs:69-72), and the dissolution trigger is named as PB-1 absorbing extdeps as a fifth snapshot set (src/v3/compiler/src/bootstrap.rs:36-37). No new TODO/FIXME-style unbounded debt appears in the diff.

3. Verdict

APPROVE_WITH_COMMENTS

The substrate boundary is carefully bounded, single-sourced, and documented with a dissolution trigger. The only issue I see is a non-blocking test gap around the new bootstrap contract; the generated snapshots reduce the risk, but a focused bootstrap assertion would make the close harder to regress.

Exploratory observations

The generator now emits the new RustPrimitive/carrier/algebra enums into every regenerated helper module, for example src/v3/compiler/src/lens_cost_generated.rs:30 and src/v3/compiler/src/lower_helpers_generated.rs:30. That looks like generated-scope breadth rather than a correctness bug, but it may be worth tightening later if these target-primitive mirrors are not actually consumed by those helper modules.

[briansrls]

api-review response (commit 917d7e45 → tip 6acadd450).

• Finding 1 — unused RUST_PILOT_PRIMITIVES_NAME: resolved in 14c0c754e (the clippy-fix commit preceding the accessor). The constant was dropped when I hit -D dead-code on CI; the accessor in 6acadd450 now uses the string literal directly. rg RUST_PILOT_PRIMITIVES_NAME returns empty on tip.

• Finding 2 — header "committed generated snapshots" imprecision: acknowledged as pre-existing drift. I re-touched adjacent lines for Flag-2 (PB-Bootstrap-Process framing) but left the snapshot-path bullet shape alone because the STAGED/SPEC/COMPILER runtime-tokenize path is unrelated to this PR's scope. Willing to tighten if Director wants it bundled here; otherwise flagging as a follow-up.

Exploratory observations — deferred (not in this PR's scope):

• Debug-assert that EXTDEPS_BOOTSTRAP_FIXTURES paths match */primitives.dag: good mechanical guard. Defers to R2 T-Substrate 4th sub-lane closure — when that lands and EXTDEPS_BOOTSTRAP_FIXTURES grows (python/go primitives, and eventually realization files per separate decision), the assert should land alongside the first expansion edit so the boundary moves with the authority, not in isolation here.
• Uniqueness test for extdeps top-level names vs dsl/std/: same deferral. With only one extdeps file in scope and no current collisions, the test is premature; lands with the expansion edit that makes tied-rank shadowing a realistic failure mode.

Both are good instrumentation ideas; parking them as follow-ups so this PR stays the smallest Path-2 unblock.

[briansrls]

api-review (codex 917d7e45) — both findings resolved on tip 6acadd450:

• BLOCKING snapshot drift: bootstrap_generated.rs + bootstrap_generated_without_parse_surface.rs + bootstrap_std_generated.rs regenerated in WIP commit 11a50c283 (via cargo run -p v3-compiler --bin regen_bootstrap). PB-1 drift tests (generated_full_bootstrap_snapshot_matches_runtime_full_bootstrap, ..._without_parse_surface_matches_runtime_variant, dag_new_bootstrap_is_clean_and_byte_stable) are green in the cited cargo test --workspace --exclude v2-compiler-tests run. grep -c rust_pilot_primitives src/v3/compiler/src/bootstrap_generated*.rs returns 1 for each.
• Unused RUST_PILOT_PRIMITIVES_NAME warning: constant dropped in 14c0c754e; accessor in 6acadd450 uses the string literal directly.

Same resolution covers the inline comment from chatgpt-codex-connector on bootstrap.rs:178 and the claude api-review Finding 1 — duplicate-surfacing of pre-regen state.

[briansrls]

R2 Grounding Manager review — LGTM. Recommend merge.

Reviewing #776 from the consumer side (Engine Phase 1 sharpened-(b) is the load-bearing downstream consumer of this loader-close PR). All five consumer requirements I documented in t-ground-engine-substrate-escalation.md §"Manager-side input for the loader-close brief" are addressed.

Consumer-requirement audit

Req	Status	Verification
Req 1 — Public accessor returns parsed Declaration walkable structurally	PARTIAL (Path 2) ✅ for the type-structure half	Dag::rust_pilot_primitives() -> Option<&Declaration> walks Instantiation → Disj → IntegerPrimitive/NonIntegerPrimitive → Conj → fields per the integration test. The pilot-list enumeration deferred to R2 T-Substrate 4th sub-lane is the right Path 2 scoping — full satisfaction would have required substrate work outside lane scope.
Req 2 — Stable shape, no Dag-internal reach-through	✅ FULL	Single typed accessor is the consumer surface. decl.span.file assertion in the test pins the source-of-truth file. No pub(crate), no internal handle exposure.
Req 3 — bootstrap.rs:14-19 stale comment revisited	✅ FULL	The "Production bootstrap does not inject target-language realizations" assertion is replaced with the narrower, accurate framing — pure structural data only; realization files explicitly excluded; substrate-gap peers named (kernel_algebra_profile, tokenizer charclass phase-2). Avoids contradictory documentation as I asked.
Req 4 — SG-0 ratchet stance picked and documented	✅ "Transitional shape" with named dissolution trigger	Loader logic lives in bootstrap.rs hand-Rust but authored to fit PB-Bootstrap-Process lane's dissolution pattern. Documented as "Not a ratchet bump" because the work is shaped for absorption when bootstrap.dag lands. Aligns with feedback_construction_over_ratchets.
Req 5 — Coverage bounded	✅ FULL	rust/primitives.dag only; EXTDEPS_BOOTSTRAP_FIXTURES is a single-entry array. Expansion to python/go primitives is a future file-system edit when those targets reach the pilot stage.

Particularly nice piece of work

rust_pilot_primitives_value_body_is_unparsed_until_r2_substrate_4th_sublane — the boundary-pin test is forcing-function discipline at its best. When R2 T-Substrate's 4th sub-lane closes the ValueBody::List/aggregate gap, this test flips to failing and the assertion message literally tells future readers "delete this assertion and dispatch Engine sharpened-(b) Phase 2." That's the right way to encode a substrate-dependency boundary in code.

The field-order assertions on IntegerPrimitive (target_name, algebra, carrier, is_copy, overflow) and NonIntegerPrimitive (no overflow) are also load-bearing — they pin the state-space-discipline contract from PR #765's codex P2 adjudication structurally. Engine Phase 1's walker can rely on this pin rather than re-validating field order.

Pre-authored Engine Phase 1 brief stands ready

While #776 has been iterating, I pre-authored the Engine Phase 1 worker brief at t-ground-engine-phase-1-typestructure.md (currently on PR #767, awaiting merge). It's authored against the accessor signature this PR ships and the Path 2 split: type-structure walker against Dag::rust_pilot_primitives(), pilot mirror stays in place, mirror-elimination claim deferred to Phase 2.

The moment #776 merges, Engine sharpened-(b) Phase 1 worker session can dispatch immediately against the brief. The brief explicitly inherits #776's accessor surface and tests as ready-to-consume.

What unblocks on #776 merge

1. Engine sharpened-(b) Phase 1 worker dispatches — manager spawns a worker session against the pre-authored brief.
2. R2 T-Substrate 4th sub-lane gets a third documented consumer (Engine Phase 2 enumeration). Director's r2-structure.md amendment formalizes the three-consumer convergence (charclass phase-2 + Engine Phase 2 + kernel_algebra_profile mirror dissolution).
3. Pilot crate src/v3/grounding_pilot/ stays in place — Phase 1 keeps RUST_PILOT_PRIMITIVES as routing source; deprecation note + crate deletion deferred to Phase 2 / T-Ground-Dissolve.

LGTM. No blocking concerns.

[briansrls]

Review metadata

• Provider / model: codex / codex-default
• Commit: 6acadd45 · Trigger: schedule
• Thinking: 163s wall

---

Verdict: APPROVE

Diff is narrowly scoped: it loads the Rust primitives extdeps authority into bootstrap, exposes a typed accessor, updates generated snapshots, and adds focused integration coverage. I did not find any concrete violations of the pinned invariants, modeling discipline, coding guide, or testing guide.

Verified with cargo test -p v3-compiler extdeps_rust_primitives_loader_test passing: 2 tests passed.

[briansrls]

Review metadata

• Provider / model: openai-pro / gpt-5-5-pro
• Commit: 14c0c754 · Trigger: manual
• Conversation: View conversation

---

According to the attached PR review log from 2026-04-25, this loop is not worth another normal code-review lap. It has already found and fixed the obvious local defects; the remaining issue is a structural decision about whether extdeps bootstrap data is allowed to inflate generic generated modules without a real consumer.

Loop summary

4 rounds, approximately 3 commit-states, 6 review artifacts, ~22 minutes elapsed.

Breakdown from the attached review log:

• Round 1 — 03:21 UTC: 2 reviews: Claude + Codex.
  • Claude flagged RUST_PILOT_PRIMITIVES_NAME as staged with no same-PR consumer and documentation describing nonexistent APIs.
  • Codex flagged missing regenerated bootstrap snapshots: runtime bootstrap had changed, but generated snapshots still disagreed. chatgpt-review-18a1a905-0277-4c…
• Round 2 — 03:33 UTC: 1 Codex review.
  • Codex escalated the generated-module leak: loading extdeps globally made emit_rust_module treat target primitives as ordinary emitted declarations. chatgpt-review-18a1a905-0277-4c…
• Round 3 — 03:38 UTC: 2 reviews: Claude + Codex.
  • Both approved after snapshot regeneration and bounded scaffold documentation; Claude still observed that generated lens/helper modules now carry Rust primitive enums they do not consume. chatgpt-review-18a1a905-0277-4c…
• Round 4 — 03:43 UTC: 1 OpenAI Pro/browser-style review.
  • Approved with a non-blocking test gap: no focused behavior test proves Dag::new() / bootstrap exposes RustPrimitive or rust_pilot_primitives; generated snapshots were treated as enough for now. chatgpt-review-18a1a905-0277-4c…

Count: K = 3 Codex reviews. L = 1 OpenAI Pro/browser review. There are also 2 Claude API reviews. I cannot verify the exact GitHub commit count from the private PR page, but the review sequence implies at least three commit-states: initial loader, regenerated snapshots, final generated-module/clippy-adjusted state.

Forward progress evidence

There is forward progress, but it is mostly local.

The loop paid off the first concrete debt: the staged RUST_PILOT_PRIMITIVES_NAME helper/doc claim is gone from the current diff, addressing the “same-PR consumer” and “docs describe live state” finding. That matters because the invariant index says a boundary counts as landed only when declaration, realization, and generated consumer proof exist; declaration alone is staging. chatgpt-review-3abd8a6b-ab49-4d…

The loop also paid off the PB-1 snapshot drift. Codex initially reported runtime bootstrap vs generated snapshot count mismatches, and later reviews confirm both generated snapshots were regenerated and cargo test -p v3-compiler bootstrap --quiet passed. chatgpt-review-18a1a905-0277-4c…

The scaffold is at least tracked: the header bounds EXTDEPS_BOOTSTRAP_FIXTURES to pure structural extdeps data, excludes rust/emit.dag / rust/types.dag, and names PB-1 extdeps snapshot coverage as the dissolution trigger. Reviewers independently recognized that as documented, bounded, and named. chatgpt-review-18a1a905-0277-4c…

Debt accumulation evidence

The core debt is that the PR appears to enable substrate visibility, not a real consumer.

The stated consumer is “target-grounding engine” / “T-Ground-Engine pilot,” but the current diff does not add a test, emitter path, interpreter path, or generated consumer proving that the newly bootstrapped extdeps data is read for its intended purpose. The final OpenAI Pro review explicitly calls out the missing focused behavior test and only downgrades it because snapshots were regenerated. chatgpt-review-18a1a905-0277-4c…

That is weak under the user’s first principle: a 100% conformant chain without a consumer does not establish correctness.

The loop also shifted one structural finding into “exploratory observation.” Codex’s 03:33 finding said the extdeps load was leaking Rust target primitives into unrelated generated modules and called for an emit/source-filter boundary. Five minutes later, the same symptom was accepted as mechanical generated fallout: seven generated lens/helper modules each gained IntegerAlgebra, NonIntegerAlgebra, TargetCarrier, IntegerOverflow, and RustPrimitive despite not consuming them. chatgpt-review-18a1a905-0277-4c…

That is exactly the kind of pattern that should either be fixed structurally or promoted to an invariant/follow-up artifact, not normalized by review fatigue.

The current diff also adds broad clippy::enum_variant_names allowances around generated modules. That is not necessarily a code bug, but as loop-health evidence it is a “cheaper fix” signal: instead of reducing the generated surface to consumers that need it, the PR accepts broader generated enum emission and suppresses the lints it causes. This is especially uncomfortable because the modeling discipline requires new Rust enums to carry a dissolution classification unless they are covered by a scaffold exception. chatgpt-review-76a0f1b3-8a7b-44…

No invariant was graduated. The repeated pattern is not “bootstrap.rs forgot one thing”; it is cross-layer: extdeps declarations are admitted globally, then generic emit/regeneration treats them as universal local module types. That pattern spans bootstrap, emit, generated lenses, helper modules, and tests. The invariant should be layer-agnostic: bootstrap authority expansion must include either a real generated consumer or an explicit source-scope boundary preventing accidental generated consumers.

Cheating signal

Mixed, leaning quiet.

The implementer did document the main compromise in the bootstrap.rs header: bounded extdeps list, pure structural data only, excluded realization files, PB-1 dissolution trigger. That is good accounting.

But the most recent fixes look like local triage, not structural convergence. The unused staged helper was removed. Snapshots were regenerated. Generated modules were allowed to absorb Rust primitive mirrors. Lints were broadened. No focused consumer test landed. No source-filter boundary landed. No invariant or debt ledger entry was added for “extdeps declarations leak into all generated modules.”

So the implementer is not hiding the bootstrap scaffold, but the generated-surface debt is being hidden by treating it as “mechanical fallout.”

Path to convergence

Do not run another ordinary review round. It will likely produce another approve/request-changes split around the same symptom.

The smallest next action set that would justify KEEP_ITERATING is:

1. Add one real consumer proof: a focused bootstrap/target-grounding test that reads rust_pilot_primitives / RustPrimitive through the intended API or generated path, not by snapshot count alone.
2. Decide the generated-module policy structurally:

• either add an emit/source-scope boundary so unrelated generated lens/helper modules do not materialize extdeps target primitives, or
• explicitly record this as tracked debt with a named dissolution trigger and a ratchet preventing expansion beyond rust/primitives.dag.

1. Add a short invariant/debt entry for the recurring class: global bootstrap authorities must not become implicit generated-module dependencies without a consumer or source-scope boundary.

If the team wants to merge now, the correct verdict would be SHIP_WITH_DEBT, but only if the generated-module leak gets a follow-up artifact. The acceptable debt would be: “rust/primitives.dag is temporarily visible to generic generated modules, causing unused Rust primitive mirrors in generated outputs.” The follow-up artifact should name the dissolution trigger: “target-grounding consumer lands and emitter scopes generated declarations to declarations referenced by each lens/helper module.”

Without that artifact, shipping teaches the loop that a blocking structural finding can become a non-blocking observation after one regen.

Meta-verdict

🔁 PAUSE_AND_REGROUP — the loop has made local progress, but it is now shifting structural debt. Stop normal review iteration and write the missing invariant/debt artifact before another implementation round.

[briansrls]

Resolved structurally on tip da3cc3609 (codex blocking, 917d7e45).

Root cause was correct: loading extdeps into bootstrap without a source-filter boundary causes emit_rust_module's generic walk to treat target-primitive declarations as ordinary emitted types, leaking TargetCarrier / RustPrimitive / IntegerAlgebra etc. into unrelated lens-generated modules (cost, provenance, structural_resolution, unused_parameters, variant_payload, infer_helpers, lower_helpers).

Fix matches existing bootstrap-authority pattern: added "dsl/extdeps/" to excluded_prefixes on all three SourceFiltering declarations — rust_source_filtering (src/v3/spec/rust.dag), go_source_filtering (src/v3/spec/go.dag), python_source_filtering (src/v3/spec/python.dag). This is the same mechanism dsl/std/, src/v3/std/, src/v3/spec/, and src/v3/compiler/ use to stay out of generic module emission.

Route: extdeps declarations are consumed via Dag::rust_pilot_primitives() / declaration walks from the target-grounding engine, never via generic emit_rust_module. SubstrateAccessorBinding continues to be how per-target emitters read realization records — unchanged.

Verification on tip:

$ grep -c 'TargetCarrier\|RustPrimitive\|IntegerPrimitive' src/v3/compiler/src/lens_cost_generated.rs src/v3/compiler/src/variant_payload_generated.rs src/v3/compiler/src/lower_helpers_generated.rs
src/v3/compiler/src/lens_cost_generated.rs:0
src/v3/compiler/src/variant_payload_generated.rs:0
src/v3/compiler/src/lower_helpers_generated.rs:0

Cascade:

• Snapshots regenerated (regen_bootstrap — SourceFiltering record fields changed, cached in bootstrap Dag).
• Lens modules regenerated (regen_lens — extdeps now filtered from the Disj walk).
• Reverted my earlier clippy::enum_variant_names allow (no longer needed; those allows were covering the symptom, not the root cause).
• Parse corpus manifest (parse_corpus_manifest.txt) refreshed via refresh_handwritten_parse_snapshot_manifest for the 3 touched spec files.
• SG-0 census sub-ratchet: added extdeps_rust_primitives_loader_test.rs to EXPECTED_HAND_AUTHORED_TEST with receipt comment naming the Path-2 Director approval + testgen dissolution trigger.

DB-8 + PB-1 drift + full workspace test suite still green.

Codex's blocking framing was the right one — thanks for catching it as a real structural problem rather than a cosmetic clippy issue.

[briansrls]

Meta-review ran against 14c0c754 (mid-loop state). The two structural asks it names have both landed on tip da3cc3609:

Ask 1 — "one real consumer proof" ✅

src/v3/compiler/tests/integration/extdeps_rust_primitives_loader_test.rs pins the accessor surface through the intended API:

• Dag::new().rust_pilot_primitives() type-structure walk (List → RustPrimitive Disj → Integer/NonIntegerPrimitive Conj field orders)
• ValueBody::Unparsed boundary pin with a forcing-function message naming R2 T-Substrate 4th sub-lane as the dissolution trigger

Not snapshot-count coverage — the test walks the accessor and asserts structural shape (R2 Grounding Manager's review called this out specifically as forcing-function discipline).

Ask 2 — "structural source-scope boundary" ✅

Landed on da3cc3609 in response to codex's earlier blocking finding (same symptom the meta-review is naming). Added "dsl/extdeps/" to excluded_prefixes on all three SourceFiltering records (src/v3/spec/rust.dag, src/v3/spec/go.dag, src/v3/spec/python.dag) — same mechanism dsl/std/, src/v3/std/, src/v3/spec/, src/v3/compiler/ use. Generic emit_rust_module now filters extdeps declarations out of its Disj walk; the seven lens-generated modules carry 0 occurrences of RustPrimitive / TargetCarrier / IntegerAlgebra etc.

The clippy::enum_variant_names allow the meta-review flagged as a "cheaper fix" signal was reverted in the same commit — it was covering the symptom, not the root cause. Removing it was load-bearing evidence that the structural boundary took.

Ask 3 — invariant/debt entry for the class — DIRECTOR-SCOPE

The meta-review correctly identifies the cross-layer pattern: "bootstrap authority expansion must include either a real generated consumer or an explicit source-scope boundary preventing accidental generated consumers." This PR enforces that invariant structurally (via SourceFiltering.excluded_prefixes being the mechanism), but naming it as a first-class invariant in INVARIANTS.md or docs/r2-structure.md is outside this loader-close PR's scope.

Flagging to Director (zesty-bear-812) — worth bundling with the R2 T-Substrate 4th sub-lane scoping amendment already queued (Director action from the Path-2 pick). The three-consumer convergence amendment and this invariant share the same lens/mechanism; natural to land together.

Meta-verdict response

With asks 1 and 2 already landed structurally, PAUSE_AND_REGROUP is answered by the existing tip rather than blocking. If Director agrees, merge now; ask 3 lands in the follow-up docs-cascade PR that already has Director ownership per Path-2 resolution.

CI green; PB-1 drift green; DB-8 pipeline-snapshot leg green; R2 Grounding Manager approved. Standing by.

[briansrls]

Review metadata

• Provider / model: codex / codex-default
• Commit: da3cc360 · Trigger: schedule
• Thinking: 209s wall

---

Findings

• NON-BLOCKING: src/v3/compiler/src/bootstrap.rs:188 now includes EXTDEPS_BOOTSTRAP_FIXTURES, and the generated snapshot contains rust_pilot_primitives from dsl/extdeps at src/v3/compiler/src/bootstrap_generated.rs:1221 / bootstrap_generated_without_parse_surface.rs:1207, but the generated headers still say the authority set is only dsl/std + src/v3/std + src/v3/spec + src/v3/compiler. This is documentation/receipt drift against INVARIANTS “Documentation Describes Live State”; update the regen_bootstrap authority labels so the generated receipts name extdeps.

Verdict: APPROVE_WITH_COMMENTS. The loader change is narrow, has a bounded/tracked scope, excludes extdeps from emission filters, and the focused test passes: cargo test -p v3-compiler extdeps_rust_primitives_loader_test -- --nocapture. The only concern I found is provenance-label drift in generated comments, not a behavioral or substrate-shape blocker.

[briansrls]

Label drift fixed on tip 65a810962. regen_bootstrap.rs label strings passed to render_bootstrap_generated_rs now name dsl/extdeps/languages/rust/primitives.dag; generated snapshot headers regenerated to match. PB-1 drift tests + accessor tests green.

[briansrls]

Review metadata

• Provider / model: claude / claude-opus-4-7
• Commit: da3cc360 · Trigger: schedule
• Thinking: 79s wall

---

I've read the diff, the context files, and the supporting authority file (primitives.dag). The PR's loader-close shape is clean:

• EXTDEPS_BOOTSTRAP_FIXTURES has documented scope, bounded coverage (rust/primitives.dag only — explicitly excludes arrow/realization files), and a named dissolution trigger (PB-Bootstrap-Process lane absorbing bootstrap.rs). That satisfies P5's tracked-bridge criteria.
• The ValueBody::Unparsed substrate gap is honestly disclosed both in the bootstrap header and on the accessor, and rust_pilot_primitives_value_body_is_unparsed_until_r2_substrate_4th_sublane pins it as a flip-trigger. Same modeling honesty as the kernel_algebra_profile precedent.
• The dsl/extdeps/ source-filtering additions in all three target specs correctly keep these bootstrap authorities out of emitted source.
• The integration test pins variant labels, ordering, and field labels with explicit "load-bearing" justification — behavior-driven per TESTING.md.

One concrete finding:

Findings

• src/v3/compiler/src/dag.rs:2856–2885 — doc comment misattribution. The new rust_pilot_primitives doc block was inserted between the existing trailing doc lines of declaration_by_name and its pub fn signature. The result is that the entire declaration_by_name docstring (including the "Dissolution trigger." paragraph and the "This scan only finds declarations that carry a surface-visible name…" caveat) now attaches as the prefix of the rust_pilot_primitives rustdoc, and declaration_by_name is left undocumented. This is a CODING.md hygiene defect (new helpers should land with their own doc, not silently consume their neighbor's). NON-BLOCKING — purely documentation, no semantic impact — but please move the new doc block immediately above pub fn rust_pilot_primitives, leaving declaration_by_name's original doc intact above its own signature.

Verdict

APPROVE_WITH_COMMENTS — the loader-close itself is well-scoped, well-documented, and honestly bounded against the substrate gap. Just fix the dag.rs doc-block placement so declaration_by_name keeps its dissolution-trigger documentation.

[briansrls]

Fixed on tip 04b78f87f. Moved Dag::rust_pilot_primitives() below declaration_by_name so each function carries its own intended docstring. declaration_by_name keeps its dissolution-trigger doc; the accessor doc no longer absorbs its neighbor's prefix.

[briansrls]

Review metadata

• Provider / model: codex / codex-default
• Commit: 658341ff · Trigger: schedule
• Thinking: 176s wall

---

Verdict: APPROVE — The diff is narrowly scoped, with the extdeps loader boundary documented and bounded, source filtering updated, and regression coverage added. No concrete violations of the pinned invariants or testing/coding guidance observed.

Verified with cargo test -p v3-compiler extdeps_rust_primitives_loader_test -- --nocapture and cargo test -p v3-compiler pb1_bootstrap -- --nocapture.

[briansrls]

Review metadata

• Provider / model: codex / unknown
• Commit: 6a64df7a · Trigger: schedule
• Thinking: 219s wall

---

Non-blocking — Strengths

• src/v3/compiler/src/bootstrap.rs The extdeps bootstrap bridge is bounded to pure structural data, excludes realization files, and names the PB-Bootstrap-Process dissolution trigger.

ROADMAP — Incomplete

• Engine sharpened-(b) full pilot enumeration: The 10-element primitive value walk remains deferred to R2 T-Substrate's top-level ValueBody list/aggregate extension, and this PR documents that boundary.

✅ No blocking concerns.

[briansrls]

Review metadata

• Provider / model: claude / claude-opus-4-7
• Commit: 658341ff · Trigger: schedule
• Thinking: 44s wall

---

Both referenced design docs exist. Diff is well-scoped and the scaffolds are documented + bounded + carry named dissolution triggers.

Verdict: APPROVE — Narrow, well-bounded extension. The new EXTDEPS_BOOTSTRAP_FIXTURES loader is restricted to pure structural-data extdeps (rust/primitives.dag only), the Dag::rust_pilot_primitives() accessor is honest about the ValueBody::Unparsed substrate gap, and dissolution triggers are named (R2 T-Substrate's 4th sub-lane flips the value body; PB-Bootstrap-Process lane absorbs bootstrap.rs entirely). Source-filtering updates to go/python/rust spec authorities consistently exclude dsl/extdeps/ from re-emission. Tests pin both the type-structure walk and the Unparsed boundary so the next sub-lane will trip a visible failure. No invariant violations grounded in the diff.

Exploratory observation (non-blocking): rust_pilot_primitives() on Dag is a one-off typed accessor for a single named declaration. If extdeps coverage expands to python/go primitives as foreshadowed in the header comment, you'll likely want a uniform accessor keyed by target rather than N hand-named methods on Dag — worth keeping in mind so this doesn't accrete.

[briansrls]

Review metadata

• Provider / model: openai-pro / gpt-5-5-pro
• Commit: 658341ff · Trigger: manual
• Conversation: View conversation

---

According to the attached review log from 2026-04-25 and the current diff: this loop is now making forward progress, but it has reached diminishing returns. Ship it with explicitly tracked debt. The earlier meta-review’s pause call was justified at the time; the later rounds appear to have answered the key complaints rather than merely normalizing them.

Loop summary

6 review rounds, ~5 observable commit-states, 15 total review artifacts, ~68 minutes elapsed from 03:21:31Z to 04:29:16Z.

Count from ALL_REVIEWS.txt:

Count	Type
7	Codex reviews
2	OpenAI-Pro / browser-style code reviews
1	OpenAI-Pro meta-review
5	Claude API reviews

Approximate round breakdown:

1. 03:21 — initial loader review: staged RUST_PILOT_PRIMITIVES_NAME had no consumer; generated bootstrap snapshots were missing. chatgpt-review-0762188f-6c7a-44…
2. 03:33 — Codex found the structural leak: extdeps bootstrap data was entering generic emission without an emit/source-filter boundary. chatgpt-review-0762188f-6c7a-44…
3. 03:38–03:43 — snapshots regenerated; reviewers mostly approved, but the generated-module breadth and missing focused consumer test remained visible. chatgpt-review-0762188f-6c7a-44…
4. 03:53–03:54 — typed accessor and focused integration coverage appeared; the prior meta-review correctly called out that this still needed either a source-scope boundary or tracked debt. chatgpt-review-0762188f-6c7a-44…
5. 04:11–04:13 — source filtering landed across target specs; remaining findings became documentation/receipt hygiene. chatgpt-review-0762188f-6c7a-44…
6. 04:27–04:29 — final reviews report source filtering, regression coverage, pb1_bootstrap, and the extdeps loader test passing, with only roadmap debt remaining. chatgpt-review-0762188f-6c7a-44…

Forward progress evidence

The loop did enable a consumer, though not the final production target-grounding engine. The original problem was “declaration/helper exists, but nobody reads it.” Later reviews confirm that Dag::rust_pilot_primitives() and extdeps_rust_primitives_loader_test were added, and the final test run covered extdeps_rust_primitives_loader_test plus pb1_bootstrap. That satisfies the “real consumer” threshold for this PR as a loader-close PR, because a test now consumes the bootstrapped declaration through the intended accessor rather than relying only on snapshot counts.

The loop paid off the PB-1 snapshot drift. Codex initially reported runtime bootstrap and committed generated snapshots disagreeing; later reviews confirm regenerated snapshots and bootstrap tests passing. That is real forward motion, not review churn.

The generated-module leak was not merely reclassified forever. It was first called blocking because extdeps declarations were being treated as ordinary emitted types; later rounds added dsl/extdeps/ source-filtering across target specs, and final reviews explicitly say the extdeps authorities are excluded from re-emission. That is the most important loop-health improvement after the prior meta-review.

The scaffolds now have accounting. EXTDEPS_BOOTSTRAP_FIXTURES is bounded to rust/primitives.dag, realization files remain excluded, the ValueBody::Unparsed limitation is documented, and the dissolution triggers are named: R2 T-Substrate for top-level list/aggregate value bodies, and PB-Bootstrap-Process for absorbing hand-written bootstrap logic. This matches the invariant discipline that scaffolds need named dissolution triggers rather than becoming steady state.

No new invariant was added to INVARIANTS.md, but in this case the recurring class was mostly fixed structurally rather than just memorialized: source filtering now prevents extdeps bootstrap authorities from becoming accidental emitted-module dependencies. A new invariant would still be useful before adding Python/Go primitives, but it is no longer the smallest blocker for this PR.

Debt accumulation evidence

There is debt, but it is tracked and bounded.

The main remaining debt is that rust_pilot_primitives is only type-structure-walkable. The 10-element primitive value enumeration remains behind ValueBody::Unparsed until R2 T-Substrate lands a top-level list/aggregate value-body form. Final reviews explicitly call that roadmap-incomplete rather than a hidden correctness claim. chatgpt-review-0762188f-6c7a-44…

The production target-grounding engine is not landed here. This PR proves the loader/accessor/test boundary, not the full engine path. Under “consumers define correctness,” that is acceptable only because the PR scope is loader close and because the test now consumes the declaration. It would not be acceptable if the PR claimed the target-grounding engine itself was complete.

The bootstrap fixture list remains a hand-written bridge. That is acceptable debt because the bootstrap header and reviews name PB-Bootstrap-Process / Zero-Floor as the dissolution path. It would become debt-shifting if future PRs casually append more extdeps files without the same source-scope and consumer proof. chatgpt-review-0762188f-6c7a-44…

The one-off Dag::rust_pilot_primitives() accessor is a small accretion risk. The final Claude review calls out that if Python/Go primitives follow, a uniform target-keyed accessor should replace N hand-named methods. That is not blocking for one pilot, but it should be tracked before the second target lands. chatgpt-review-0762188f-6c7a-44…

Cheating signal

Low now. It was mixed earlier; the latest rounds improved it.

Earlier, the loop showed a classic cheap-fix pattern: regenerate snapshots, accept generated-module spread, and treat the leak as “mechanical fallout.” The prior meta-review was right to call that out: at that point, no source-filter boundary had landed and no focused consumer test existed. chatgpt-review-0762188f-6c7a-44…

The newest fixes are not just “good enough for now.” They are structural or explicitly accounted: a focused accessor test, source filtering across targets, generated receipt-label cleanup, doc-placement cleanup, and explicit ValueBody::Unparsed flip conditions. The implementer is documenting compromises rather than hiding them.

Path to convergence

The smallest action set that would justify KEEP_ITERATING would be a real scope expansion, not another normal review lap:

1. Land the actual T-Ground-Engine consumer that uses rust_pilot_primitives for target grounding; or
2. Land R2 T-Substrate’s top-level ValueBody::List / aggregate extension and update the test from “Unparsed boundary” to “structured primitive enumeration”; or
3. Add a negative emitted-source regression proving dsl/extdeps/ declarations do not appear in generated helper/lens modules.

For this PR, those are beyond the loader-close scope. Another review round without one of those changes is likely to re-litigate already-accounted debt.

Acceptable debt to carry:

• rust_pilot_primitives.value_body remains ValueBody::Unparsed until R2 T-Substrate’s 4th sub-lane.
• EXTDEPS_BOOTSTRAP_FIXTURES remains hand-written until PB-Bootstrap-Process / Zero-Floor moves bootstrap workflow into generated .dag authority.
• Dag::rust_pilot_primitives() may remain a one-off accessor for this Rust pilot, but the next target primitive PR should introduce a target-keyed/generated accessor instead of duplicating the pattern.
• The production target-grounding engine consumer can land in the T-Ground-Engine follow-up PR, not here.

The follow-up artifact should be a small debt/roadmap entry under the existing R2 T-Substrate / T-Ground-Engine / PB-Bootstrap-Process tracking, with this exact trigger: delete or flip the ValueBody::Unparsed test when structured list/aggregate value bodies land, then add the real primitive-enumeration consumer.

Meta-verdict

⚖️ SHIP_WITH_DEBT — consumer tests pass, the source-filter leak was fixed structurally, and the remaining scaffolds are documented with dissolution triggers.

[briansrls]

Director signal — Grounding Manager (`crisp-seal-366`): Engine Phase 1 dispatchable.

PR #776 merged. The loader-close work is live on `main`:

• `Dag::rust_pilot_primitives() -> Option<&Declaration>` public accessor available (per integration test `extdeps_rust_primitives_loader_test.rs`).
• `EXTDEPS_BOOTSTRAP_FIXTURES` set extends bootstrap with pure structural-data extdeps (rust/primitives.dag scope per the brief's req 5 narrow-scoping decision).
• PB-Bootstrap-Process dissolution trigger named in `bootstrap.rs` per req 4.
• Path 2 scoping honored: type-structure-only accessor; pilot-list enumeration (`ValueBody::Unparsed` for `rust_pilot_primitives` data table) remains deferred to R2 T-Substrate 4th sub-lane per Director's earlier signal on PR T-Ground-Engine Phase 1 — Phase 0 substrate audit (ESCALATION, no implementation) #768.

Per your merged PR #785, Engine Phase 1 brief at `docs/briefs/t-ground-engine-phase-1-typestructure.md` is the dispatch target — type-structure walker against the accessor; pilot `RUST_PILOT_PRIMITIVES` mirror stays in place; mirror-elimination claim deferred to Phase 2 (which blocks on T-Substrate 4th sub-lane).

Cross-program coupling unchanged: Phase 2 still blocks on R2 T-Substrate 4th sub-lane (2 consumers, both list-of-sum: tokenizer charclass phase-2 + Engine Phase 2; `kernel_algebra_profile` excluded as map-shaped per #782 cascade).

Worker dispatch is at your discretion under standing R2 Grounding Manager scope.

CC: `stern-swift-335` (Zero-Floor Manager) — heads-up that PB-Bootstrap-Process dissolution trigger now has its named anchor live on main; loader-close logic added in this PR is what eventually becomes generated content under PB-Bootstrap-Process scope.

[briansrls]

Review metadata

• Provider / model: openai-pro / gpt-5-5-pro
• Commit: 658341ff · Trigger: manual
• Conversation: View conversation

---

1. Story of the diff

This PR makes one scoped extdeps authority, dsl/extdeps/languages/rust/primitives.dag, part of the v3 bootstrap DAG without opening the broader target-realization surface. The mechanism is intentionally narrow: bootstrap.rs adds an include_str! fixture pair for the Rust primitives file and threads it into load_runtime_bootstrap_authorities via EXTDEPS_BOOTSTRAP_FIXTURES (src/v3/compiler/src/bootstrap.rs:82-88, src/v3/compiler/src/bootstrap.rs:188), while the generated bootstrap snapshots now contain RustPrimitive and rust_pilot_primitives declarations (src/v3/compiler/src/bootstrap_generated.rs:1220-1221, src/v3/compiler/src/bootstrap_generated_without_parse_surface.rs:1206-1207). The PR then exposes that loaded authority through a small Dag::rust_pilot_primitives() accessor rather than having future consumers re-walk names ad hoc (src/v3/compiler/src/dag.rs:2895-2897). Because the current substrate cannot structurally lower the top-level list value yet, the change explicitly scopes this as “type-structure-only” access and pins ValueBody::Unparsed as the current boundary (src/v3/compiler/src/bootstrap.rs:37-47, src/v3/compiler/tests/integration/extdeps_rust_primitives_loader_test.rs:95-115). Finally, the target specs exclude dsl/extdeps/ from source filtering and the parse corpus manifest is updated to match those spec edits (src/v3/spec/rust.dag:97, src/v3/spec/go.dag:47, src/v3/spec/python.dag:158, src/v3/compiler/tests/integration/parse_corpus_manifest.txt:20-22).

2. Invariant categories

I checked the diff against the supplied invariant, modeling, coding, and testing references. chatgpt-review-56bb8896-729b-41…

chatgpt-review-7ecf1e2a-8f84-46…

chatgpt-review-ed148284-19b5-4e…

chatgpt-review-159a2f5c-c050-42…

1. LAYER MODEL (substrate vs implementation).

Compliant — this touches the Dag API but does not add new Dag-resident substrate variants or mutate core modeling shapes; the new API is a read-only accessor over a declared authority (src/v3/compiler/src/dag.rs:2895-2897). The bootstrap extension is bounded to structural data only, with realization/arrow files explicitly excluded (src/v3/compiler/src/bootstrap.rs:26-35).

1. INVARIANTS.md + modeling-discipline.md.

Compliant — single authority / facts-flow-forward is preserved by loading the .dag authority itself via include_str! and load_fixtures, rather than copying the primitive table into Rust (src/v3/compiler/src/bootstrap.rs:82-88, src/v3/compiler/src/bootstrap.rs:188). Fail-closed behavior is also not weakened: the accessor returns absence rather than fabricating a placeholder declaration, and the new integration test asserts clean diagnostics before treating the fixture as loaded (src/v3/compiler/tests/integration/extdeps_rust_primitives_loader_test.rs:15-24).

1. CODING.md.

Compliant — the implementation keeps dependencies explicit and localized: the new authority is a named const fixture pair (src/v3/compiler/src/bootstrap.rs:82-88), and the consumer-facing surface is a small reader method over Dag with no hidden mutation (src/v3/compiler/src/dag.rs:2895-2897). The regen label strings were updated to match the actual generated authority set (src/v3/compiler/src/bin/regen_bootstrap.rs:38, src/v3/compiler/src/bin/regen_bootstrap.rs:48).

1. TESTING.md.

Compliant — the diff adds a behavior-level integration test at the right boundary: Dag::new() bootstrap exposure is the unit under test, so constructing a full bootstrap Dag is appropriate here (src/v3/compiler/tests/integration/extdeps_rust_primitives_loader_test.rs:13-24). The second test deliberately pins the current ValueBody::Unparsed boundary and names the future flip condition, which matches the PR’s partial-substrate scope (src/v3/compiler/tests/integration/extdeps_rust_primitives_loader_test.rs:94-115). The module is wired into the integration suite (src/v3/compiler/tests/integration.rs:44-45).

1. LOCKED DESIGN DECISIONS.

Compliant — the PR preserves the locked external-realization boundary rather than moving target emit/type realization bodies into bootstrap: the header explicitly says realization facts stay emitter-side and that rust/emit.dag, rust/types.dag, etc. are excluded (src/v3/compiler/src/bootstrap.rs:17-24, src/v3/compiler/src/bootstrap.rs:30-32). The only loaded extdeps file is the primitive structural-data fixture (src/v3/compiler/src/bootstrap.rs:85-88).

1. TRACKED vs UNTRACKED DEBT.

Compliant — the temporary shapes are documented, bounded, and have named dissolution triggers. The type-structure-only limitation is bounded by the current lack of top-level ValueBody::List/aggregate support and names R2 T-Substrate’s 4th sub-lane as the trigger (src/v3/compiler/src/bootstrap.rs:37-47, src/v3/compiler/tests/integration/extdeps_rust_primitives_loader_test.rs:96-102). The hand-Rust loader test is registered as hand-authored debt with a dissolution path into testgen once that path covers the extdeps loader surface (src/v3/compiler/tests/integration/sg0_census_test.rs:212-219). The bootstrap loader itself is also tied to PB-Bootstrap-Process dissolution (src/v3/compiler/src/bootstrap.rs:49-53).

3. Verdict

APPROVE

I found no changed line that introduces duplicate authority, broadens the realization boundary, or leaves an untracked scaffold. The PR is narrow: it loads one structural extdeps authority, exposes it through a canonical Dag accessor, updates generated snapshots/source filters, and pins the current partial-substrate boundary with tests.