Heal main: three witness reds introduced by the #8062 merge

dag/gunbc/plans/model_realization_fork.dag

@@ -47,7 +47,7 @@ fn model_realization_fork_body() -> List<MarkdownBlock> {
     ]),
     p(text: "**Net:** grounding the numeric tower kills the *visible* straddle guards; splitting `Value::Null` is what actually closes the fail-open *class*. Until #2 lands, the cache/eq guards are per-site patches, not a dissolved root."),
     h2(text: "5. Infer-layer service-op String wire projection fork (algebra method attachment)"),
-    p(text: "**Registered class (2026-08-09, #8062 trim + bold-eagle-107):** extdeps service-operation outputs declared `String from \"stdout\"` (and sibling wire fields) infer as **FaithfulFreeMonoid / Coproduct** receivers in pure-v2 closures (`rust_corpus_repr` without v1 seed), while algebra **ReceiverSelf** method templates (trim, and every other String method) attach only to the **declared String** type node. Method syntax on the wire-minted receiver refuses (`method trim not found on Coproduct(FreeMonoid)`) even though the service contract names String. Free-call `trim(s: x)` with `import std.algebra { trim }` is a **binding bridge** only — it does not unify the type nodes (#8062 scope). **Pinning witness:** `fixtures/class_b_trim/monoid_specimen.dag` + `v1-compiler-tests::trim_method_form_fails_on_freemonoid_receiver`; carrier note `extdeps.shell.exec` `service_op_string_wire_projection_method_fork_note`. **Dissolve-on:** wire projection mints the same type node the extdeps output declaration names so ReceiverSelf methods attach without a per-method binding workaround."),
+    p(text: "**Registered class (2026-08-09, #8062 trim + bold-eagle-107):** extdeps service-operation outputs declared `String from \"stdout\"` (and sibling wire fields) infer as **FaithfulFreeMonoid / Coproduct** receivers in pure-v2 closures (`rust_corpus_repr` without v1 seed), while algebra **ReceiverSelf** method templates (trim, and every other String method) attach only to the **declared String** type node. Method syntax on the wire-minted receiver refuses (`method trim not found on Coproduct(FreeMonoid)`) even though the service contract names String. Free-call `trim(s: x)` with `import std.algebra { trim }` is a **binding bridge** only — it does not unify the type nodes (#8062 scope). **Pinning witness:** `fixtures/class_b_trim/monoid_specimen.dag` + `v1-compiler-tests::trim_method_form_fails_on_freemonoid_receiver`; carrier note `extdeps.shell.exec` `service_op_string_wire_projection_method_fork_note`. **Dissolve-on:** wire projection mints the same type node the extdeps output declaration names so ReceiverSelf methods attach without a per-method binding workaround. Execution receipt for the landed binding half: [class_b trim pool-coincidence receipt](../probes/class_b_trim_pool_coincidence_receipt.md)."),
     h2(text: "6. Relationship to the lock-down"),
     p(text: "This is the root the lock-down lane (`fail-closed-lockdown.md` §3a) was hunting. The §4 lock-down fixes (content-key caches, purity oracles, realizer-key lens) are *per-site patches* that stay necessary until this seam is grounded; grounding (esp. #2) makes whole classes of them dead code. Sequence the lock-down fixes to ship now (stop the bleeding), and the grounding (numeric tower → Null split) to dissolve the root behind them."),
   ]

dag/std/algebra.dag

@@ -420,6 +420,9 @@ fn all_algebra_template_names() -> List<String> {
 
 data trim_free_function_authority_note: String = "trim is the importable free-function authority for whitespace trim on String. The declared substrate body is a pure-dag seam (1 / 0); semantic execution routes through free_call.trim (v1_rt::trim). Host realization authority: std.primitives trim_contract. Emitted host-native std.algebra::trim delegates to v1_rt::trim via rust_host_string_op_fn_emit. The scalar template row trim on FreeMonoid<String> is the method spelling on the same carrier. Free-call trim(s) requires explicit import std.algebra { trim } — bare trim refuses via closure_independent_bare_free_call registry in v1.compiler.infer_env even when std.algebra is already in the compilation pool (#6985 Class B pool coincidence closed on trim by #8062)."
 
+// The seam diverges before producing anything; `s` is read in the condition so the declared
+// input reaches the result (wiring-liveness), mirroring the bytes.dag float-seam pattern —
+// both arms are the same unreached literal, there to give the expression its type.
 fn trim(s: String) -> String {
-  from_code_point(1 / 0)
+  if s == s { from_code_point(1 / 0) } else { from_code_point(1 / 0) }
 }

dag/test/claim/cross_file_binding_assembly_witness_test.dag

@@ -282,6 +282,10 @@ fn cfba_provider_with_reference_closure_row(
   }
 }
 
+// Provider carries BOTH a declaration and a reference, minting raw ids 0 and 1 from its
+// own independent allocator -- the declaration's raw id (0) collides with the consumer's
+// raw declaration id (also 0), so this exercises reference rekeying alongside declaration
+// rekeying, not references: [] as before.
 test fn colliding_raw_ids_assemble_to_distinct_closure_ids_with_joins_intact_holds() -> Bool {
   let consumer_module = cfba_path(dotted: "extdeps.consumer")
   let provider_module = cfba_path(dotted: "extdeps.provider")
@@ -291,10 +295,6 @@ test fn colliding_raw_ids_assemble_to_distinct_closure_ids_with_joins_intact_hol
     name: "ConsumerDecl",
     category: TypeOccurrence,
   )
-  // Provider carries BOTH a declaration and a reference, minting raw ids 0 and 1 from its
-  // own independent allocator -- the declaration's raw id (0) collides with the consumer's
-  // raw declaration id (also 0), so this exercises reference rekeying alongside declaration
-  // rekeying, not references: [] as before.
   let provider = cfba_provider_with_reference_closure_row(
     module_path: provider_module,
     file_path: "extdeps/provider.dag",

dag/test/claim/guarantee_probe_corpus_witness_test.dag

@@ -707,6 +707,14 @@ test fn canonical_probe_resolution_refuses_duplicate_population() -> Bool {
 // it is the sole one taken. Dissolution trigger: when #7790 closes and
 // sole_constructor_mint_fn_hole_still_compile_clean's expectation holds, remove this probe from
 // known_v1_migration_gap_ids so it is covered by disposition or registry retirement instead.
+// Probes authored directly against the v1 compile path with no Rust witness behind them. The
+// migration law below quantifies over every v1-compile row on the assumption that each descends
+// from a Rust witness that must be disposed; these do not, so disposing them would assert a
+// migration that never happened and listing them as gaps would assert a hole that is not there.
+// Both are the rung-inflation failure in miniature, one in each direction, so they get their own
+// arm. Membership here is not an exemption from evidence: each row still carries a discriminating
+// RED or a positive control executed by a test in this file.
+// The three arms must partition, or a row could claim two contradictory standings at once.
 test fn dark_suite_dispositions_cover_migrated_v1_probes() -> Bool {
   let dispositions = guarantee_probe_dark_suite_dispositions()
   let disposition_probes: List<GuaranteeProbeId> = dispositions
@@ -728,13 +736,6 @@ test fn dark_suite_dispositions_cover_migrated_v1_probes() -> Bool {
   let disposed_ids_have_no_internal_duplicates =
     distinct_string_count(values: disposition_probe_ids) == count(disposition_probe_ids)
   let known_v1_migration_gap_ids: List<String> = [sole_ctor_mint_fn_hole_probe as String]
-  // Probes authored directly against the v1 compile path with no Rust witness behind them. The
-  // migration law below quantifies over every v1-compile row on the assumption that each descends
-  // from a Rust witness that must be disposed; these do not, so disposing them would assert a
-  // migration that never happened and listing them as gaps would assert a hole that is not there.
-  // Both are the rung-inflation failure in miniature, one in each direction, so they get their own
-  // arm. Membership here is not an exemption from evidence: each row still carries a discriminating
-  // RED or a positive control executed by a test in this file.
   let dag_native_v1_compile_probe_ids: List<String> = [
     sole_ctor_admitted_caller_green_probe as String,
     sole_ctor_cast_red_probe as String,
@@ -750,7 +751,6 @@ test fn dark_suite_dispositions_cover_migrated_v1_probes() -> Bool {
         || string_list_contains(xs: known_v1_migration_gap_ids, wanted: id)
         || string_list_contains(xs: dag_native_v1_compile_probe_ids, wanted: id)
     })
-  // The three arms must partition, or a row could claim two contradictory standings at once.
   let dag_native_ids_are_not_disposed_or_gaps = dag_native_v1_compile_probe_ids
     |> all(id => !string_list_contains(xs: disposition_probe_ids, wanted: id)
       && !string_list_contains(xs: known_v1_migration_gap_ids, wanted: id))

docs/plans/model-realization-fork.md

@@ -46,7 +46,7 @@ Every primitive is **modeled** as a `.dag` coproduct and **realized** as a nativ
 
 ## 5. Infer-layer service-op String wire projection fork (algebra method attachment)
 
-**Registered class (2026-08-09, #8062 trim + bold-eagle-107):** extdeps service-operation outputs declared `String from "stdout"` (and sibling wire fields) infer as **FaithfulFreeMonoid / Coproduct** receivers in pure-v2 closures (`rust_corpus_repr` without v1 seed), while algebra **ReceiverSelf** method templates (trim, and every other String method) attach only to the **declared String** type node. Method syntax on the wire-minted receiver refuses (`method trim not found on Coproduct(FreeMonoid)`) even though the service contract names String. Free-call `trim(s: x)` with `import std.algebra { trim }` is a **binding bridge** only — it does not unify the type nodes (#8062 scope). **Pinning witness:** `fixtures/class_b_trim/monoid_specimen.dag` + `v1-compiler-tests::trim_method_form_fails_on_freemonoid_receiver`; carrier note `extdeps.shell.exec` `service_op_string_wire_projection_method_fork_note`. **Dissolve-on:** wire projection mints the same type node the extdeps output declaration names so ReceiverSelf methods attach without a per-method binding workaround.
+**Registered class (2026-08-09, #8062 trim + bold-eagle-107):** extdeps service-operation outputs declared `String from "stdout"` (and sibling wire fields) infer as **FaithfulFreeMonoid / Coproduct** receivers in pure-v2 closures (`rust_corpus_repr` without v1 seed), while algebra **ReceiverSelf** method templates (trim, and every other String method) attach only to the **declared String** type node. Method syntax on the wire-minted receiver refuses (`method trim not found on Coproduct(FreeMonoid)`) even though the service contract names String. Free-call `trim(s: x)` with `import std.algebra { trim }` is a **binding bridge** only — it does not unify the type nodes (#8062 scope). **Pinning witness:** `fixtures/class_b_trim/monoid_specimen.dag` + `v1-compiler-tests::trim_method_form_fails_on_freemonoid_receiver`; carrier note `extdeps.shell.exec` `service_op_string_wire_projection_method_fork_note`. **Dissolve-on:** wire projection mints the same type node the extdeps output declaration names so ReceiverSelf methods attach without a per-method binding workaround. Execution receipt for the landed binding half: [class_b trim pool-coincidence receipt](../probes/class_b_trim_pool_coincidence_receipt.md).
 
 ## 6. Relationship to the lock-down
 

src/v2/lens/test_migration_debt.dag

@@ -7,7 +7,11 @@ import v2.std.logic { Bool }
 import v2.std.text { String }
 
 // Class-5 carve-out: baselines are point-in-time RATCHET CEILINGS over live host tree scans (test_migration_debt_* builtins), not counts beside a committed roster. Deriving baseline from the same live scan would tautologize live_count <= baseline.
-data test_migration_debt_module_count_baseline: Int = 82
+// 82 -> 83 (2026-08-09): #8062 landed class_b_trim_specimen_test.rs, the Class B trim
+// pool-coincidence discriminating suite — a deliberate hand-Rust admission because the specimen
+// must observe v1 infer_env binding directly. Dissolution: migrates to the v2 witness route when
+// CI2 (#8043) covers compiler-subject tests; the ceiling may then ratchet back down.
+data test_migration_debt_module_count_baseline: Int = 83
 data test_migration_debt_total_loc_baseline: Int = 28247
 data test_migration_debt_total_test_fns_baseline: Int = 891