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]

Lane A E0308 re-baseline — Route-A last mile (faithful emitted-seed crate → cargo-green)

Drives the faithful --emit-fresh Route-A seed crate from 647 → 6 E0308 (measured by execution against the real assembled crate: emitted seed closure + hand-written periphery). Three landed changes, all on the .dag authority (src/v1/05_emit_rust.dag) and spliced into the hand-synced seed mirror (src/v1/stage0/src/v1_compiler_emit_rust.rs):

1. Family-A — map-literal &str key coercion (24 → 0)

A Map<String, V> data literal now emits HashMap<String, V> keys ("k".to_string()), not HashMap<&str, V>. The coercion is type-DERIVED from the declared key type (is_rust_string_like over the map's key type), NOT a blanket "always .to_string() keys".

• Witnesses (map_literal_string_key_test.rs): string_key_is_coerced_to_owned_string (String key → owned) + the negative control non_string_key_is_left_as_literal (a non-String declared key stays an unowned literal — the wall against blanket coercion) + a real-source Map<String, Int> fixture proving owned keys with the Int value left uncoerced.

2. First-Option carrier signature — faithful Optional rendering (the dominant ~638 cluster)

Root cause (construction, not consumer-unwrap): the Rust emitter rendered T? types inconsistently — Int? → Option<i64> ✓ but String? → bare String ✗ (the Optional was dropped). The function body already emitted Some/None correctly, so only the signature mismatched (expected String, found Option<String>). Every String text-carrier renderer path had an early-return (is_host_text_carrier_type → "String", faithful name=="String" → render_rust_text_carrier) that short-circuited before the renderer that applies the Optional template.

• Fix: a new rust_carrier_optional_wrap(n, rendered) wraps the carrier rendering in Option<..> iff n.return_cardinality == CardOptional, applied at the 11 String carrier early-returns (returns / fields / params / applied / alias-rhs). Cardinality-DERIVED faithful rendering — no unwrap, no fabrication.
• Witnesses (optional_carrier_signature_test.rs): optional_string_return_renders_option_signature (String? → Option< signature) + the discriminating control non_optional_string_return_stays_bare (a non-optional String stays bare — would RED if it wrapped all String carriers). Signature-scoped so the runtime's own Option<..> types don't pollute the assertion.

This strictly subsumes the originally-signed "type-derived unwrap at pipe-first" shape: forcing an unwrap at the consumer would have MASKED the renderer bug (fabricating presence / spurious-panicking on a value that genuinely should be Optional). Construction over validation.

3. Residual-3 — fail-closed unwrap at the genuine optional-into-required consumers (9 → 6)

After the renderer fix, 3 genuine T?-into-T consumer sites remain — a value modeled -> T? (e.g. first → OptionalOf<T>, the modeled total-returning-optional) flowing into a NON-optional parameter. These are the real model hole: expected Rc<T>, found Option<Rc<T>>, where the v1 checker accepts optional-into-non-optional fail-open.

• Fix: a new rust_call_arg_fail_closed_unwrap appends a located, fail-CLOSED .expect("fail-closed: an optional value flowed into non-optional parameter <idx> of <func> (empty Optional at runtime)") — type-DERIVED: emitted iff the declared param is required AND the arg's resolved type is CardOptional. It is explicitly NOT unwrap_or_default / unwrap_or_else(<fabricated>) (those would be §5 fail-OPEN — a silent wrong answer). On an empty Optional at runtime it aborts loudly with a diagnostic naming the call site.
• Fires at exactly the 3 real sites (semver semver_compare_identifier, schedule schedule_witness_entry_eq / runnable_eq) and nowhere else — verified by emitting the whole crate and confirming 3 applied .expect("fail-closed: sites, no over-application.
• Witnesses (optional_consumer_fail_closed_test.rs), three teeth:
  • required_param_optional_arg_emits_located_fail_closed_unwrap — maybe(..) -> Int? into consume(x: Int) emits the located .expect("fail-closed: (scoped to the drive fn).
  • required_param_nonoptional_arg_stays_bare — discriminating control: a non-optional arg into the same required slot gets NO unwrap (type-derived, not blanket).
  • empty_optional_unwrap_panics_not_fabricates — discriminating EXECUTION: the empty case actually FAILS CLOSED — None.expect("fail-closed: ...") PANICS (caught via catch_unwind), whereas the rejected fail-OPEN shape unwrap_or_default silently fabricates 0. The §5 distinction made executable.

Final residual: 6 E0308, all out-of-scope of this lane

Confirmed by execution against the rebuilt seed:

site	mismatch	family
extdeps_version_semver.rs:226	Rc<VersionScheme> vs fn-item	fn-item-as-value
std_realization_schedule.rs:167	&str vs String	&str/String
v1_compiler_complexity.rs:504,507	&str vs String	&str/String
std_termination.rs:71,72	DescentEvidence vs Box<DescentEvidence>	Box/Rc

§5 model-hole flag (follow-up owed upstream, NOT expanded here)

Residual-3 is fixed at the emitter with a fail-closed unwrap, but the deeper cause is a model §5 hole: pipe-first is modeled as -> T? (total-returning-optional, algebra.dag OptionalOf), and the .dag model admits that optional flowing into a non-optional slot without an explicit unwrap node, which the v1 checker accepts fail-open. A model-forces-unwrap follow-up (an explicit unwrap/partiality node, or grounding Optional against its realization) is owed on the operator-owned Optional / Value::Null runway. This PR deliberately does not expand into model-grounding; it makes the emitted Rust fail-closed and flags the model gap.

🤖 Generated with Claude Code

[gunbai-bot]

Status: this PR's first-option-carrier-sig work has already landed in main (the optional-carrier wrap, fail-closed call-arg unwrap, and associated tests are all present on origin/main via the merged stack). After merging current origin/main, this branch's diff vs main is now empty.

The only thing the branch had carried beyond that was a stale merge resolution that reverted unrelated lanes' work (#5715 TS first-class, and the ci_humming / realization_measurement_loop / resolver_type_name_collision_wall plan fan-out from #5727). I restored all 14 of those files to origin/main's exact version (commit e0bbe841ec), so the branch now carries zero reversions and a zero net diff.

Recommendation: close this PR — it's an empty no-op; its deliverable is in main. Nothing here to merge.

— sent from deep-wolf-695

[gunbai-bot]

Heads-up on what this review is actually approving: the BlockEvaluationMode coproduct + target_model.dag threading + plan-doc churn it describes are #5715 (TS first-class inc-2b) and #5727 (plan fan-out) — both already merged to main. They show up in this PR's "Files changed" only as a merge-base display artifact (this branch's stale merge-base re-surfaces content that is already in main), not as anything this PR introduces.

This PR's net diff vs current main is empty — its own first-option-carrier work (rust_carrier_optional_wrap) is already in main, and I restored the 14 other-lane files this branch had been reverting back to origin/main exact (commit e0bbe841ec). So a squash here would revert nothing (#5703/#5715/#5727 all preserved) — it's simply a no-op.

Recommendation stands: close this PR, don't merge it. There's no #5716-owned change left to land. (Parent jolly-cat-29 independently verified the net-zero diff and relayed the close recommendation to the operator.)

— sent from deep-wolf-695