PREFIX dissolution lens L1.1-L1.12 acceptance keys

INVARIANTS.md

@@ -365,6 +365,7 @@ Per **Dispatch-Discipline Mechanisms (b)** above, each **new** path added to `EX
 | `src/v3/compiler/tests/integration/common/wiring_scanner_test.rs` | **ROADMAP:** same **v3 lens capability honesty pass** bullet — Band-C `tests/integration.rs` `#[path]` wiring is enforced by `integration_rs_wiring_scan.rs` + `cementing_dispatch.rs`. **Dissolution:** remove when `integration.rs` wiring can be validated structurally for cementing modules without line scanners. **Interim ratchet:** unit tests for helpers promoted from the retired `cementing_lens_registry_dispatch_test.rs` monolith. |
 | `src/v3/compiler/tests/integration/ctrl_pr_digests_dag_smoke_test.rs` | **Project plan:** `docs/r4-ctrl-dag-migration-project-plan.md` §3 — catalog **#8** `dsl/ctrl/pr_digests.dag` (Wave-1 ctrl → `.dag` subsystem modeling). **PR receipt (P5 Mechanism (b)):** this INVARIANTS row + the matching `EXPECTED_HAND_AUTHORED_TEST` line in `sg0_census_test.rs` land in the same PR as the smoke test. **Dissolution:** remove when `compile_to_dag` (or a single generated harness) validates `module … service …` ctrl carrier files end-to-end without a parallel Rust string/lexer ratchet, or when the contract migrates to `.dag` `TestClaim` coverage. **Interim ratchet:** `ctrl_pr_digests_dag_tokenizes_and_matches_expected_surface` requires clean tokenization plus presence of `module ctrl.pr_digests`, `import extdeps.github.pulls { PullRequest, PullReview, ReviewComment }`, `std.errors` / `std.types` imports, the four Practice-4 sum/record carriers (with `🟡 STAGED` / `🟢 TERMINAL` markers per `dsl/ctrl/README.md`), `ReviewCommentBody` + `review_line_comments` wiring, and `service ctrl.PrDigests` / the four `operation` blocks / `readonly`. |
 | `src/v3/compiler/tests/integration/extdeps_sql_transport_test.rs` | **ROADMAP:** `ROADMAP.md` § **Nine lanes** row `T-PB-B` / `pb_rust_tests_outside_residual_zero`; this Rust integration receipt keeps HTTP/SQL/audit extdeps compiled by the existing v3 parser before downstream emission-target consumers rely on them. **Dissolution:** remove when extdeps transport and Phase 3 emission-target files are covered by a `.dag`-native parse/authority suite or generated test harness rather than per-file Rust `compile_to_dag` probes. **Interim ratchet:** `rest_transport_dag_compiles_cleanly` and `sql_transport_dag_compiles_cleanly` pin `dsl/extdeps/transports/rest.dag` and `dsl/extdeps/transports/sql.dag`; `http_server_extdep_dag_compiles_cleanly`, `sql_migration_extdep_dag_compiles_cleanly`, and `audit_event_extdep_dag_compiles_cleanly` pin `dsl/extdeps/http/server.dag`, `dsl/extdeps/sql/migration.dag`, and `dsl/extdeps/audit/event.dag` as parseable staged emission-target substrate. The field-sensitive companions (`http_server_target_fields_are_authoritative_substrate_edges`, `sql_migration_target_fields_bound_raw_sql_scaffold`, `audit_event_target_fields_preserve_cloudevents_core_names`) consume the new target-contract fields directly so they fail on raw `String`/`Int` regressions, missing SQL scaffold bounds, or CloudEvents alias drift while the first real projection consumer is still staged; the audit ratchet also locks CloudEvents core fields to branded carriers and `std.types.Timestamp` rather than raw strings. |
+| `src/v3/compiler/tests/integration/coverage_defect_acceptance_dag_test.rs` | **Coverage-defect acceptance keys:** `src/v4/lens/coverage.dag` carries the canonical coverage-key set for `docs/design-dissolution-lens.md` §5.1; the old emit-template key is retired into `TemplateHole`, and the old string-escape key is split into `TemplateHole` plus `CanonicalCarrier`. **ROADMAP:** `ROADMAP.md` § **Nine lanes** row **T-PB-B** / `pb_rust_tests_outside_residual_zero`. **PR receipt (P5 Mechanism (b)):** this INVARIANTS row + matching `EXPECTED_HAND_AUTHORED_TEST` line in `sg0_census_test.rs` land in the same PR as the parse-level ratchet. **Dissolution:** remove when the v4 coverage lens runs as `.dag` / generated coverage and can assert the same acceptance rows without this host parser check. **Interim ratchet:** `coverage_defect_acceptance_keys_match_declared_rows` tokenizes/parses `src/v4/lens/coverage.dag` and asserts the exact parsed `(coverage_defect_* data row, CoverageDefectKey variant)` set matches the expected acceptance-key table while rejecting retired emit-template / string-escape names. |
 | `src/v3/compiler/tests/integration/v4_lens_registry_dag_smoke_test.rs` | **Operator pin** `docs/briefs/r4-lane-a-lens-interface-freeze-pin.md` §3 / **PREFIX T-23 v0** (`src/v4/lens/registry.dag` — **`LensIdV0`** closed sum + **`LensModulePathV0`**). **ROADMAP:** `ROADMAP.md` § **Nine lanes** row **T-PB-B** / `pb_rust_tests_outside_residual_zero`. **P2 / Practice 5:** this smoke is a **parse + inference cleanliness** probe for `src/v4/lens/registry.dag` only — it does **not** claim a **generated** substrate consumer for `LensRegistryEntryV0` (INVARIANTS §P2: declaration without generated consumer = staging; see `STRUCTURE.md`). **PR receipt (P5 Mechanism (b)):** this INVARIANTS row + matching `EXPECTED_HAND_AUTHORED_TEST` line in `sg0_census_test.rs` land in the same PR as the smoke harness. **Dissolution:** remove when `registry.dag` is exercised only by `.dag` `TestClaim` rows / a generated harness that mechanically reads registry rows without this per-file Rust `compile_to_dag` probe. **Interim ratchet:** `v4_lens_registry_dag_compiles` asserts `compile_to_dag` succeeds with empty `dag.diagnostics()` for the pinned `include_str!` source. |
 | `src/v3/compiler/tests/integration/file_attachment_substrate_carrier_test.rs` | **R3 program plan:** `docs/r3-program-plan.md` §1.8 gate **#62** `substrate_gap_file_ingestion_closed` (T-Workflow-As-Data substrate-gap class; worker brief `docs/briefs/r3-substrate-gate-62-file-attachment-carrier-worker.md`). **Dissolution:** remove when a `.dag` `TestClaim` / PB-B-1 runner receipt can assert `FileAttachment` field names + cross-module nominal wiring against `generated_full_bootstrap_dag()` without this hand-Rust structural ratchet (same dissolution posture as `timing_lens_substrate_carrier_test.rs` for gate #55). **Interim ratchet:** `file_attachment_shape_locked` + `file_attachment_field_types_locked` + `file_attachment_field_count_is_five` pin the ratified Refined-B-1 five-field subset of `WorkflowObservationAnchor` (`NodeId`, `ContentHash`, `WorkflowProducerId`, `WorkflowRunId`, `Nanoseconds`) exactly as declared in `src/v3/std/timing_lens.dag`; existence proof carrier construction stays in-module as `gate_62_file_attachment_demo_record`. |
 | `src/v3/compiler/tests/integration/lens_application_substrate_carrier_test.rs` | **R3 program plan:** `docs/r3-program-plan.md` §1.8 gate **#89** `section_ref_substrate_landed` (T-Lens-Application-Surface — `SectionRef` disjoint sum over `DeclarationScope` and `NodeScope` in `src/v3/std/lens_application.dag`; design authority `docs/design-lens-application-surface.md` §1.2–§2). **PR receipt (P5 Mechanism (b)):** this INVARIANTS row + matching `EXPECTED_HAND_AUTHORED_TEST` line in `sg0_census_test.rs` land in the same PR as the harness. **Dissolution:** remove when a `.dag` `TestClaim` / PB-B-1 runner receipt can assert `SectionRef` variant labels, field names, and `DeclarationId` / `NodeId` nominal wiring against `generated_full_bootstrap_dag()` without this hand-Rust structural ratchet (same dissolution posture as gate **#62** `file_attachment_substrate_carrier_test.rs`). **Interim ratchet:** `gate_89_section_ref_is_disjoint_sum_from_lens_application_authority` pins variant order (`DeclarationScope` then `NodeScope`) and payload fields to `lens_application.dag`. |

docs/design-dissolution-lens.md

@@ -75,9 +75,10 @@ same way:
 > mechanical lens.**
 
 A lens is added from *real evidence* — a finding that reached merge-ready
-despite being a defect (§8). The lens's signature is the smallest
-structural pattern that catches that finding's class with zero false
-positives on the clean shape.
+despite being a defect (§8), or a checkable review / audit receipt that
+names the same defect shape, its live substrate home, and its dissolve
+trigger. The lens's signature is the smallest structural pattern that
+catches that finding's class with zero false positives on the clean shape.
 
 ## 4. Layer 0 — standard compiler hygiene
 
@@ -177,35 +178,35 @@ sibling labels for one consolidated signature space.
 ### 5.1 Canonical L1.x acceptance-key names (rebase target for downstream consumers)
 
 Downstream consumers that need to register acceptance / coverage rows
-per Layer-1 lens (e.g. `src/v4/lens/coverage.dag`'s `dissolution_l1_*`
-rows) MUST use the canonical key names enumerated here. The lens
-suite is the single authority; key sets in other files are projections
-of this enumeration.
+per Layer-1 lens (e.g. `src/v4/lens/coverage.dag`'s `coverage_defect_*`
+rows) MUST use the canonical key names enumerated here. The lens suite
+is the single authority; key sets in other files are projections of this
+enumeration.
 
 | Lens / sub-signature | Canonical acceptance-key name |
 |---|---|
-| L1.1 Discriminant-predicate | `dissolution_l1_1_discriminant_predicate` |
-| L1.2 Degenerate-type | `dissolution_l1_2_degenerate_type` |
-| L1.3 Hollow-type | `dissolution_l1_3_hollow_type` |
-| L1.4 Carrier-clone | `dissolution_l1_4_carrier_clone` |
-| L1.5 Catamorphism | `dissolution_l1_5_catamorphism` |
-| ~~L1.6 Emit/template~~ | **retired — see L1.10.a below; no `dissolution_l1_6_*` key** |
-| L1.7 Off-substrate-fact | `dissolution_l1_7_off_substrate_fact` |
-| L1.8 Wrong-home | `dissolution_l1_8_wrong_home` |
-| L1.9 Vacuous-arm | `dissolution_l1_9_vacuous_arm` |
-| **L1.10.a** `TemplateHole` (sub-signature of Textual-bypass family) | `dissolution_l1_10_a_template_hole` |
-| **L1.10.b** `CanonicalCarrier` (sub-signature of Textual-bypass family) | `dissolution_l1_10_b_canonical_carrier` |
-| L1.11 Plausible-fallback | `dissolution_l1_11_plausible_fallback` |
-| L1.12 Parallel-authority | `dissolution_l1_12_parallel_authority` |
+| L1.1 Discriminant-predicate | `coverage_defect_discriminant_predicate` |
+| L1.2 Degenerate-type | `coverage_defect_degenerate_type` |
+| L1.3 Hollow-type | `coverage_defect_hollow_type` |
+| L1.4 Carrier-clone | `coverage_defect_carrier_clone` |
+| L1.5 Catamorphism | `coverage_defect_catamorphism` |
+| ~~L1.6 Emit/template~~ | **retired — see L1.10.a below; no `coverage_defect_emit_template` key** |
+| L1.7 Off-substrate-fact | `coverage_defect_off_substrate_fact` |
+| L1.8 Wrong-home | `coverage_defect_wrong_home` |
+| L1.9 Vacuous-arm | `coverage_defect_vacuous_arm` |
+| **L1.10.a** `TemplateHole` (sub-signature of Textual-bypass family) | `coverage_defect_template_hole` |
+| **L1.10.b** `CanonicalCarrier` (sub-signature of Textual-bypass family) | `coverage_defect_canonical_carrier` |
+| L1.11 Plausible-fallback | `coverage_defect_plausible_fallback` |
+| L1.12 Parallel-authority | `coverage_defect_parallel_authority` |
 
 **Migration notes for existing downstream consumers:**
-- Any consumer carrying `dissolution_l1_6_emit_template` is **stale**;
-  rename to `dissolution_l1_10_a_template_hole` (the renamed
+- Any consumer carrying `coverage_defect_emit_template` is **stale**;
+  rename to `coverage_defect_template_hole` (the renamed
   sub-signature).
-- Any consumer carrying `dissolution_l1_10_string_escape_hatch` (the
+- Any consumer carrying `coverage_defect_string_escape_hatch` (the
   pre-merge name) is **stale**; replace with the two sub-signature
-  rows `dissolution_l1_10_a_template_hole` AND
-  `dissolution_l1_10_b_canonical_carrier`. L1.10 itself is no longer
+  rows `coverage_defect_template_hole` AND
+  `coverage_defect_canonical_carrier`. L1.10 itself is no longer
   a single mechanical unit — it's a lens family per §5.0's exception.
 - These names are stable as of this revision; further changes to the
   L1.x taxonomy will require a corresponding update to this enumeration
@@ -1140,7 +1141,7 @@ A living record. Every finding that reaches merge-ready despite a defect
 is logged here, root-caused by the §3 methodology — so the lens set grows
 from real evidence, not speculation.
 
-| date | PR | finding | core invariant violated | lens |
+| date | receipt | finding | core invariant violated | lens |
 |---|---|---|---|---|
 | 2026-05-18 | #3250 | `free_monoid_non_empty` hand-rolled discriminant | A coproduct's variant-discriminant is a derived operation | L1.1 |
 | 2026-05-18 | #3255 | `nat_is_zero` hand-rolled discriminant | same | L1.1 |

scripts/ci-merge/sg0-pr-body-append.3318.txt

@@ -0,0 +1,3 @@
+SG-0 hand-path delta: +1
+
+SG-0 pairing: (c) Net add is one `EXPECTED_HAND_AUTHORED_TEST` row for the v4 coverage lens ratchet (`coverage_defect_acceptance_dag_test.rs`) plus the matching `INVARIANTS.md` §P5(b) receipt row. The ratchet follows the post-#3334 canonical Layer-1 key set: L1.6 is retired into L1.10.a, and monolithic L1.10 is split into L1.10.a/L1.10.b. Dispatch posture: retire this host check when the v4 coverage lens runs as `.dag` / generated coverage per ROADMAP T-PB-B (`pb_rust_tests_outside_residual_zero`); dispatch evidence: gunbc#3318 (this PR).

src/v3/compiler/tests/integration.rs

@@ -59,6 +59,8 @@ mod cementing_provenance_origin_integration_test;
 mod complexity_lens_behavioral_completion;
 #[path = "integration/cementing/cost_lens_symbolic_consumer_test.rs"]
 mod cost_lens_symbolic_consumer_test;
+#[path = "integration/coverage_defect_acceptance_dag_test.rs"]
+mod coverage_defect_acceptance_dag_test;
 #[path = "integration/cross_target_coverage_carrier_test.rs"]
 mod cross_target_coverage_carrier_test;
 #[path = "integration/ctrl_pr_digests_dag_smoke_test.rs"]

src/v3/compiler/tests/integration/coverage_defect_acceptance_dag_test.rs

@@ -0,0 +1,138 @@
+//! **Layer:** integration
+//!
+//! Ratchet coverage-defect acceptance keys into the v4 coverage-lens
+//! substrate. The check is intentionally structural and stays at parse level
+//! because v4 single-file checks do not load sibling lens/std imports as a
+//! bundle yet.
+
+use v3_compiler::parse_for_test;
+use v3_compiler::parse_surface::{SurfaceExpr, SurfaceItem, SurfaceRecordField};
+use v3_compiler::tokenize_for_test;
+
+use std::collections::BTreeSet;
+
+const COVERAGE_DAG: &str = include_str!("../../../../v4/lens/coverage.dag");
+const COVERAGE_PATH: &str = "src/v4/lens/coverage.dag";
+
+const EXPECTED_ACCEPTANCE_ROWS: &[(&str, &str)] = &[
+    (
+        "coverage_defect_discriminant_predicate",
+        "DiscriminantPredicate",
+    ),
+    ("coverage_defect_degenerate_type", "DegenerateType"),
+    ("coverage_defect_hollow_type", "HollowType"),
+    ("coverage_defect_carrier_clone", "CarrierClone"),
+    ("coverage_defect_catamorphism", "Catamorphism"),
+    ("coverage_defect_template_hole", "TemplateHole"),
+    ("coverage_defect_off_substrate_fact", "OffSubstrateFact"),
+    ("coverage_defect_wrong_home", "WrongHome"),
+    ("coverage_defect_vacuous_arm", "VacuousArm"),
+    ("coverage_defect_canonical_carrier", "CanonicalCarrier"),
+    ("coverage_defect_plausible_fallback", "PlausibleFallback"),
+    ("coverage_defect_parallel_authority", "ParallelAuthority"),
+];
+
+const RETIRED_ACCEPTANCE_ROWS: &[(&str, &str)] = &[
+    ("coverage_defect_emit_template", "EmitTemplate"),
+    ("coverage_defect_string_escape_hatch", "StringEscapeHatch"),
+];
+
+#[test]
+fn coverage_defect_acceptance_keys_match_declared_rows() {
+    let module = parse_module(COVERAGE_DAG, COVERAGE_PATH);
+    let observed_variants = module
+        .items
+        .iter()
+        .find_map(|item| match item {
+            SurfaceItem::TypeSum { name, variants, .. } if name == "CoverageDefectKey" => Some(
+                variants
+                    .iter()
+                    .map(|variant| variant.name.as_str())
+                    .collect::<BTreeSet<_>>(),
+            ),
+            _ => None,
+        })
+        .unwrap_or_else(|| panic!("{COVERAGE_PATH}: missing CoverageDefectKey coproduct"));
+    let expected_variants = EXPECTED_ACCEPTANCE_ROWS
+        .iter()
+        .map(|(_, variant)| *variant)
+        .collect::<BTreeSet<_>>();
+
+    assert_eq!(
+        observed_variants, expected_variants,
+        "{COVERAGE_PATH}: CoverageDefectKey variants must exactly match canonical coverage-defect keys"
+    );
+
+    let retired_variants = RETIRED_ACCEPTANCE_ROWS
+        .iter()
+        .map(|(_, variant)| *variant)
+        .collect::<BTreeSet<_>>();
+    assert!(
+        observed_variants.is_disjoint(&retired_variants),
+        "{COVERAGE_PATH}: retired emit-template / string-escape variants must not reappear"
+    );
+
+    let observed = module
+        .items
+        .iter()
+        .filter_map(|item| match item {
+            SurfaceItem::Data { name, body, .. } if name.starts_with("coverage_defect_") => Some((
+                name.as_str(),
+                acceptance_defect_variant(name, body.as_ref()),
+            )),
+            _ => None,
+        })
+        .collect::<BTreeSet<_>>();
+    let expected = EXPECTED_ACCEPTANCE_ROWS
+        .iter()
+        .copied()
+        .collect::<BTreeSet<_>>();
+
+    assert_eq!(
+        observed, expected,
+        "{COVERAGE_PATH}: coverage-defect acceptance rows must exactly map canonical keys"
+    );
+
+    let retired = RETIRED_ACCEPTANCE_ROWS
+        .iter()
+        .copied()
+        .collect::<BTreeSet<_>>();
+    assert!(
+        observed.is_disjoint(&retired),
+        "{COVERAGE_PATH}: retired emit-template / string-escape rows must not reappear"
+    );
+}
+
+fn acceptance_defect_variant<'a>(row_name: &str, body: Option<&'a SurfaceExpr>) -> &'a str {
+    let Some(SurfaceExpr::Record { fields, .. }) = body else {
+        panic!("{COVERAGE_PATH}: {row_name} must have a record initializer");
+    };
+    let concern = field_value(fields, "concern")
+        .unwrap_or_else(|| panic!("{COVERAGE_PATH}: {row_name} must initialize concern"));
+    let SurfaceExpr::VariantRecord { target, fields, .. } = concern else {
+        panic!("{COVERAGE_PATH}: {row_name}.concern must construct CoverageDefectAcceptanceKey");
+    };
+    assert_eq!(
+        target, "CoverageDefectAcceptanceKey",
+        "{COVERAGE_PATH}: {row_name}.concern must construct CoverageDefectAcceptanceKey"
+    );
+    let lens = field_value(fields, "lens")
+        .unwrap_or_else(|| panic!("{COVERAGE_PATH}: {row_name}.concern must initialize lens"));
+    let SurfaceExpr::Var { name, .. } = lens else {
+        panic!("{COVERAGE_PATH}: {row_name}.concern.lens must be a CoverageDefectKey variant");
+    };
+    name.as_str()
+}
+
+fn field_value<'a>(fields: &'a [SurfaceRecordField], name: &str) -> Option<&'a SurfaceExpr> {
+    fields
+        .iter()
+        .find(|field| field.name == name)
+        .map(|field| &field.value)
+}
+
+fn parse_module(source: &str, file: &str) -> v3_compiler::parse_surface::SurfaceModule {
+    let tokens = tokenize_for_test(source, file)
+        .unwrap_or_else(|diag| panic!("{file}: tokenization failed: {diag:?}"));
+    parse_for_test(&tokens, file).unwrap_or_else(|diag| panic!("{file}: parse failed: {diag:?}"))
+}

src/v3/compiler/tests/integration/sg0_census_test.rs

@@ -828,6 +828,10 @@ const EXPECTED_HAND_AUTHORED_TEST: &[&str] = &[
     // R3 T-V2-Retirement §1.8 gate #41 (`v2_oracle_no_remaining_test_consumers`): comment-aware
     // source ratchet — no `v2-compiler` crate references outside `src/v2/`.
     "src/v3/compiler/tests/integration/v2_oracle_no_remaining_test_consumers_test.rs",
+    // Coverage-defect acceptance keys: parse-level ratchet for
+    // `src/v4/lens/coverage.dag`; retires when generated coverage owns the
+    // same key projection.
+    "src/v3/compiler/tests/integration/coverage_defect_acceptance_dag_test.rs",
     // PREFIX T-23 v0: `compile_to_dag` smoke on `src/v4/lens/registry.dag` (P2-staging
     // `LensIdV0` + `LensModulePathV0`; no generated consumer yet). SG-0 + INVARIANTS §P5(b) receipt.
     "src/v3/compiler/tests/integration/v4_lens_registry_dag_smoke_test.rs",