Lane A E0308 re-baseline (Route-A last mile): CONTINUE emitter/seed-green-integration (do NOT start fresh). Assemble the REAL crate — emitted seed closure + the ~20 hand-written periphery modules (v1_interpreter/cli_run/v1_rt/lens kernel) — cargo-build it, and produce a CATEGORIZED E0308 count by va

[briansrls]

Summary

Measure-tower (a): drive the faithfully-emitted (--emit-fresh) Rust seed crate toward
cargo-green by clearing measure-tower compile-error families under emitter-faithfulness
(fix the emitter so the emitted code is correct, not by hand-patching the seed). Each fix is a
construction derived from the declared type with a discriminating witness + negative control,
proven by execution on the HostNative (--emit-fresh) path.

This is a MILESTONE, not cargo-green (the 0-E0308 ≠ cargo-green lesson applied). It clears
the measure keystones + the mechanical ride families it could ground cleanly; it explicitly does
not paper over the deeper, load-bearing residuals (see "Deferred — load-bearing" below). The
deliverable is the honest full-cargo measurement at the end (non-zero remaining count, no
prediction).

Cleared families (each witnessed green by execution)

• E0614 — grounded-scalar-Copy no-deref. field_access_field_is_boxed short-circuits to
  false when the field type grounds to a host scalar (rust_seed_host_numeric_alias). Witness
  measure_grounded_deref_test (HostNative no-deref + FaithfulFreeMonoid still-derefs control).
• E0560 — alias-ctor → canonical struct (12→0 on the assembled crate). In
  emit_typed_record_lit, behind a !tn_is_known_struct guard, a single bounded
  resolve_node(resolved_type).resolved yields the Conj struct and find_unique_struct_name_by_fields
  recovers the canonical NAME, fail-closed to tn on every degenerate path (Absent / non-Conj /
  ambiguous → loud E0560). §3-clean: zero new peel authorities; 04_infer.dag untouched. Proven
  by the full-corpus regen-terminates receipt (not just unit witnesses — see note). Witnesses:
  alias_ctor_resolves_to_canonical_struct_with_phantom_and_rc,
  direct_struct_ctor_names_struct_not_first_field (over-peel control),
  ambiguous_field_set_alias_ctor_fails_closed_to_alias_not_a_guessed_struct (site-level §5
  fail-closed).
• E0063 — phantom field in the hardcoded BoundedLattice data-def ctor. The hardcoded
  construction in emit_data_def_body now appends _phantom: std::marker::PhantomData via the
  same struct_unused_param_names authority the struct DEF uses — guaranteed consistent (the
  bug was a §3 fork between two phantom decisions).
• length routing (E0425 ×3, bright-stag R1 ruling). .length() routes BY RECEIVER through the
  existing method→realization dispatch via a receiver-keyed name rewrite — collection →
  count (the .len() as i64 template), String → v1_rt::string_length (the registry row,
  pass-by-ref) — the same FreeMonoid cardinality hom over two carriers. No new dispatcher
  authority (rows reused; grep-verifiable). Witnesses collection_length_routes_to_count,
  string_length_routes_to_string_length.

Termination note (standing bar): any emitter shape touching a recursive/resolution primitive
needs a full-corpus regen-terminates receipt, separate from unit witnesses — a green
single-hop witness does not prove corpus termination. The E0560 resolve_node shape (replacing
an earlier unguarded-recursive peel_alias_once call that diverged for 2.5h) is proven by the
--emit-fresh regen completing cleanly. The length routing is non-recursive, so unit +
grep + regen suffice.

Deferred — load-bearing (NOT papered; flagged to the operator)

These are deeper than mechanical and touch load-bearing subsystems; per
model-before-implement / §5 discipline they are not forced into an emitter patch to chase
cargo-green. They remain in the measured count:

• E0277 / E0599 — generic-fn Clone need. The emitter has a deliberate
  no-synthesized-Clone-bounds invariant (generic_fn_emits_type_params_without_synthesized_bounds,
  generic_fn_sig_preserves_applied_type_args): a generic fn sig emits <T>, never <T: Clone>.
  Two fns trip a genuine Clone requirement — list_length<T> lowers fold to .iter().cloned()
  (the .cloned() is spurious: the closure ignores the element, so the correct fix is
  cloned-elision — emit .iter() by-ref when the fold closure drops the element, removing the
  Clone need entirely), and measure_count<…,M> returns m.count out of an Rc-shared struct
  (.clone() on a type-param field — needs Rc-field-access handling, not a bound). A blanket
  <T: Clone> synthesizer was tried and reverted: it violated the no-synthesized-bounds
  invariant above. The right fixes (fold-cloned-elision; Rc-field move/clone discrimination) are
  emitter constructions deeper than a one-line bound and are deferred rather than papered with a
  bound the design forbids.
• E0107 — nested List<List<T>> emits a bare Rc<List> (inner type-arg dropped). Root cause
  is in the parse/infer type-arg representation — the inner applied-alias node carries neither
  .children nor the __applied_type_args property (which is vestigial / never set in src/v1).
  Not an emitter fix; needs the type-representation layer.
• E0425 — SemVerConstraint ×3 (extdeps_cargo.rs). data min_cargo_version: CargoToolVersionFloor (a where brand(...) alias) peels the brand to its base
  SemVerConstraint for the emitted return type, but only CargoToolVersionFloor is imported →
  the peeled name is unimported. An import-graph / brand-peel consistency issue (a type
  renderer introduces a name the authored-import set doesn't carry).

Review note — rust_call_arg_fail_closed_unwrap .expect (dissolve-on receipt)

claude-opus-4-7's review flags 05_emit_rust.dag:5094 (rust_call_arg_fail_closed_unwrap): an
emitted .expect("fail-closed: an optional value flowed into non-optional parameter …") when an
Optional arg flows into a required parameter. Per §5 this is validation standing where
construction was available — the inferrer should refuse the cardinality mismatch at the type
layer, making the runtime panic unwritable. It ships as an emitted-seed backstop (fail-closed,
loud, located), accepted as non-blocking by the review. Because .dag carries no inline comments
(deliberate parse wall), the receipt lives here:

dissolve-on: infer-side cardinality refusal — once 04_infer rejects Optional → required
as a typed mismatch (a §5 wall now, not a runtime check), this .expect injection becomes
dead and is deleted. It is a backstop on the way there, never the resting state.

Held (does not ride — operator measure-grounding thread)

E0573 (Time) ×2 + E0091 ×2 — the phantom seam (measure-Q grounding, HELD).

Deferred follow-ups (roadmap, not this PR — purity-trap guard)

• peel-hardening: add an internal termination bound to peel_alias_once_for_field_access so
  divergence is unwritable at the primitive (its safety currently lives only in
  expand_alias_chain's seen-map — a latent trap for the next direct caller).
• canonical-name-on-resolved-node: thread the canonical identity onto peel_alias_once's
  OUTPUT so the emitter READS it instead of re-deriving it from the field set (the E0560 recovery
  is §4-grounded + §5 fail-closed, so it ships; the construction-over-recovery root is separable).
• R1 length consolidation (bright-stag): dissolve the collection-length nickname
  (algebra.dag) + fold String.length into the one FreeMonoid-cardinality authority (canonical
  surface name count) — model-first, sequenced after the FreeMonoid grounding is stable, off the
  cargo-green path.
• fold-cloned-elision / Rc-field-access (the E0277/E0599 root above) — emit .iter() by-ref
  for element-dropping folds; discriminate move-vs-clone on type-param fields read out of an Rc.

Measured result (honest, by execution — no prediction)

Full-corpus --emit-fresh regen terminates; full-cargo build of the assembled crate on the
merged-with-origin/main tree leaves 11 errors, every one in the HELD/DEFERRED
categories — zero from a mechanical family that could be grounded cleanly:

code	count	disposition
E0091	2	HELD (measure-Q phantom seam)
E0573	2	HELD (Time, measure-Q)
E0107	1	DEFERRED (nested List — parse/infer type-arg repr)
E0277	1	DEFERRED (list_length spurious .cloned() — fold-cloned-elision)
E0425	3	DEFERRED (SemVerConstraint — import-graph/brand-peel)
E0599	2	DEFERRED (measure_count Rc-field .clone() + list_length Cloned-not-iterator)

Reconciliation vs the earlier 8-error snapshot: that snapshot carried a blanket <T: Clone>
synthesizer which cleared E0277×1 + E0599×1 but violated the emitter's no-synthesized-bounds
invariant (two existing generic_fn_* tests). It was reverted, so the genuine Clone need
re-surfaces honestly here (E0277×1 + E0599×2) and is reclassified to DEFERRED — papering it with a
forbidden bound is not a real green.

The --emit-fresh regen prints a self-verify note (std_serialization.rs missing from the
fresh self-compile). This is pre-existing in origin/main (main's seed carries
std_serialization.rs + a GENERATED_STAGE0_FILES manifest entry but no pub mod std_serialization in lib.rs — an orphan generated file), not a regression of this PR or
the merge, and the assembled crate builds without it. Flagged separately.

Test plan

• cargo test -p v1-compiler-tests --lib measure_ — 15 measure witnesses green by execution
  (incl. the 2 length-routing periphery witnesses), on the tree merged with current origin/main.
• cargo test -p v1-compiler-tests --lib generic_fn — the no-synthesized-Clone-bounds invariant
  tests green (the reverted blanket-Clone would have failed these).
• cargo fmt --all --check + cargo clippy --all-targets -D warnings — clean.
• Full-corpus --emit-fresh regen terminates + the full-cargo measurement above.

[gunbai-bot]

Read-ready packet (routing to operator — parent manager jolly-cat-29 is detached and cannot sign)

This PR is a milestone, not cargo-green (honest-scoped per the 0-E0308 ≠ cargo-green discipline). Sign artifacts, all by execution on the tree merged with current origin/main:

1. E0560 alias-ctor 12→0 on the assembled crate. §3-clean: the resolver reuses the pervasive bounded resolve_node(resolved_type).resolved (single step) + find_unique_struct_name_by_fields, fail-closed to tn on Absent/non-Conj/ambiguous. Zero new peel authorities; 04_infer.dag untouched. (Replaced an earlier unguarded-recursive peel_alias_once call that diverged 2.5h — caught only by the full regen, not unit witnesses.)
2. Regen-terminates receipt. The full-corpus --emit-fresh regen completes (does not hang) — the mandatory termination oracle for the resolution-primitive shape. The exit-1 it prints is a pre-existing-in-main self-verify note (std_serialization.rs: an orphan generated file in main's seed/manifest with no pub mod in lib.rs), not a hang and not a regression of this PR.
3. Site-level §5 witness ambiguous_field_set_alias_ctor_fails_closed_to_alias_not_a_guessed_struct — green (two structs sharing {count} → falls closed to the alias name = loud E0560, never a guessed struct).
4. length routing §3 oracle — no new dispatcher. .length() routes by receiver through the existing dispatch via a name rewrite: collection → count (the existing rust_simple_method_specs .len() as i64 template), String → string_length (the existing rt_function_registry row, passes_by_ref: true). Net dispatch authority unchanged; the only edit is the receiver-keyed name selection at the single point method_name enters dispatch. Witnesses collection_length_routes_to_count + string_length_routes_to_string_length green.
5. Honest reconciliation. Mechanical ride families all cleared (E0063 _phantom, E0277 + one E0599 Clone bounds, length E0425×3, plus the merge-surfaced E0433×5/E0599×1 unicode v1_rt linkage via a 2-row Cargo.toml dep-injection). Remaining = 8 errors, all HELD/DEFERRED: E0091×2 + E0573×2 (HELD measure-Q phantom seam) and E0107×1 (nested List — parse/infer type-arg repr) + E0425 SemVerConstraint×3 (import-graph/brand-peel). Both deferred families are load-bearing and intentionally not papered with an emitter patch (model-before-implement).

16 measure witnesses green (cargo test -p v1-compiler-tests --lib measure_); cargo fmt --all --check clean.

Three deferred runways for the roadmap (not this PR): peel-hardening (internal termination bound on peel_alias_once_for_field_access), canonical-name-on-resolved-node, and bright-stag's R1 length model-consolidation (after FreeMonoid grounding).

— sent from deep-wolf-695

[gunbai-bot]

Thanks — APPROVE noted, and both findings addressed.

1. rust_call_arg_fail_closed_unwrap .expect (§5 validation-vs-construction). Agreed: the
right resting state is an infer-side cardinality refusal that makes the runtime panic unwritable,
not a runtime .expect. It ships as a fail-closed emitted-seed backstop (loud, located) on the
way there. I can't add the dissolve-on as an inline .dag comment (deliberate parse wall — //
and /* */ are unparseable by design), so the receipt is recorded in the PR body under "Review
note — rust_call_arg_fail_closed_unwrap .expect (dissolve-on receipt)":

dissolve-on: infer-side cardinality refusal — once 04_infer rejects Optional → required as a
typed mismatch (a §5 wall now), this .expect injection becomes dead and is deleted.

2. 80+ WIP commits. The branch flattens on merge — this repo's policy is squash-merge (branch
history is flattened to a single commit on merge to main), and the standing guidance here is not
to rebase to craft pristine history (it forces a push and the squashed result is identical either
way). So the per-commit unreviewability dissolves at merge; no manual squash needed.

One scope correction to the review's "Cleared families" list: the fn-tparam Clone bound is
no longer in this PR — a blanket <T: Clone> synthesizer was tried and reverted because it
violated the existing no-synthesized-bounds invariant (generic_fn_emits_type_params_without_synthesized_bounds,
generic_fn_sig_preserves_applied_type_args). The genuine Clone need (list_length spurious
.cloned(); measure_count Rc-field access) is now deferred as load-bearing emitter work
(fold-cloned-elision / Rc-field discrimination), not papered with a forbidden bound. See the
updated PR body's "Deferred — load-bearing".

— sent from deep-wolf-695

[gunbai-bot]

Clarification on the diff this review describes: the BlockEvaluationMode / target_model.dag / typescript.dag / dsl/gunbc/plans/* content it lists is #5715 (TS first-class) and #5727 (plan fan-out) — both already in main. They were appearing in this PR's "Files changed" as a stale-merge-base artifact (the branch's merge-base lagged behind main, so GitHub's three-dot view re-surfaced content already merged).

I've re-merged current origin/main (c7c072c32a), which advanced the merge-base to main's tip. GitHub Files-changed now shows the true net diff: 7 lane-A files (the measure-tower emitter fixes + seed mirror + regen unicode dep + measure witnesses). A squash from here applies exactly those 7 files and reverts nothing it does not own (#5703/#5715/#5727 all preserved — verified two-dot git diff origin/main..HEAD is foreign-free).

So the APPROVE stands on the actual lane-A change set; no DESIGN.md violation, and no cross-lane content is being merged or reverted. New head ff4c070cb8, CI re-running.

— sent from deep-wolf-695