Emission follows resolution: remove the std::string::String ↔ Rc<im::Vector<i64>> expected/found family against the 155-row boundary

[gunbai-bot]

Claim (mechanism grain)

This PR removes the exact std::string::String ↔ Rc<im::Vector<i64>> expected/found E0308 family against the 155-row receipt-1 boundary (main@eced9d24c599, tree d424154bb6fb, census digest 049d0a54eea70534), with every successor row classified. It does NOT claim "all String bugs repaired" and predicts no remainder — the next census classifies additions, it never subtracts.

Nat-family occupancy is ZERO in the live census; the nine LLVM IR identities are String-family. The retired ≤11 bound stays retired.

Root cause (authority_substitution at the env)

rewire_type_env_import_str_binding_identity (04_infer.dag) runs post-fold over the run's assembled TypedModules and, for any inherited name with exactly one exporter in the invocation's module list (build_export_indexes — run-scoped, not corpus-scoped, not intrinsically closure-scoped) and ≤1 direct-import exporter, REPLACES the ancestry binding with that exporter's declaration. String has one closure exporter (v2.std.text; std.string_type is outside the 00_compile closure), so every persisted env lost its kernel <kernel:String> binding. Inference ran pre-rewire (kernel answer, host String bodies); emit read post-rewire (structural answer) → the 139-row pub use crate::v2_std_text::{String} shadow.

Two natural-experiment confirmations, pre-registered: (1) v2.std.compilers.target_model imports v2.std.text via TWO import statements → direct-exporter count 2 → skip arm → only module where the consumer filter fired pre-producer-fix; (2) Int has two closure exporters (std.integer + v2.std.integer) → skip arm → kernel binding survived corpus-wide. The drops occurred precisely on the skip-arm's complement.

The fix (two halves, both identity-keyed)

1. Producer (ancestry_binding_is_kernel_identity, 04_infer.dag): the rewire skips any ancestry binding whose resolved ident_span.file == "<kernel:NAME>" — keyed on the binding's own identity, never a name roster.
2. Consumer (import_name_resolves_to_kernel, 05_emit_rust.dag): use-line derivation consults the resolver's own walk (lookup_type_by_name over the module's TypeEnv) and drops a name only when it resolves to a structureless kernel scalar (<kernel: file, NoConnective, 0 children). Structural kernels (Bool, Optional) and non-kernel bindings (Witness) keep their lines. Absent binding/env → keep: ignorance never widens a drop.

Exact closing decomposition (155 → 66, identity grain, remainder EMPTY)

Measured at the byte fixed point (regen round 1, first_generation_equal=true; unit tests 612 passed / 0 failed).

66 = 14 baseline survivors + 52 classified additions. The set of rows that is neither a predicted survivor nor a classified addition is EMPTY.

Survivors (14):

• 9 at identical positions: gunbc_v1_interpreter_primitive_surface.rs:254 E0599 concat; v2_compiler_infer.rs:1323 E0308; v2_compiler_infer.rs:489 + v2_compiler_parse.rs:529 E0282; v2_std_collection.rs:93 E0308 + :94 E0560; v2_std_text.rs:64/72/90 E0599 chars.
• 5 shifted by exactly −1 line (one use-line dropped per file), matched to their baseline row by file+code+label: target_model.rs:2606 (String↔i64), target_model.rs:7224 (Ownership lookup pair), target_carriers.rs:105 (Option<Rc<Node>>), compile.rs:288 (Witness nesting), source_authority.rs:1007 (Rc<Node>↔Rc<NormalizedTree>).

Additions (52), all classified, exact counts:

• 48 E0308 String ↔ Rc<Vector<i64>>/Rc<Vector<_>> body-boundary rows (bodies binding kernel host String while calling structural v2.std.text/algebra fns; both mismatch directions; 4 of the 48 render as "arguments to this function are incorrect" whose expected/found notes carry the same pair, and 5 spans carry two diagnostics each — which is why 66 rows sit over 61 distinct span+code keys).
• 1 E0282 at v2_compiler_tokenize.rs:151:77 — inference failure induced by the same boundary (a closure over is_prefix_of(prefix, source, …) where String is now host).
• 3 at target_model.rs:739 — the pre-registered known rows: E0277 str-indexing, E0599 iter on str, E0308.

Removals (141 = 155 − 14): the pre-registered 139 String-family E0308, plus 2 rows predicted to survive that were also removed — v2_std_qualified_name.rs:238:68 E0599 (split on Rc<im::Vector<i64>>) and v2_std_compilers_lexing.rs:182:72 E0282 — both String-representation rows the prediction had misfiled as heterogeneous survivors. Reported as divergence, not reconciled: the predicted survivor set was 16; the measured set is 14.

Pre-registration scoring

• Predicted use-line drops — CONFIRMED: v2_std_text::{String} 18 → 0; v2_std_integer::{Int} 9 → 0.
• Predicted skips — CONFIRMED: Bool ×32, List ×46, Map ×16, Witness ×22 use-lines all kept.
• Predicted removals — CONFIRMED plus the 2 favorable-divergence rows above.
• Predicted additions class — CONFIRMED with zero unclassifiable rows; the volume (49 String-boundary rows vs 5 known candidates) is a divergence reported as measured.
• No falsifier fired: no String line survived, no Bool/Witness/List line dropped, no predicted-removed identity persisted.

Finding — additions concentration: 38 of the 48 String-boundary E0308 additions sit in v2_compiler_tokenize.rs (86% of the class in one module once the 4 arguments-form rows are included: 42/49). Kernel-host String bodies calling structural text/algebra fns cluster where the tokenizer folds lexemes; the next lane on the String body boundary should start there.

Method note: the discipline used here — pre-register predicted sets and falsifiers before measuring, score at identity grain, report every divergence instead of reconciling it — caught two authoring errors before measurement (the "fired in only one module" misread; the corpus-vs-run scope of build_export_indexes) and, post-measurement, caught the survivor-count misfiling above. One addition from the score itself: score BOTH directions — the prediction can be wrong about what stays as easily as about what goes; the miss here was a predicted SURVIVOR removed, which a removals-only scoreboard would have scored 139/139 and called clean. The next receipt inherits this as method.

Finding: run-scoped resolution divergence (narrowed, not closed)

build_export_indexes is scoped to the invocation's assembled module list, so a scoped run and a whole-corpus run could bind the same name to different declarations. This fix removes that run-dependence for kernel names only — the divergence is narrowed, not closed. The explicit scope field on CompilePhaseReceiptSubject lands with receipt 2, not here (carried by the manager as a known gap).

🤖 Generated with Claude Code

https://claude.ai/code/session_01GXfYKNQTD3VfYyQcnJpxNU