Delete the floor's stale live-tree decline

dag/gunbc/discovery_census.dag

@@ -12,7 +12,7 @@ import gunbc.build_target {
 }
 import v2.workflow.required_floor {
   RequiredFloorDisposition,
-  Planned, DeclinedLongModule, DeclinedLiveTree,
+  Planned, DeclinedLongModule, DeclinedFixtureMember,
   required_floor_site_disposition,
 }
 import v2.std.live_tree { LiveTreeDisposition }
@@ -52,6 +52,8 @@ import std.integer { Int }
 // on the ENTRY PATH a witness was found in and carries no authored module name at all. The two
 // are different keys for different questions — where a declaration was found, versus which
 // identity it is — and the disposition below can only be computed from the second.
+// `reads_live_tree` now serves selection-eligibility consumers only. Required-floor disposition
+// no longer consumes it, and retaining the field here must not recreate the deleted decline.
 type DiscoveredSite {
   module_path: String
   function: String
@@ -197,8 +199,7 @@ fn census_fold_site(state: CensusFoldState, site: DiscoveredSite) -> CensusFoldS
             CensusRow {
               label: l,
               disposition: required_floor_site_disposition(
-                module_path: site.module_path,
-                reads_live_tree: site.reads_live_tree
+                module_path: site.module_path
               )
             }
           ], state.rows_reversed),
@@ -244,7 +245,7 @@ fn census_partition_step(acc: CensusPartition, row: CensusRow) -> CensusPartitio
     Planned => CensusPartition { planned: concat([row], acc.planned), declined: acc.declined }
     DeclinedLongModule { matched_prefix: _ } =>
       CensusPartition { planned: acc.planned, declined: concat([row], acc.declined) }
-    DeclinedLiveTree =>
+    DeclinedFixtureMember { matched_prefix: _ } =>
       CensusPartition { planned: acc.planned, declined: concat([row], acc.declined) }
   }
 }
@@ -296,7 +297,7 @@ fn required_aggregate_from_census(census: SiteCensus) -> RequiredAggregateDeriva
 
 // THE COUNTS ARE DERIVED AND THE PARTITION IS EXACT BY CONSTRUCTION, so there is no
 // partition-exactness check here. Each row holds exactly one disposition and the fold below
-// matches it with no wildcard, so `offered` is the sum of the four arms because there is nowhere
+// matches it with no wildcard, so `offered` is the sum of the three arms because there is nowhere
 // else for a row to go — a check restating that would be validation standing where construction
 // already holds (DESIGN §5). The floor's own host-side partition check exists because THERE the
 // counters are incremented independently and can drift; here they cannot.
@@ -309,15 +310,15 @@ type CensusCounts {
   offered: Int
   planned: Int
   declined_long_module: Int
-  declined_live_tree: Int
+  declined_fixture_member: Int
 }
 
 fn census_counts_zero() -> CensusCounts {
   CensusCounts {
     offered: 0,
     planned: 0,
     declined_long_module: 0,
-    declined_live_tree: 0
+    declined_fixture_member: 0
   }
 }
 
@@ -328,21 +329,21 @@ fn census_counts_add(counts: CensusCounts, d: RequiredFloorDisposition) -> Censu
         offered: counts.offered + 1,
         planned: counts.planned + 1,
         declined_long_module: counts.declined_long_module,
-        declined_live_tree: counts.declined_live_tree
+        declined_fixture_member: counts.declined_fixture_member
       }
     DeclinedLongModule { matched_prefix: _ } =>
       CensusCounts {
         offered: counts.offered + 1,
         planned: counts.planned,
         declined_long_module: counts.declined_long_module + 1,
-        declined_live_tree: counts.declined_live_tree
+        declined_fixture_member: counts.declined_fixture_member
       }
-    DeclinedLiveTree =>
+    DeclinedFixtureMember { matched_prefix: _ } =>
       CensusCounts {
         offered: counts.offered + 1,
         planned: counts.planned,
         declined_long_module: counts.declined_long_module,
-        declined_live_tree: counts.declined_live_tree + 1
+        declined_fixture_member: counts.declined_fixture_member + 1
       }
   }
 }

dag/gunbc/emitter_shared_layer_producer_census.dag

@@ -84,9 +84,10 @@ type SharedLayerProducer {
 // witness_test holds the repair and its two controls. Against the pre-repair binary the repair arm
 // returns false and both controls return true; against the post-repair binary all three return
 // true -- taken by running each test fn directly, which is a real execution receipt. It is NOT a
-// standing one: that file declares ReadsLiveTree truthfully, and v2.workflow.required_floor's
-// retained DeclinedLiveTree arm therefore discovers and declines it, so nothing re-takes these
-// measurements until that arm's staged deletion lands. BLAST RADIUS: a full required-regen over the
+// standing one on main before this cut: that file declares ReadsLiveTree truthfully, and the
+// now-deleted DeclinedLiveTree arm discovered and declined it. With the root deletion these rows
+// execute; their terminal dispositions, rather than this pre-cut note, state the current result.
+// BLAST RADIUS: a full required-regen over the
 // 135-module seed subject drifted exactly one file, v1_compiler_emit_rust.rs -- the repair's own
 // mirror -- and re-ran first_generation_equal=true once that mirror was installed.
 //

dag/gunbc/floor_non_verdict_classification.dag

@@ -79,6 +79,8 @@ data closure_dependent_repaid_note: String = "EMPTY, AND THAT IS A REPAYMENT REC
 
 data closure_dependent_rows: List<ClassifiedNonVerdictRow> = []
 
+data realization_attempt_branch_repaid_note: String = "THE COMPOSED #9106 BRANCH CONTRIBUTED A TENTH ClosureDependentResolution specimen: gunbc.test.claim.realization_attempt_keystone_test.witness_planted_minimal_module_emits passed in its 179-module entry closure but the old floor union shadowed emit_produced's pattern-bound render with std.layout.render(doc, proto), producing the same missing-proto error as produced_decl_support_preserved. #9259 makes the lexical Value::Fn binding win, so this branch-only non-verdict and its expected-red row retire while the witness remains an ordinary regression control."
+
 data closure_independent_repaid_note: String = "EMPTY, AND THAT IS A REPAYMENT RECEIPT RATHER THAN A MISSING MEASUREMENT. This list held the four v2.test.manual.bootstrap_footprint_anchor identities, the only ClosureIndependent / HonestDebtWithStatedTrigger rows in the population. Their cause was a Symbol-declared field holding Int code points: semantic_decl_string_to_bundle_node folded a String into character atoms carrying raw code points, and canonical_hash_of_connective routed that field into content_hash_atom -> atom_identity_hash, which requires a string, so the hash threw before any assertion ran. Repaired at the PRODUCER by giving character atoms a string identity through from_code_point, with code_point as its inverse on the two decoders. All four now ANSWER: three PASS and bootstrap_footprint_canonical_holds FAILS honestly, so the four left this roster and the three passing ones left floor_expected_red in the same change. The list stays declared rather than deleted because the CAUSE remains constructible -- nothing prevents another producer putting a non-Symbol into Atom.identity -- and an emptied arm with its reason recorded is a different fact from an arm that never existed."
 
 data closure_independent_rows: List<ClassifiedNonVerdictRow> = []

dag/gunbc/floor_route_gap_seed_growth.dag

@@ -0,0 +1,20 @@
+module gunbc.floor_route_gap_seed_growth
+
+import gunbc.roadmap_model { RoadmapNodeId }
+import gunbc.seed_growth { SeedGrowthJustification }
+import std.decl_ref { DeclarationRef, WholeDeclaration }
+
+// FORWARD-FREEZE RECEIPT for the typed route-gap expectation consumed by the required floor.
+// The modeled authority is v2.workflow.floor_route_gap FloorRouteGapExpectation; these three
+// declarations are its seed-side realization at the interpreter boundary, not a second policy.
+data floor_route_gap_seed_growth_justification: SeedGrowthJustification = SeedGrowthJustification {
+  hand_authored_declarations: [
+    DeclarationRef { module_path: "v1_compiler.cli_run", decl_name: "FloorRouteGapExpectedGround", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run", decl_name: "FloorRouteGapExpectation", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run", decl_name: "floor_route_gap_expectation_mismatch", field: WholeDeclaration }
+  ],
+  reason: "WHY RUST IS STILL NEEDED: the required floor executes in the seed, and v1_compiler.cli_run is the boundary that receives v1_interpreter.HermeticEffectGround after a claim executes. v2.workflow.floor_route_gap owns the expectation vocabulary and population; the Rust realization decodes that authority and refuses when the observed operation or closed ground differs, instead of letting an identity-only enrollment absorb changed evidence. A modeled row without this consumer cannot constrain the host terminal ledger.\n\nWHY IT IS ADMITTED AGAINST THE v1 FREEZE: gunbc.v1_maintenance_standing v1_seed_standing admits work serving the v2 self-host program. The required floor is the instrument guarding that program, and this change strengthens a pre-existing route-gap debt roster from identity-only agreement to operation-and-ground agreement. It adds no language behavior, compatibility route, escape hatch, seed feature, or emitted public surface.\n\nHAND-ITEM DELTA: +3, exactly the closed ground mirror, the decoded expectation record, and the pure mismatch classifier enumerated above. All other Rust edits are inside existing declarations and are ExistingSeedItemModified.\n\nHAND-LOC DELTA AT THIS RECEIPT: src/v1/stage0/src/cli_run.rs +223/-49 and src/v1/stage0/src/bin/claim_executor.rs +5/-5 against origin/main. The latter adds no declaration. The item observation producer is currently absent, so these diff-derived figures remain review evidence rather than a mechanically joined admission.",
+  owning_dissolution_lane: "v1-hand-queue-drain" as RoadmapNodeId,
+  trigger: "Delete the three seed declarations when the self-emitted claim executor executes the required floor and consumes v2.workflow.floor_route_gap FloorRouteGapExpectation directly; the modeled expectation then remains the sole authority and the hand-written decode/classifier disappears with the v1 floor bridge.",
+  current_boundary: "v2.workflow.floor_route_gap FloorRouteGapExpectation -> v1_compiler.cli_run FloorRouteGapExpectation -> v1_compiler.cli_run floor_route_gap_expectation_mismatch -> v1_compiler.cli_run run_required_floor"
+}

dag/gunbc/guarantee_rung_drop.dag

@@ -1,7 +1,7 @@
 module gunbc.guarantee_rung_drop
 
 import std.types { String, List, Bool, Int }
-import v2.std.algebra { fold_list }
+import v2.std.algebra { Cons, Empty, fold_list }
 
 // THE TYPED CARRIER FOR A DESIGN section 4b(3) RUNG DROP.
 //
@@ -288,3 +288,97 @@ data next_rung_trigger_enforcement_stall: GuaranteeStall = GuaranteeStall {
   },
   next_rung_trigger: "every class this repository declares below its ceiling declares it through gunbc.guarantee_rung_drop GuaranteeStall rather than in prose, at which point the population becomes a fold over rows and a stall missing its trigger has no spelling. Not satisfied by this carrier existing: one row is a carrier with a consumer, not a migrated population, and the 4b(2) obligation stays review diligence for every class still stalling in an annotation"
 }
+
+// DECLINED-LIVE-TREE CENSUS, observed by required-floor run 32882641450 after the root decline
+// stopped hiding these subjects. The fifteen executing identities below project TEN facts. They
+// are stalls rather than drops: no guarantee stopped holding in this change; the facts were outside
+// the ladder because no required consumer executed them. `ClimbableButUnbuilt` states that each
+// repair is specifiable. Assignment is a dashboard routing fact and deliberately does not live in
+// this semantic carrier.
+
+data doc_graph_orphan_population_stall: GuaranteeStall = GuaranteeStall {
+  subject: "the derived documentation graph contains orphan documents",
+  current: OutsideTheLadder,
+  ceiling: MechanicallyPreventable,
+  blocker: ClimbableButUnbuilt,
+  population: BoundedPopulation { members: Cons { head: "test.claim.doc_reachability_witness.doc_graph_has_no_orphan_docs", tail: Cons { head: "v2.test.lens_doc_reachability.doc_reachability_test.doc_graph_has_no_orphan_docs", tail: Cons { head: "v2.test.lens_doc_reachability.doc_reachability_test.doc_graph_is_clean", tail: Empty {} } } } },
+  next_rung_trigger: "the derived orphan-document identity population is empty and every enrolled projection reports NowPassing"
+}
+
+data doc_graph_dangling_link_population_stall: GuaranteeStall = GuaranteeStall {
+  subject: "the derived documentation graph contains dangling links",
+  current: OutsideTheLadder,
+  ceiling: MechanicallyPreventable,
+  blocker: ClimbableButUnbuilt,
+  population: BoundedPopulation { members: Cons { head: "test.claim.doc_reachability_witness.doc_graph_has_no_dangling_links", tail: Cons { head: "v2.test.lens_doc_reachability.doc_reachability_test.doc_graph_has_no_dangling_links", tail: Cons { head: "v2.test.lens_doc_reachability.doc_reachability_test.doc_graph_is_clean", tail: Empty {} } } } },
+  next_rung_trigger: "the derived dangling-link identity population is empty and every enrolled projection reports NowPassing"
+}
+
+data enforcement_live_closure_gate_stall: GuaranteeStall = GuaranteeStall {
+  subject: "the live enforcement closure and its question-zero gate are non-green",
+  current: OutsideTheLadder,
+  ceiling: MechanicallyPreventable,
+  blocker: ClimbableButUnbuilt,
+  population: BoundedPopulation { members: Cons { head: "v2.test.claim.enforcement.lens_module_gate_witness.lens_closure_question_zero_holds_live", tail: Cons { head: "v2.test.claim.enforcement.lens_module_gate_witness.lens_module_gate_holds_live", tail: Cons { head: "v2.test.claim.enforcement.lens_module_gate_witness.question_zero_verdict_live_holds", tail: Empty {} } } } },
+  next_rung_trigger: "the live closure question returns zero and both gate projections report true"
+}
+
+data mandatory_tag_live_corpus_stall: GuaranteeStall = GuaranteeStall {
+  subject: "the live corpus contains a mandatory-tag violation",
+  current: OutsideTheLadder,
+  ceiling: MechanicallyPreventable,
+  blocker: ClimbableButUnbuilt,
+  population: BoundedPopulation { members: Cons { head: "v2.lens.mandatory_tag.corpus_scan_witness_test.corpus_live_clean_tree_wall_holds", tail: Empty {} } },
+  next_rung_trigger: "the derived mandatory-tag violation population is empty"
+}
+
+data parse_ingest_grammar_relation_stall: GuaranteeStall = GuaranteeStall {
+  subject: "parse and ingest disagree over the same grammar round trip",
+  current: OutsideTheLadder,
+  ceiling: StructurallyGuaranteed,
+  blocker: ClimbableButUnbuilt,
+  population: BoundedPopulation { members: Cons { head: "v2.test.execution.emit_ingest_grammar_relation_round_trip.same_grammar_parse_ingest_bridge_holds", tail: Empty {} } },
+  next_rung_trigger: "the same-grammar parse-to-ingest round trip holds"
+}
+
+data self_host_candidate_generation_add_slice_stall: GuaranteeStall = GuaranteeStall {
+  subject: "self-host candidate generation, translation, and emission disagree on the add slice",
+  current: OutsideTheLadder,
+  ceiling: MechanicallyPreventable,
+  blocker: ClimbableButUnbuilt,
+  population: BoundedPopulation { members: Cons { head: "v2.test.execution.self_host_candidate_generation.candidate_generation_translate_self_emit_dag_add_slice_holds", tail: Empty {} } },
+  next_rung_trigger: "candidate generation, translation, and self-emission agree on the add slice"
+}
+
+data non_fold_residue_roster_stall: GuaranteeStall = GuaranteeStall {
+  subject: "the live non-fold residue contains an unrostered or stale identity",
+  current: OutsideTheLadder,
+  ceiling: MechanicallyPreventable,
+  blocker: ClimbableButUnbuilt,
+  population: BoundedPopulation { members: Cons { head: "v2.test.lens_non_fold_residue.non_fold_residue_test.non_fold_residue_no_unrostered_or_stale", tail: Empty {} } },
+  next_rung_trigger: "the derived unrostered and stale non-fold-residue populations are both empty"
+}
+
+data retained_rust_live_tree_migration_stall: GuaranteeStall = GuaranteeStall {
+  subject: "live Rust-test discovery disagrees with the retained-kernel migration authority",
+  current: OutsideTheLadder,
+  ceiling: MechanicallyPreventable,
+  blocker: ClimbableButUnbuilt,
+  population: BoundedPopulation { members: Cons { head: "v2.test.lens_test_migration_debt.test_migration_debt_test.retained_rust_kernel_wall_holds_against_live_tree", tail: Empty {} } },
+  next_rung_trigger: "live Rust-test discovery and the retained-kernel authority join exactly"
+}
+
+// REQUIRED-FLOOR RUN 32942047138 first executed this ReadsLiveTree carrier after #9284 landed.
+// The direct byte-equality witness and its aggregate both returned false: one underlying fact,
+// namely that the committed .gitattributes no longer equals its emitting authority. This is real
+// generated-artifact drift, not a stale expectation. The floor cut's generated-artifact drift
+// gates are currently absent, so nothing refused the authority/artifact disagreement when it was
+// introduced; this bounded row keeps the two projections attached to the one repair obligation.
+data gitattributes_committed_emit_drift_stall: GuaranteeStall = GuaranteeStall {
+  subject: "the committed .gitattributes differs from the bytes derived by its emitting authority",
+  current: OutsideTheLadder,
+  ceiling: MechanicallyPreventable,
+  blocker: ClimbableButUnbuilt,
+  population: BoundedPopulation { members: Cons { head: "test.claim.gitattributes_emit_witness.witness_committed_matches_emit_holds", tail: Cons { head: "test.claim.gitattributes_emit_witness.witness_holds", tail: Empty {} } } },
+  next_rung_trigger: "node://adhoc-16f7520a-85f lands: identify the authority edit that introduced the drift, regenerate .gitattributes from that authority, and restore a required generated-artifact drift gate so later authority/artifact disagreement refuses"
+}

dag/gunbc/seed_growth_admission.dag

@@ -42,6 +42,7 @@ import gunbc.rust_item_identity { RustItemIdentity, rust_item_identity_key }
 import gunbc.seed_growth { SeedGrowthJustification }
 import gunbc.stage0_rust_host_observation { stage0_rust_observation_seed_growth_justification }
 import gunbc.floor_non_verdict_enrollment { floor_non_verdict_seed_growth_justification }
+import gunbc.floor_route_gap_seed_growth { floor_route_gap_seed_growth_justification }
 import gunbc.whole_corpus_compile_admission { whole_corpus_compile_seed_growth_justification }
 import std.decl_ref { DeclarationRef, WholeDeclaration }
 import std.disposition { Disposition }
@@ -146,6 +147,7 @@ fn seed_growth_justification_roster() -> List<SeedGrowthJustification> {
   [
     anonymous_record_resolution_seed_growth_justification,
     floor_non_verdict_seed_growth_justification,
+    floor_route_gap_seed_growth_justification,
     stage0_rust_observation_seed_growth_justification,
     observation_scoped_run_seed_growth_justification(),
     whole_corpus_compile_seed_growth_justification,