Run the emitted v2 compiler natively and close construct coverage

dag/extdeps/languages/go/types.dag

@@ -24,6 +24,11 @@ data go_type_checkpoints: List<TypeCheckpoint> = [
   { dag_name: "Json",   target_type: "interface{}", grounding_type: "interface{}", default_expr: "nil",        is_copy: none, literal_suffix: none }
 ]
 
+// NO PointwisePower ROW — see extdeps.languages.rust.types (the note above
+// rust_algebra_inhabitants) for the full reasoning. PointwisePower is the open-support
+// characteristic-function carrier; a finite map[...]struct{} realizes FinitePowerSet, not it.
+// The fossil row's only live effect was the record-literal refusal panic, measured on the
+// emitted 00_compile closure's first native run (2026-09-07).
 data go_algebra_inhabitants: List<InhabitantDecl> = [
 
   { algebra: "FreeMonoid",
@@ -40,13 +45,6 @@ data go_algebra_inhabitants: List<InhabitantDecl> = [
     import_path: none,
     is_copy: none },
 
-  { algebra: "PointwisePower",
-    template: "map[\{0\}]struct{}",
-    arity: 1,
-    identity_expr: "nil",
-    import_path: none,
-    is_copy: none },
-
   { algebra: "PartialFunction",
     template: "map[\{0\}]\{1\}",
     arity: 2,

dag/extdeps/languages/python/types.dag

@@ -24,6 +24,11 @@ data python_type_checkpoints: List<TypeCheckpoint> = [
   { dag_name: "Json",   target_type: "dict", grounding_type: "dict",  default_expr: "{}",     is_copy: none, literal_suffix: none }
 ]
 
+// NO PointwisePower ROW — see extdeps.languages.rust.types (the note above
+// rust_algebra_inhabitants) for the full reasoning. PointwisePower is the open-support
+// characteristic-function carrier; a finite set[...] realizes FinitePowerSet, not it. The fossil
+// row's only live effect was the record-literal refusal panic, measured on the emitted
+// 00_compile closure's first native run (2026-09-07).
 data python_algebra_inhabitants: List<InhabitantDecl> = [
   { algebra: "FreeMonoid",
     template: "list[\{0\}]",
@@ -39,13 +44,6 @@ data python_algebra_inhabitants: List<InhabitantDecl> = [
     import_path: none,
     is_copy: none },
 
-  { algebra: "PointwisePower",
-    template: "set[\{0\}]",
-    arity: 1,
-    identity_expr: "set()",
-    import_path: none,
-    is_copy: none },
-
   { algebra: "PartialFunction",
     template: "dict[\{0\}, \{1\}]",
     arity: 2,

dag/extdeps/languages/rust/types.dag

@@ -51,6 +51,23 @@ data rust_checkpoint_scalar_arity_note: String = "A TypeCheckpoint row states on
 // authority for how a Rust primitive is spelled is `extdeps.languages.rust.primitives`
 // `rust_grounding_primitives`, through its `target_name` rows. A name list here would be
 // a second spelling authority for one fact.
+// NO PointwisePower ROW IN THIS ROSTER, BY CONSTRUCTION. PointwisePower<T> is the OPEN-support
+// power set presented as a characteristic function (std.algebra, profile OpenSupport): its only
+// construction is a record literal carrying `member: fn(T) -> Bool`, and no finite enumerable
+// BTreeSet can realize an open membership oracle. The row that stood here was a pre-split
+// fossil — std.algebra's carrier-split note records the byte-identical "BooleanAlgebra" /
+// "PointwisePower" rows that prompted the split, and the FinitePowerSet row below keeps the
+// finite-set realization the fossil actually described. Its one live effect was measured on the
+// emitted 00_compile closure's first native run (2026-09-07):
+// keyed_container_has_target_inhabitant answered true for the record literal, so twelve
+// language-model and nullable-fixpoint construction sites emitted the record-shaped-carrier
+// refusal panic where the interpreted pipeline evaluates — while the type renderer, keyed on
+// declaration provenance, already rendered PointwisePower structurally, so the row made the two
+// emission paths disagree. Removing it routes construction to the same structural path the type
+// renderer already takes (the bool_boolean_algebra pattern: Rc'd closure fields, _phantom
+// filled). Regression control:
+// test.claim.self_host_emitted_call_target_realization_witness_test
+// w_pointwise_power_record_shape_constructs_its_structural_carrier.
 data rust_algebra_inhabitants: List<InhabitantDecl> = [
 
   { algebra: "FreeMonoid",
@@ -67,13 +84,6 @@ data rust_algebra_inhabitants: List<InhabitantDecl> = [
     import_path: none,
     is_copy: false },
 
-  { algebra: "PointwisePower",
-    template: "BTreeSet<\{0\}>",
-    arity: 1,
-    identity_expr: "BTreeSet::new()",
-    import_path: none,
-    is_copy: false },
-
   { algebra: "FinitelySupportedFunction",
     template: "HashMap<\{0\}, \{1\}>",
     arity: 2,

dag/extdeps/languages/typescript/types.dag

@@ -24,6 +24,11 @@ data ts_type_checkpoints: List<TypeCheckpoint> = [
   { dag_name: "Json",   target_type: "unknown", grounding_type: "unknown",    default_expr: "null",            is_copy: false, literal_suffix: none }
 ]
 
+// NO PointwisePower ROW — see extdeps.languages.rust.types (the note above
+// rust_algebra_inhabitants) for the full reasoning. PointwisePower is the open-support
+// characteristic-function carrier; a finite Set<...> realizes FinitePowerSet, not it. The fossil
+// row's only live effect was the record-literal refusal panic, measured on the emitted
+// 00_compile closure's first native run (2026-09-07).
 data ts_algebra_inhabitants: List<InhabitantDecl> = [
 
   { algebra: "FreeMonoid",
@@ -40,13 +45,6 @@ data ts_algebra_inhabitants: List<InhabitantDecl> = [
     import_path: none,
     is_copy: false },
 
-  { algebra: "PointwisePower",
-    template: "Set<\{0\}>",
-    arity: 1,
-    identity_expr: "new Set()",
-    import_path: none,
-    is_copy: false },
-
   { algebra: "PartialFunction",
     template: "Map<\{0\}, \{1\}>",
     arity: 2,

dag/gunbc/commit_workflow.dag

@@ -1684,8 +1684,8 @@ data commit_gate_roster: List<CommitCheckEnrollment> = [
       check_fns: [
         "ingested_classical_not_resolves_holds",
         "ingested_classical_not_arrow_has_match_holds",
-        "ingested_classical_not_canonical_emit_refuses_underived_holds",
-        "ingested_classical_not_staging_emit_refuses_underived_holds",
+        "ingested_classical_not_canonical_emit_accepts_holds",
+        "ingested_classical_not_staging_emit_accepts_holds",
         "ingested_classical_not_emit_accepts_holds",
         "ingested_classical_not_emit_octet_bridge_shape_holds",
         "ingested_classical_not_emit_source_arm_shape_holds"

dag/gunbc/declined_live_tree_defect_classification.dag

@@ -205,8 +205,8 @@ data group_a_remaining_rows: List<ClassifiedRow> = [
   ClassifiedRow {
     identity: identity(module_path: "v2.test.execution.self_host_candidate_generation", function: "candidate_generation_translate_self_emit_dag_add_slice_holds"),
     classification: RealDefect { subject: CompilerBehaviourRefusal },
-    measured_evidence: "staged by execution: infer(dag_add_emitted_root) ACCEPTS, translate(inferred, dag_add_target_model) REFUSES with head reason infer_grounding_not_derived; identical under --hermetic and --wet, so the mode is not the discriminator",
-    disposition: RoutedToOwner { owner: "the v2 self-host lane -- infer_grounding_not_derived is the known v2-self-grounding-frontier class already registered in gunbc.guarantee_probe_corpus, not a new defect" }
+    measured_evidence: "staged by execution: infer(dag_add_emitted_root) ACCEPTS, translate(inferred, dag_add_target_model) REFUSES with head reason infer_grounding_not_derived; identical under --hermetic and --wet, so the mode is not the discriminator. REPAIR RECEIPT, 2026-09-07: the owner lane's declared-inhabitant roster-membership derivation (v2.compiler.infer infer_node_declared_in_language_inhabitants) grounds the slice's ten type-spine nodes by lookup against the dag language authority's declared-inhabitants roster, and the witness now PASSES under claim_batch --hermetic on the repairing tree (re-measured after the merge onto main at 5ee9cab5fa). The classification and the first sentence are kept verbatim as the dated record of the defect as routed; this sentence is the repair measurement.",
+    disposition: RepairedInThisChange
   },
   ClassifiedRow {
     identity: identity(module_path: "v2.test.lens_test_migration_debt.test_migration_debt_test", function: "retained_rust_kernel_wall_holds_against_live_tree"),

dag/gunbc/explicit_witness_admission.dag

@@ -337,14 +337,6 @@ data explicit_witness_admissions: List<ExplicitWitnessAdmission> = [
     reason: "the discriminating closing validation for roadmap node namespace-reference-derived-closure, RED BY DESIGN while its six-clause production admission frontier carries typed unavailable rows naming #7515 and the Class-B pool-independence wall. The separately discovered fixture suite executes P1 and proves every clause rejects its planted wrong output; this witness imports no fixture admissions and is bound directly by namespace_reference_derived_closure_execution_contract, so zero implementation progress cannot verify as complete.",
     dissolution: unbound_dissolution(description: "the production candidate producer and dependency projection establish all six ReferenceDerivedClosureCapability rows by execution — this row deletes in the completing change, promoting the unchanged acceptance witness to ordinary DiscoverySelection as the permanent namespace-derived-closure regression wall")
   ),
-  known_red_probe(
-    entry: "src/v2/test/claim/long/direct_rust_door_production_group_test.dag",
-    f: "direct_rust_door_production_group_closing_expectation_holds",
-    kind: CorpusWitnessKind,
-    budget: SubstrateLongLaneEvalBudget,
-    reason: "THE canonical closing validation for roadmap node v2-emitter-direct-rust-door, RED BY EXECUTION. Say the location claim exactly: ONE production implementation authority, ONE production walk per group construction, ONE scheduled group construction (the second occurrence was the budget-by-batch-membership deficit, closed 2026-08-06 when the eval budget became its own declared axis; direct_rust_door_group_root_is_scheduled_exactly_once is the executing receipt), and the IN-MEMORY group locates EmissionRejected while the SCHEDULED executor receipt remains an unlocated Bool. Inside that group the observation stops at EmissionRejected, so the four artifact leaves report LeafNotReached carrying that stage while the missing-rule leaf is green. That one green leaf is what proves the red is located rather than uniform — for a consumer holding the group, not for anyone reading the falsifier receipt. It replaces three superseded rows deleted in the same change, whose fold answered SeedEmitterRequiredForWrittenSource for BOTH a rejected pipeline and a seed-dependent artifact. Not relaxable: the only edit that may green it is making the real inferred tree survive emission.",
-    dissolution: unbound_dissolution(description: "every leaf reaches LeafEstablished by execution — this row deletes in the completing change, promoting the unchanged group root to ordinary DiscoverySelection as the lane's permanent regression wall")
-  ),
   known_red_probe(
     entry: "dag/test/claim/self_host_parse_engine_hooks_behavioral_witness_test.dag",
     f: "self_host_parse_engine_hooks_behavioral_receipt_holds",

dag/gunbc/guarantee_stall/roster.dag

@@ -29,7 +29,6 @@ import gunbc.guarantee_stall.enforcement_live_closure_gate_stall { enforcement_l
 import gunbc.guarantee_stall.mandatory_tag_live_corpus_stall { mandatory_tag_live_corpus_stall }
 import gunbc.guarantee_stall.parse_ingest_grammar_relation_stall { parse_ingest_grammar_relation_stall }
 import gunbc.guarantee_stall.required_regen_host_derivation_stall { required_regen_host_derivation_stall }
-import gunbc.guarantee_stall.self_host_candidate_generation_add_slice_stall { self_host_candidate_generation_add_slice_stall }
 import gunbc.guarantee_stall.self_host_hand_authorized_cargo_toml_stall { self_host_hand_authorized_cargo_toml_stall }
 import gunbc.guarantee_stall.self_host_hand_authorized_driver_source_stall { self_host_hand_authorized_driver_source_stall }
 import gunbc.guarantee_stall.self_host_spelling_search_stall { self_host_spelling_search_stall }
@@ -186,7 +185,6 @@ data all_guarantee_stalls: List<GuaranteeStall> = [
   mandatory_tag_live_corpus_stall,
   parse_ingest_grammar_relation_stall,
   required_regen_host_derivation_stall,
-  self_host_candidate_generation_add_slice_stall,
   self_host_hand_authorized_cargo_toml_stall,
   self_host_hand_authorized_driver_source_stall,
   self_host_spelling_search_stall,

dag/gunbc/instruments/emission_entry_instrument.dag

@@ -531,6 +531,19 @@ fn emission_scope_entry(sc: EmissionScope) -> EmissionScopeEntry {
 // recorded target TRUE BY CONSTRUCTION rather than checked afterwards, which is section 5's order
 // of preference; and where the triple cannot be read the half REFUSES, because an unpinned target
 // is exactly the state this pin exists to exclude. Found by review on gunbc#9857.
+//
+// THE TOOLCHAIN CHANNEL IS PINNED BY THE SAME ARGUMENT, ONE LEVEL UP. The cargo half runs with
+// cwd = out_dir, a fresh mktemp directory: with no rust-toolchain.toml there, rustup resolves the
+// host's DEFAULT toolchain, and a census under cargo 1.83 against one under cargo 1.93 would
+// compare as equal epochs while different compilers did the measuring -- the fabricated
+// comparability the target pin excludes, at the channel layer. Measured 2026-09-07 on this
+// instrument: a host default of 1.83.0 met a crates.io index whose freshly published dependency
+// manifests require edition2024, dependency resolution failed before any diagnostic existed, and
+// the zero-diagnostic refusal fired (correctly) on an unmeasured tree. The pin is propagated by
+// COPYING the repo's rust-toolchain.toml into out_dir: the file remains the sole in-repo channel
+// authority (its header forbids a second pinned literal), and the copy makes the measured channel
+// true by construction on any host. The gate's read_live_toolchain observes the same channel
+// because every documented actuator invokes from the repository root, which the same file governs.
 fn measure_cargo_half(
   subject: EmissionMeasurementSubject,
   root: String,
@@ -582,11 +595,18 @@ fn measure_cargo_half(
         path: concat(out_dir, "/Cargo.toml"),
         content: cssl_v1_compiled_probe_lib_cargo_toml(root: root)
       )
-      if !manifest.success {
+      let channel = Filesystem.Read(path: concat(root, "/rust-toolchain.toml"))
+      let channel_pin = if channel.success {
+        Filesystem.Write(path: concat(out_dir, "/rust-toolchain.toml"), content: channel.content).success
+      } else {
+        false
+      }
+      let scaffold_incomplete = !manifest.success || !channel_pin
+      if scaffold_incomplete {
         EmissionCargoUnreached {
           subject: subject,
           stage: StageManifest,
-          cause: concat("could not write the probe crate manifest under ", out_dir),
+          cause: concat("could not write the probe crate manifest and toolchain channel pin under ", out_dir),
           emit_diagnostics: emit_diagnostics,
           emitted_files: emitted_files
         }