An occurrence that survives the front end, and an ingest-wide index to join it to a file

dag/gunbc/compiler_frontend_program_status.dag

@@ -178,7 +178,7 @@ fn missing_instrument_label(i: MissingInstrument) -> String {
     PhaseCargoExecutionFact => "a per-phase cargo-execution fact on gunbc.required_ci_phase_roster"
     ResolverBoundDeclaringIdentity => "the v2 resolver answering a qualified reference with an EXACT declaring identity by execution -- the binding's declaration containment path, not a leaf and not the authored spelling -- so that v2.compiler.repair_input_origin_roster derives RepairInputDeclared.declaring from that binding rather than from carrier_declaration_ref's spelling arm (XL-0's population; the roster producer itself exists and answers)"
     DeclaringIdentitySpellingCensus => "a declaring-identity spelling census that answers over XL-3's usable population on the production ingest route: QUALIFIED cross-module mentions (every position) and bare type names in FIELD position, joined to their declaring identity - the producer v2.compiler.declaring_identity_spelling_census spelling_census_from_ingest exists and answers over the bare same-module classes only, which is not that population (XL-3's population)"
-    ExactOccurrenceResidualCensus => "the exact occurrence and import-declaration residual an XL-2 rehearsal produces (XL-5's population): the typed import strip (std.import strip_import_statements, already built) applied to a throwaway tree, followed by the v2 production route -- ingest, graft, normalize, RESOLVE -- over every stripped module, its resolve refusals joined to occurrence identity where an id is minted and to module + path + locus structure where it is synthetic (the residual's ids are mixed, majority synthetic over the whole tree -- gunbc#11738's census-resolve run; a wave keyed on occurrence identity alone would cover a minority and report success on the rest). KNOWN NECESSARY prerequisites -- not an exhaustive set, and a fourth found by review is not the end of the list either -- each an undercount BY CONSTRUCTION rather than a missing producer file: (i) call callees and ARGUMENTS reach resolve (gunbc.recurring_failure_mode call_expression_erased_at_v2_body_lowering -- resolve fails OPEN for every dependent reached through a call, so its refusal roster cannot establish completeness over that population; the callee half is gunbc#11683's, the argument half is open); (ii) bare FIELD-position type names reach the containment tree (the grafting lane, namespace_cut_stage cause 4); (iii) a whole-tree v2 census that RESOLVES per module rather than stopping at normalize: the executing entry that omits resolve is the SourceRootEvalDriver's rendered census mode (v1.compiler.emit_rust emit_source_root_eval_driver_main_rs, run_census), which calls v2.compiler.compile native_test_context_from_ingest, whose per-file native_test_context_fold_step reaches program_assembly_read_to_normalized_root_prepared and nothing further -- resolve is native_test_resolve_module, reached only from adjudicate mode's prepare over universe modules (gunbc.witness.v2_native_route native_route_census is a fold over supplied verdict rows and is not that entry). AND ONE UNRESOLVED OBLIGATION THAT NONE OF THOSE DISCHARGES, occurrence completeness: v2.compiler.resolve resolve_children_homogeneous_scope (and resolve_transform_children, resolve_edges_first_outer_then_inner, resolve_bind_edges) returns a Rejected accumulator without visiting the remaining children, so a module with two independent post-cut refusals records the first and never observes the second -- a truthful MODULE-level refusal and an incomplete OCCURRENCE-level population -- and an earlier parse or normalize refusal blocks a whole module the same way. Running resolve once per module therefore does not establish that every affected occurrence was observed; the census must report every site or explicitly refuse completeness, and its discriminator is two independently failing sites in ONE module, each shown individually reachable by a control, both reported. The Step-0 canary (gunbc.namespace_step0_candidate_run over tools.multi_module_compile_fixture) is NOT this instrument, on a population ground rather than a version-number one: its carrier is a per-bucket diagnostic HISTOGRAM differential (gunbc.namespace_step0_canary_v2 Step0HistogramDifferential, whose arms include OccurrenceJoinUnavailable), so it cannot carry an exact occurrence residual whatever pipeline compiles it; a rehearsal that observes a proposed cut through the old implementation is admissible as a differential, and what it may not do is be the authority that still answers after the surgery"
+    ExactOccurrenceResidualCensus => "the exact occurrence and import-declaration residual an XL-2 rehearsal produces (XL-5's population): the typed import strip (std.import strip_import_statements, already built) applied to a throwaway tree, followed by the v2 production route -- ingest, graft, normalize, RESOLVE -- over every stripped module, its resolve refusals joined to occurrence identity where an id is minted and to module + path + locus structure where it is synthetic (the residual's ids are mixed, majority synthetic over the whole tree -- gunbc#11738's census-resolve run; a wave keyed on occurrence identity alone would cover a minority and report success on the rest). KNOWN NECESSARY prerequisites -- not an exhaustive set, and a fourth found by review is not the end of the list either -- each an undercount BY CONSTRUCTION rather than a missing producer file: (i) call callees and ARGUMENTS reach resolve (gunbc.recurring_failure_mode call_expression_erased_at_v2_body_lowering -- resolve fails OPEN for every dependent reached through a call, so its refusal roster cannot establish completeness over that population; the callee half is gunbc#11683's, the argument half is open); (ii) bare FIELD-position type names reach the containment tree (the grafting lane, namespace_cut_stage cause 4); (iii) a whole-tree v2 census that RESOLVES per module rather than stopping at normalize: the executing entry that omits resolve is the SourceRootEvalDriver's rendered census mode (v1.compiler.emit_rust emit_source_root_eval_driver_main_rs, run_census), which calls v2.compiler.compile native_test_context_from_ingest, whose per-file native_test_context_fold_step reaches program_assembly_read_to_normalized_root_seeded and nothing further -- resolve is native_test_resolve_module, reached only from adjudicate mode's prepare over universe modules (gunbc.witness.v2_native_route native_route_census is a fold over supplied verdict rows and is not that entry). AND ONE UNRESOLVED OBLIGATION THAT NONE OF THOSE DISCHARGES, occurrence completeness: v2.compiler.resolve resolve_children_homogeneous_scope (and resolve_transform_children, resolve_edges_first_outer_then_inner, resolve_bind_edges) returns a Rejected accumulator without visiting the remaining children, so a module with two independent post-cut refusals records the first and never observes the second -- a truthful MODULE-level refusal and an incomplete OCCURRENCE-level population -- and an earlier parse or normalize refusal blocks a whole module the same way. Running resolve once per module therefore does not establish that every affected occurrence was observed; the census must report every site or explicitly refuse completeness, and its discriminator is two independently failing sites in ONE module, each shown individually reachable by a control, both reported. The Step-0 canary (gunbc.namespace_step0_candidate_run over tools.multi_module_compile_fixture) is NOT this instrument, on a population ground rather than a version-number one: its carrier is a per-bucket diagnostic HISTOGRAM differential (gunbc.namespace_step0_canary_v2 Step0HistogramDifferential, whose arms include OccurrenceJoinUnavailable), so it cannot carry an exact occurrence residual whatever pipeline compiles it; a rehearsal that observes a proposed cut through the old implementation is admissible as a differential, and what it may not do is be the authority that still answers after the surgery"
     PersistedBehavioralReceipt => "a persisted behavioral receipt over a discriminating corpus"
     PersistedPromotionOutcome => "a persisted PromotionOutcome over a named candidate"
     SeedDeletionObservation => "an observation of the live tree that the v1 seed families (interpreter, cli_run, seed harness, interpreter floor) are ABSENT, read from the tree rather than from an authored roster"

dag/gunbc/instruments/frontier_ingestion_probe.dag

@@ -255,7 +255,7 @@ fn classify_after_lex(
 }
 
 fn classify_source_in(world: FrontendWorld, source: String) -> FrontendStage {
-  match lex_walk_artifact(source: source, file: ^frontier_probe, rules: world.lex_rules) {
+  match lex_walk_artifact(source: chars(s: source), file: ^frontier_probe, rules: world.lex_rules) {
     v2.std.diagnostic.Rejected { diagnostics: _ } => LexRefused
     v2.std.diagnostic.Accepted { value: a, diagnostics: _ } =>
       classify_after_lex(prepared: world.prepared, residue: world.validation_residue, artifact: a)
@@ -276,7 +276,7 @@ fn classify_source_in(world: FrontendWorld, source: String) -> FrontendStage {
 // a stage by construction.
 
 fn classify_source(source: String) -> v2.std.diagnostic.Outcome<FrontendStage> {
-  match lex_walk_artifact(source: source, file: ^frontier_probe, rules: dag_lex_rules()) {
+  match lex_walk_artifact(source: chars(s: source), file: ^frontier_probe, rules: dag_lex_rules()) {
     v2.std.diagnostic.Rejected { diagnostics: _ } =>
       Accepted { value: LexRefused, diagnostics: None }
     v2.std.diagnostic.Accepted { value: a, diagnostics: _ } =>

dag/gunbc/recurring_failure_mode/call_expression_erased_at_v2_body_lowering.dag

@@ -13,7 +13,7 @@ data call_expression_erased_at_v2_body_lowering: RecurringFailureMode = Recurrin
 
     "DISTINGUISHING FACTS, because two neighbouring rows look like this one and are not. `unresolved_callee_conflated_with_dispatched_elsewhere` is the v1 ExprCall-tail class: there the callee reaches the classifier and the miss is absorbed later. Here the callee never reaches resolve at all. And the earlier dated measurements (v2.test.claim.staged_front_end unbound_symbol_reason_note, v2.test.claim.dag_acceptance frontier_arm_note) attributed the silence to resolve. That was the wrong stage: resolve is correct over the tree it receives, and the tree has already lost the call. A wall authored in resolve would therefore be a decoration (DESIGN section 4b), because the undeclared-callee RED and the declared-callee positive control arrive as identical trees.",
 
-    "RECEIPT (2026-09-12, still-eagle-447, NAMESPACE XL-2 scoping). The normalized tree was dumped for five bodies via prepare_grammar, parse_module_prepared and normalize -- the calls v2.compiler.program_assembly program_assembly_read_to_normalized_root_prepared makes, and so the census route's own hand-off (v2.compiler.compile native_test_context_from_ingest). `{ k }` keeps `Atom:k`. `{ x }` over a parameter keeps `Atom:x`. `{ g(x: 1) }` with g declared, `{ zzz(x: 1) }` and `{ zzz(1) }` with zzz undeclared all become `Transform [ Atom:dag_token_lbrace ]`. The unprepared parse_module route (v2.compiler.staged_front_end run_front_end) dumps identically, so this is not a second lossy route beside a faithful one.",
+    "RECEIPT (2026-09-12, still-eagle-447, NAMESPACE XL-2 scoping). The normalized tree was dumped for five bodies via prepare_grammar, parse_module_prepared and normalize -- the calls v2.compiler.program_assembly program_assembly_read_to_normalized_root_prepared makes, and so the census route's own hand-off (v2.compiler.compile native_test_context_from_ingest). (That composition was DELETED by gunbc#11985, which threaded one occurrence allocator across the ingest and left it with no caller; the receipt is dated and its reading stands, but the live route is now program_assembly_read_to_normalized_root_seeded.) `{ k }` keeps `Atom:k`. `{ x }` over a parameter keeps `Atom:x`. `{ g(x: 1) }` with g declared, `{ zzz(x: 1) }` and `{ zzz(1) }` with zzz undeclared all become `Transform [ Atom:dag_token_lbrace ]`. The unprepared parse_module route (v2.compiler.staged_front_end run_front_end) dumps identically, so this is not a second lossy route beside a faithful one.",
 
     "EVIDENCE LEVEL, stated so the receipt is not read one rung high. The dumps ran the v2 .dag through the gunbc interpreter at main f9d37e43a1, and a structural node-count fold (not a printer) agrees: the parse tree grows with a call's arguments and nesting, while the normalized body of { g(x: 1) } is exactly one node larger than { k } -- the Transform and its lbrace atom -- and { g(x: h(y: 5)) } is no larger than that. A second named argument adds one node, so the lowering keeps something per extra argument, but none of the callee or argument content. That the natively emitted normalize behaves identically is not executed. The native route gives no contrary evidence: its receipt on the #10940 head (eager-raven-113, 2026-09-12) holds exactly one Passed identity, a literal-bodied smoke test, and every richer body refuses before or at eval (v2.compiler.infer node_grounding_frontier_note). So no route has been observed to lower a call faithfully.",
 

dag/gunbc/recurring_failure_mode/emitted_field_carrier_diverges_from_the_dag_type_authored_against.dag

@@ -18,7 +18,7 @@ data emitted_field_carrier_diverges_from_the_dag_type_authored_against: Recurrin
 
     "THE RULE THE AUTHOR CANNOT SEE, stated because the obvious summary of it is WRONG. `v1.compiler.emit_rust` `needs_box_wrapping` boxes a field whose type is in `recursive_types`, and an OPTIONAL-cardinality field inherits that decision from its inner type by recursing with required cardinality; `rust_field_carrier_final_type` then renders `Box<T>`. So it is NOT 'an Optional field boxes' -- whether it boxes depends on whether its inner type rides a recursion cycle, which is a property of the WHOLE CORPUS and not of the declaration. Two fields spelled with the same cardinality in the same record can take different carriers, and neither spelling says so.",
 
-    "SPECIMEN, gunbc PR 11206 (perf item C instrument, draft), 2026-09-12. A new carrier `v2.compiler.compile` `NativeTestFrontEnd` carries `residue: Diagnostics`, where `v2.std.diagnostic` `Diagnostics` is `Optional<NonEmptyDiagnostics>` and `NonEmptyDiagnostics` is recursive. The field emitted as `Box<Option<Rc<NonEmptyDiagnostics>>>` while `v2.compiler.program_assembly` `program_assembly_phase_parse` takes `residue` by value, so the emitter template's `front_end.residue.clone()` cloned the Box: `error[E0308]: expected Option<Rc<NonEmptyDiagnostics>>, found Box<Option<Rc<NonEmptyDiagnostics>>>` at `src/main.rs:407`, help `consider unboxing the value`. The sibling fields on the same carrier -- `lm: LanguageModel`, `prepared: PreparedGrammar` -- took `Rc<..>` and their `.clone()` was correct, which is exactly the per-field divergence this row names. Repair: `(*front_end.residue).clone()`.",
+    "SPECIMEN, gunbc PR 11206 (perf item C instrument, draft), 2026-09-12. A new carrier `v2.compiler.compile` `NativeTestFrontEnd` carries `residue: Diagnostics`, where `v2.std.diagnostic` `Diagnostics` is `Optional<NonEmptyDiagnostics>` and `NonEmptyDiagnostics` is recursive. The field emitted as `Box<Option<Rc<NonEmptyDiagnostics>>>` while `v2.compiler.program_assembly` `program_assembly_phase_parse` takes `residue` by value, so the emitter template's `front_end.residue.clone()` cloned the Box (that phase was DELETED by gunbc#11985 with the unseeded composition it served; the receipt is dated and its reading stands, and the live phase is `program_assembly_phase_parse_measured_seeded`): `error[E0308]: expected Option<Rc<NonEmptyDiagnostics>>, found Box<Option<Rc<NonEmptyDiagnostics>>>` at `src/main.rs:407`, help `consider unboxing the value`. The sibling fields on the same carrier -- `lm: LanguageModel`, `prepared: PreparedGrammar` -- took `Rc<..>` and their `.clone()` was correct, which is exactly the per-field divergence this row names. Repair: `(*front_end.residue).clone()`.",
 
     "WHAT DID NOT CATCH IT, each checked rather than assumed: `gunbc run` typechecked both changed modules under the whole `dag` + `src/v2` closure and was green; `cargo fmt --all --check` passed; `claim_executor --required-regen` regenerated the emitter's own projection and adjudicated it, reaching `first_generation_equal` on the file CONTAINING the defective template text, because regen compares emitted BYTES against the authority and never compiles the program those bytes describe.",
 

dag/gunbc/recurring_failure_mode/realization_respells_a_modeled_folds_sequencing_to_instrument_it.dag

@@ -18,7 +18,7 @@ data realization_respells_a_modeled_folds_sequencing_to_instrument_it: Recurring
 
     "WHAT IS ALREADY SINGLE-AUTHORED, so the row is not read as wider than it is. Only the ordering and the inter-phase diagnostic merge are re-spelled. The absorbing half of the step -- the qualified-name read and the source-root index insertion -- stays one declaration that the driver calls (`v2.compiler.compile` `native_test_context_absorb`), the per-phase bodies are each one modeled declaration, and the unmeasured composition remains live and is executed by the SAME BINARY in its census mode, so the two spellings ship together rather than one replacing the other.",
 
-    "SPECIMEN, gunbc PR 11219 (perf item C instrument), 2026-09-13, found by review 65068 rather than by a mechanism. `v2.compiler.program_assembly` `program_assembly_read_to_normalized_root_prepared` composes tokenize, parse and normalize in one declaration, each phase binding the previous phase's `Outcome`. The emitted `std.compiler_entry.SourceRootEvalDriver` opens that sequence as a Rust `for` loop over the ingest -- `program_assembly_phase_tokenize`, then `program_assembly_phase_parse_measured`, then `program_assembly_measured_outcome`, then `program_assembly_phase_normalize`, then `native_test_context_absorb` -- so that each call can be bracketed by `Instant::now()`. The diff's own comment asserted the equivalence in prose; nothing executed it.",
+    "SPECIMEN, gunbc PR 11219 (perf item C instrument), 2026-09-13, found by review 65068 rather than by a mechanism. `v2.compiler.program_assembly` `program_assembly_read_to_normalized_root_prepared` composes tokenize, parse and normalize in one declaration, each phase binding the previous phase's `Outcome`. (That composition and its unseeded phases were DELETED by gunbc#11985, which threaded one occurrence allocator across the ingest and left them with no caller; the class is unchanged and its live instance is now the same loop re-spelling `program_assembly_read_to_normalized_root_seeded`, which the evidence below names.) The emitted `std.compiler_entry.SourceRootEvalDriver` opens that sequence as a Rust `for` loop over the ingest -- `program_assembly_phase_tokenize`, then `program_assembly_phase_parse_measured_seeded`, then `program_assembly_measured_outcome`, then `program_assembly_phase_normalize`, then `native_test_context_absorb` -- so that each call can be bracketed by `Instant::now()`. The diff's own comment asserted the equivalence in prose; nothing executed it.",
 
     "IT IS THE MODULE THAT OWNS THE ORDER THAT IS FORKED, AND AN EARLIER REVISION OF THIS ROW DID NOT REACH IT (review 65114). The row first argued only against `v2.compiler.program_assembly` `program_assembly_read_to_normalized_root_prepared`, the composition sitting beside the phases. The declared authority for the .dag front-end ORDER is `v2.compiler.staged_front_end`, whose own header names re-inlining its calls as the section-3 nickname class; a per-phase decomposition authored anywhere else is a second copy of THAT order, and saying so against the local composition understated the fork.",
 
@@ -34,7 +34,7 @@ data realization_respells_a_modeled_folds_sequencing_to_instrument_it: Recurring
   ],
 
   evidence: [
-    DeclarationRef { module_path: "v2.compiler.program_assembly", decl_name: "program_assembly_read_to_normalized_root_prepared", field: WholeDeclaration },
+    DeclarationRef { module_path: "v2.compiler.program_assembly", decl_name: "program_assembly_read_to_normalized_root_seeded", field: WholeDeclaration },
     DeclarationRef { module_path: "v2.compiler.staged_front_end", decl_name: "run_front_end_to", field: WholeDeclaration },
     DeclarationRef { module_path: "v2.compiler.compile", decl_name: "native_test_context_absorb", field: WholeDeclaration },
   ],