Production-path stage executor fixture (#7499 blocker 3)

dag/gunbc/ci_layer_roots.dag

@@ -472,6 +472,12 @@ data witness_exclusion_frontier: List<WitnessExclusionRow> = [
     reason: "floor_skip control fixtures at dir grain: driven by floor_skip_discovery_witness explicit rosters, never corpus witnesses (floor_skip_control_fixture_exclusion_note, witness_admission_fixture_note)",
     dissolve_on: "fixture-home policy changes (witness_admission_fixture_note); row deletes"
   },
+  WitnessExclusionRow {
+    pattern: "test/fixture/walk_plan_stage/",
+    classification: FixtureExplicitRoster,
+    reason: "walk_plan_stage production-path fixtures at dir grain: Wet typed-service controls driven only by plan.dag claim_executor recipes, never hermetic discovery witnesses (walk_plan_stage_control_fixture_exclusion_note, witness_admission_fixture_note)",
+    dissolve_on: "fixture-home policy changes (witness_admission_fixture_note); row deletes"
+  },
   WitnessExclusionRow {
     pattern: "test/claim/long/",
     classification: OfflineLocalRecipe,
@@ -1041,6 +1047,8 @@ fn falsifier_silent_pick_gate_roster() -> List<ScheduleWitnessEntry> {
 
 data floor_skip_control_fixture_exclusion_note: String = "test/fixture/floor_skip/ is excluded from tree-wide discovery at DIR grain (parent ruling 2026-07-11: a fixture that WANTS witness enrollment is mis-homed by definition, and file-grain exclusion invites the next control fixture to repeat the landmine). These fixtures exist to be driven by floor_skip_discovery_witness's explicit rosters, not as corpus witnesses: falsifier_divergence_control_test.dag carries a BY-DESIGN red row (falsifier_red_control_holds returns false to prove the divergence attribution channel), so any completed full-corpus run - the nightly falsifier, or a PR whose diff touches its import closure - would red on a row whose red is the control's specification, and a permanent by-design divergence would also make the falsifier's 8-clean-window retirement criterion unsatisfiable; live_tree_declared_test.dag declares ReadsLiveTree as a control, so as a corpus row it would be a permanent never-skip cost with no enforcement value. Genuine corpus witnesses that were mis-homed here have been re-homed under test/claim/ (provenance_fail_closed_contract_test, live_tree_collision_test). Explicit-roster runs (the floor_skip bin) are unaffected: witness exclusions apply to discovery only."
 
+data walk_plan_stage_control_fixture_exclusion_note: String = "test/fixture/walk_plan_stage/ is excluded from tree-wide discovery at DIR grain (same fixture-home ruling as floor_skip_control_fixture_exclusion_note): these are production-path stage-executor controls with Wet typed-service bodies (shell.Mkdir/Remove/Test, Filesystem.Read/Write, sleep.Delay) driven only through claim_executor --plan-entry/--plan-function recipes in plan.dag. As hermetic discovery witnesses they refuse at the effect boundary (no mock_response for Parents/Write/Read/RecursiveForce) or carry BY-DESIGN reds (failure_red_member_holds); inclusion turned every PR touching the import closure into 8 WitnessRed failures in discovery batch 3. Explicit plan-driven runs and walk_plan_stage_fixture.rs (#[ignore] integration) are unaffected."
+
 data enforcement_coverage_exclusion_note: String = "The three enforcement coverage witnesses (enforcement/cost_coverage_witness_test.dag, enforcement/grammar_coverage_witness_test.dag, enforcement_live_witness_test.dag) are operator-ruled OFFLINE (2026-07-11). Receipt: their *_live fns read the corpus as data (live-tree rosters), so the PR-A never-predict-skip rule for live-tree rows made them run on EVERY wide PR regardless of diff; the block cost 22.0 min (main run 29137081535, busy fleet) and 21.0 min (PR run 29142398465, quiet fleet) of the 60-minute floor budget - about 35 percent - and their allocation ramp feeds the ~15GiB slot memory.high throttle that turns the floor tail into swap-speed work. Their input is corpus-denominated (the InputEnvelope axis, not layer span): per-PR admission wants a declared bounded envelope, which these rows cannot declare today. Offlining required TWO edits (cursor review catch, same PR): the discovery exclusion rows here AND removing the explicit CommitCheckEnrollment for enforcement_live_witness_test.dag in gunbc.commit_workflow - explicit roster rows merge after discovery with no exclusion filter (cli_run.rs explicit_entries dedup), and that is correct: an explicitly declared row should run, so offlining one means deleting its declaration, never teaching exclusions to veto the roster (a second authority). Run them via the local recipe: claim_batch --source-root dag --source-root src/v2 --entry <entry> per fn (all pure reads, no --wet needed). Dissolve-on: witness rows declare InputEnvelope/CostEnvelope and the scheduled (nightly) lane admits corpus-input rows under its own budget - then re-enroll consciously through the floor owner's lane; the affected-set-falsifier cadence covers interim drift."
 
 data accumulator_copy_roster_gate_exclusion_note: String = "The three accumulator_copy_roster_gate*_test.dag witnesses are operator-ruled OFFLINE (2026-07-10: the gate is ~15m of serial interpreted resolve; run it via the claim_batch recipe in v2.lens.complexity_accumulator_copy.roster_gate). Excluded from discovery because the flip's selection cannot see them honestly either way: file_gate reads its roster targets via filesystem_read at runtime — a data dependency invisible to resolve-closure attribution — and the live-scan classifier reads only entry-file text, so the rows would be intermittently selected by lens/std-closure PRs (cost, against the ruling) while never firing on roster-target-only PRs (no enforcement). Dissolve-on: resolved-graph memoization receipts land AND G2 path-intersection (not G1 module-closure alone) is wired into floor admission axis (iv); then re-enroll consciously through the floor owner's lane."

dag/gunbc/walk_plan_stage_fixture_scaffold.dag

@@ -0,0 +1,28 @@
+module gunbc.walk_plan_stage_fixture_scaffold
+
+import std.disposition { Disposition, Scaffold, SingleAuthority }
+import std.decl_ref { DeclarationRef, WholeDeclaration }
+import std.types { Int, List, String }
+
+data walk_plan_stage_fixture_hand_rust_scaffold: Disposition = Scaffold {
+  dissolves_to: SingleAuthority,
+  bind: DeclarationRef {
+    module_path: "v2.test.fixture.walk_plan_stage.plan",
+    decl_name: "walk_plan_stage_overlap_barrier_recipe",
+    field: WholeDeclaration
+  }
+}
+
+data walk_plan_stage_fixture_hand_rust_dissolve_trigger: String = "🟡 dissolve-on: src/v1/stage0/tests/walk_plan_stage_fixture.rs — seed subprocess transport that drives plan.dag recipes through claim_executor for cold production-path controls (~7m each, #[ignore]). The behavioral contract lives in v2.test.fixture.walk_plan_stage.\{plan,common\}.dag; Rust materializes harness env from common.dag (walk_plan_stage_materialize_harness_authority_holds) and must not fork attempt/receipt/path literals. DISSOLVES WHEN ROADMAP.md v1-materialization-kernel (Compute things once and reuse the result — docs/plans/witness-realization-plan.md) lands a typed host-effect transport for plan-driven walks OR the controls run exclusively via documented plan.dag recipes without a parallel Rust authority fork — same dissolution family as std.realization_schedule walk_plan_run_stage_claim_executor_seed_deferral."
+
+data walk_plan_stage_fixture_hand_rust_loc_delta_net: Int = 1
+
+data walk_plan_stage_fixture_hand_rust_receipt_plan_anchor: String = "dag/std/realization_schedule.dag walk_plan_run_stage_claim_executor_seed_deferral"
+
+data walk_plan_stage_fixture_hand_rust_roadmap_lane_anchor: String = "ROADMAP.md v1-materialization-kernel — Compute things once and reuse the result (docs/plans/witness-realization-plan.md)"
+
+data walk_plan_stage_fixture_hand_rust_paths: List<String> = [
+  "src/v1/stage0/tests/walk_plan_stage_fixture.rs"
+]
+
+data walk_plan_stage_fixture_hand_rust_receipt_witness_entry: String = "dag/test/claim/walk_plan_stage_fixture_hand_rust_witness_test.dag"

dag/test/claim/walk_plan_stage_fixture_hand_rust_witness_test.dag

@@ -0,0 +1,57 @@
+module test.claim.walk_plan_stage_fixture_hand_rust_witness
+
+import gunbc.walk_plan_stage_fixture_scaffold {
+  walk_plan_stage_fixture_hand_rust_scaffold,
+  walk_plan_stage_fixture_hand_rust_dissolve_trigger,
+  walk_plan_stage_fixture_hand_rust_loc_delta_net,
+  walk_plan_stage_fixture_hand_rust_paths,
+  walk_plan_stage_fixture_hand_rust_receipt_plan_anchor,
+  walk_plan_stage_fixture_hand_rust_receipt_witness_entry,
+  walk_plan_stage_fixture_hand_rust_roadmap_lane_anchor
+}
+import v2.test.fixture.walk_plan_stage.common {
+  walk_plan_stage_attempt_id,
+  walk_plan_stage_stage1_receipt_path
+}
+import v2.test.fixture.walk_plan_stage.plan { walk_plan_stage_overlap_barrier_recipe }
+import std.disposition { Scaffold, SingleAuthority }
+import std.types { Bool }
+import v2.std.algebra { length }
+
+test fn walk_plan_stage_fixture_hand_rust_scaffold_is_seed_retained() -> Bool {
+  match walk_plan_stage_fixture_hand_rust_scaffold {
+    Scaffold { dissolves_to: SingleAuthority, bind: _ } => true
+    _ => false
+  }
+}
+
+test fn walk_plan_stage_fixture_hand_rust_receipt_is_checkable() -> Bool {
+  !(walk_plan_stage_fixture_hand_rust_dissolve_trigger == "")
+    && !(walk_plan_stage_fixture_hand_rust_receipt_plan_anchor == "")
+    && !(walk_plan_stage_fixture_hand_rust_roadmap_lane_anchor == "")
+    && walk_plan_stage_fixture_hand_rust_receipt_witness_entry == "dag/test/claim/walk_plan_stage_fixture_hand_rust_witness_test.dag"
+    && walk_plan_stage_fixture_hand_rust_loc_delta_net == length(xs: walk_plan_stage_fixture_hand_rust_paths)
+}
+
+test fn walk_plan_stage_fixture_hand_rust_roadmap_anchor_names_row() -> Bool {
+  string_contains(
+    s: walk_plan_stage_fixture_hand_rust_roadmap_lane_anchor,
+    pattern: "ROADMAP.md"
+  )
+    && string_contains(
+      s: walk_plan_stage_fixture_hand_rust_roadmap_lane_anchor,
+      pattern: "v1-materialization-kernel"
+    )
+    && string_contains(
+      s: walk_plan_stage_fixture_hand_rust_dissolve_trigger,
+      pattern: "v1-materialization-kernel"
+    )
+}
+
+test fn walk_plan_stage_fixture_recipes_carry_common_attempt_id() -> Bool {
+  string_contains(s: walk_plan_stage_overlap_barrier_recipe, pattern: walk_plan_stage_attempt_id)
+    && string_contains(
+      s: walk_plan_stage_overlap_barrier_recipe,
+      pattern: walk_plan_stage_stage1_receipt_path
+    )
+}