Receipt: the host-seam divergence reproduced as a two-binary discrimination

dag/gunbc/recurring_failure_mode/host_seam_self_call_diverges_when_its_arm_is_absent.dag

@@ -12,7 +12,7 @@ data host_seam_self_call_diverges_when_its_arm_is_absent: RecurringFailureMode =
 
     "HARM. DESIGN section 5 requires every path to succeed fully or fail with a typed, located diagnostic, and requires a failure arm to REFUSE. Here there is no arm to refuse from: the declaration is syntactically total, the projection roster that would say it is a seam (`std.primitive_projection` `primitive_projection_roster`, fidelity `HostRealizedSeam`) is consulted by the resolver for Rust emission and by NOBODY on the interpreted path, and the runtime discovers the state by exhausting a counter. The diagnostic then MISDIRECTS: `call depth exceeded 100000 at fn 'map_lookup_primitive_delegate' -- unbounded recursion (a bare-name resolution cycle, or a genuinely divergent chain)` names two candidate causes and a missing host realization is neither, so an investigator is pointed at recursion depth or at their own program. The cost is paid at the wrong end and by the wrong person -- in the specimen, by a lane that had to reason from a stack counter back to a PR it had not seen.",
 
-    "SPECIMEN, REPORTED BY ANOTHER LANE AND VERIFIED HERE FROM SOURCE, NOT REPRODUCED. On 2026-09-12 lane still-crab-505 ran a main-deploy `gunbc` binary over `dag/test/claim/review_sheet_converge_witness_test.dag` and it died with a `map_lookup_primitive_delegate` call-depth error; they declined to use that binary as a cost oracle, which was correct. What this row's author verified: gunbc#11121 (commit dfac90c3b06) introduced `v2.std.collection` `map_lookup_primitive_delegate` as a self-call body AND the `map_grounding.lookup` arm that intercepts it in ONE commit, so any binary built before that commit, ingesting the corpus after it, resolves the spelling to the declaration; and `v1.compiler.interpreter` `call_function_guarded` refuses at `CALL_DEPTH_LIMIT` (100_000) with exactly the wording above. The mechanism is fully determined by the two source reads; the lane's observation is the one execution of it this row can cite, and it is cited as a report.",
+    "SPECIMEN, FIRST REPORTED BY ANOTHER LANE AND VERIFIED FROM SOURCE, AND SINCE REPRODUCED -- the two-binary discrimination receipt in this row carries that reproduction, and this sentence used to read NOT REPRODUCED. On 2026-09-12 lane still-crab-505 ran a main-deploy `gunbc` binary over `dag/test/claim/review_sheet_converge_witness_test.dag` and it died with a `map_lookup_primitive_delegate` call-depth error; they declined to use that binary as a cost oracle, which was correct. What this row's author verified: gunbc#11121 (commit dfac90c3b06) introduced `v2.std.collection` `map_lookup_primitive_delegate` as a self-call body AND the `map_grounding.lookup` arm that intercepts it in ONE commit, so any binary built before that commit, ingesting the corpus after it, resolves the spelling to the declaration; and `v1.compiler.interpreter` `call_function_guarded` refuses at `CALL_DEPTH_LIMIT` (100_000) with exactly the wording above. The mechanism is fully determined by the two source reads; the lane's observation is the one execution of it this row can cite, and it is cited as a report.",
 
     "THE STALE BINARY IS THE OCCASION, NOT THE CLASS. The same divergence is reached by a future realization that renames or drops an arm, by an emission target with no registry row for the primitive, or by a new seam authored before its arm lands -- and the last of these has already happened: `std.primitive_projection` `symbol_lexeme_seam_disposition_note` records that `symbol_lexeme` and `symbol_intern_lexeme` carried self-call bodies with no roster row, so Rust emission emitted the declaration and `pub fn symbol_lexeme(sym: String) -> String { symbol_lexeme(sym) }` COMPILED. That was the same class on the other path, and it sat BELOW the interpreted path: no counter, no diagnostic, a host stack overflow at first call. THOSE TWO SITES ARE REPAIRED IN THE PRESENT SEED: `v1_compiler.v1_rt` `symbol_lexeme` and `symbol_intern_lexeme` are now emitted as identity functions with a comment stating that emitting a self-call produces a function that compiles and never returns, so the divergence is historical for the two named specimens and live for the class -- nothing refuses an unrealized self-call at acceptance, so the next seam authored before its arm or registry row lands diverges exactly as these did. The note names the residue and a next-rung trigger in a `String` data row inside std, which is section 4c's misplaced prose; this row is the ledger home it was missing, and the note is now a receipt of it.",
 
@@ -26,7 +26,17 @@ data host_seam_self_call_diverges_when_its_arm_is_absent: RecurringFailureMode =
 
     "NEXT-RUNG TRIGGER, naming the CAPABILITY: acceptance of any closure -- interpreted, emitted to each target, and by whichever binary performs the run -- refuses a same-name self-call declaration that either has no `HostRealizedSeam` projection row or whose row's primitive identity the executing realization carries no arm for, with a typed diagnostic located at the declaration. Sufficient that all thirteen sites above, and the next one authored, cannot reach `call_function_guarded` or `rustc` unrealized. A trigger naming only a projection row for the two unrostered sites, only an interpreter-side read of the roster, only a better wording of the call-depth message, or only a test that pins the current arm count does not discharge this: each leaves at least one path or one future site able to diverge, and the third re-names the wrong subject more accurately.",
 
-    "UNCERTAINTIES CARRIED. The specimen execution is a lane report; this author verified the mechanism from `dfac90c3b06` and the interpreter source and did not build a pre-#11121 binary to re-run it. The emitted-path claims are taken from `symbol_lexeme_seam_disposition_note`, the identity-form realization now in `v1_compiler.v1_rt`, and the resolver's stated suppression behaviour, not from an emission run performed for this row; that the two UNROSTERED self-call sites are absent from the emitted seed is a read of `src/v1` at f9d37e43a1, and whether an emission run that reached them would confirm a compiled self-call was not established by execution here. The denominator is a regex over first-expression self-application; a self-call reached through a `let` or a nested expression would be missed by the search and is not claimed absent.",
+    "**THE SPECIMEN IS NOW REPRODUCED, AS A TWO-BINARY DISCRIMINATION RATHER THAN A SIGNATURE MATCH (stern-bear-703, 2026-09-13).** Until now this class rested on matching the map_lookup_primitive_delegate signature: one lane reported it, this row's author verified the mechanism from source, and the row carried as an uncertainty that nobody had run a pre-#11121 binary against it. That is discharged. ",
+
+    "THE CONTROL HOLDS EVERYTHING BUT THE ARTIFACT FIXED: same corpus head (public gunbc 5504b6a7a), same probe file, same command, two binaries. THE DEFECTIVE WINDOW IS A COMMIT, NOT A DATE: a binary BUILT BEFORE dfac90c3b06 -- the #11121 commit that introduced the self-call body and its intercepting map_grounding.lookup arm together -- INGESTING A CORPUS FROM AFTER IT. The dates below identify these two artifacts; they do not define the class, and a binary built later from a branch that predates that commit falls in the same window. The binary built 2026-09-11 00:46 from a session branch at 1c0c30d4, which predates dfac90c3b06, DIVERGES with call depth exceeded 100000 at fn 'map_lookup_primitive_delegate'; the binary built 2026-09-13 06:30 at e2f2192 ANSWERS -- 'node is not in the roadmap authority' and 'declared nodes=168' on the same two calls. Artifact, not corpus, executed rather than inferred. THE CORPUS HEAD IS A CONSTANT IN THIS CONTROL AND ITS OWN CI COLOUR IS IRRELEVANT TO IT: 5504b6a7a's push run is red on an unrelated subject (two consumed namespace-admission rows), and that changes nothing here, because the comparison holds the corpus fixed and varies only the artifact. A reader who stops at the red head has read the wrong variable -- the same mistake, in miniature, that this receipt's own harm paragraph records. ",
+
+    "THE DISCRIMINATOR IS AN EMPTY INPUT, AND IT IS WHAT MAKES THIS EVIDENCE RATHER THAN A COINCIDENCE. gunbc.roadmap_launch_admission launch_admission over LaunchGraphProjected { nodes: [], edges: [] } diverges, and count(gunbc.roadmap_authority declared_roadmap_nodes()) diverges on its own. A divergence over ZERO nodes rules out a cycle among the input nodes and a node-count scale explanation: there are no input nodes to participate in either. It does not by itself rule out a defect in the fold implementation or an upstream producer; the host-seam mechanism is established separately by the source reads and the two-artifact discrimination. A negative worth one sentence so nobody re-runs it: the same probe truncated to 1, 10, 40, 100 and all 168 nodes diverges identically, so the ceiling does not track node count -- including at n=1. ",
+
+    "THE MIS-NAMED DIAGNOSTIC HAS A MEASURED COST NOW, which is this row's stated harm made concrete. The refusal text reads 'unbounded recursion (a bare-name resolution cycle, or a genuinely divergent chain)'. Taking it at its word, this author compared two corpus heads with the defective binary held fixed, concluded the newer head had regressed, and reported a PUBLIC REGRESSION to a manager who was about to spend a remote build pipeline on it. The report was retracted the same hour once the empty-input probe located the real variable. The cost of the mis-naming is therefore not hypothetical: one false regression report, one nearly-spent build, and an investigation that looked at the corpus because the diagnostic named the corpus. A seam with no arm is not a resolution cycle, and the text should not offer that as its first reading. ",
+
+    "WHY THE COMPARISON COULD NOT SEE IT, recorded because the next investigator will reach for the same instrument: two heads with one binary separates 'this head regressed' from 'nothing' only if the binary is sound. Where the binary carries the defect, the honest control needs a second ARTIFACT, not a second head. Three lanes matching one signature in two days was already the stronger inference and was available before the false report. ",
+
+    "UNCERTAINTIES CARRIED, ONE OF THEM NOW DISCHARGED AND SAID SO HERE RATHER THAN LEFT STANDING BESIDE ITS ANSWER. This row used to carry, as its first uncertainty, that the specimen execution was a lane report and that no pre-#11121 binary had been run against it: the two-binary discrimination above did exactly that run, on a corpus head held fixed, so that uncertainty is closed and the mechanism no longer rests on a source reading alone. What remains uncertain is unchanged. The emitted-path claims are taken from `symbol_lexeme_seam_disposition_note`, the identity-form realization now in `v1_compiler.v1_rt`, and the resolver's stated suppression behaviour, not from an emission run performed for this row; that the two UNROSTERED self-call sites are absent from the emitted seed is a read of `src/v1` at f9d37e43a1, and whether an emission run that reached them would confirm a compiled self-call was not established by execution here. The denominator is a regex over first-expression self-application; a self-call reached through a `let` or a nested expression would be missed by the search and is not claimed absent.",
   ],
 
   evidence: [