diff --git a/.github/workflows/witnesses.yml b/.github/workflows/witnesses.yml
index c90be8cbd0f..581e11882ef 100644
--- a/.github/workflows/witnesses.yml
+++ b/.github/workflows/witnesses.yml
@@ -412,6 +412,34 @@ jobs:
           ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
           "$ROOT/target/release/gunbc" run --source-root "$ROOT/dag" --source-root "$ROOT/src/v2" --entry dag/gunbc/instruments/generated_artifact_gate.dag --function main
         if: "!cancelled() && steps.build_witness_fold.outcome == 'success'"
+      - name: "Stage0 mirrors match what this seed emits, both generations (merge_group only): required CI build lane"
+        id: stage0_regen
+        run: |+
+          GUNBC_FLOOR_LOG='gunbc-floor-cmd.log'
+          'set' '+e'
+          'set' '-o' 'pipefail'
+          ('sh' '-e' '-c' 'ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+          cd "$ROOT"
+          '\''target/release/claim_executor'\'' '\''--required-ci'\'' '\''--source-root'\'' '\''dag'\'' '\''--source-root'\'' '\''src/v2'\'' '\''--required-lane'\'' '\''build'\''
+          ') 2>&1 | 'tee' "$GUNBC_FLOOR_LOG"
+          GUNBC_FLOOR_EXIT="$?"
+          GUNBC_FLOOR_RECEIPT='gunbc-floor-outcome.txt'
+          GUNBC_FLOOR_CLASS='structural'
+          GUNBC_FLOOR_SIGNATURE=''
+          if '[' "$GUNBC_FLOOR_EXIT" '-eq' '126' ']'; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='CommandInvokedCannotExecute'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' "$GUNBC_FLOOR_EXIT" '-eq' '127' ']'; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='CommandNotFound'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' "$GUNBC_FLOOR_EXIT" '-eq' '0' ']'; then GUNBC_FLOOR_CLASS='none'; GUNBC_FLOOR_SIGNATURE=''; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' '-f' "$GUNBC_FLOOR_LOG" ']' && 'grep' '-q' 'MemoryStallRefusedPageThrash' "$GUNBC_FLOOR_LOG"; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='MemoryStallRefusedPageThrash'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' '-f' "$GUNBC_FLOOR_LOG" ']' && 'grep' '-q' 'The runner has received a shutdown signal' "$GUNBC_FLOOR_LOG"; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='RunnerLost'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' '-f' "$GUNBC_FLOOR_LOG" ']' && 'grep' '-q' 'sccache: error: failed to execute compile' "$GUNBC_FLOOR_LOG"; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='SccacheFailedToExecuteCompile'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' '-f' "$GUNBC_FLOOR_LOG" ']' && 'grep' '-q' '(exit status: 254)' "$GUNBC_FLOOR_LOG"; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='SccacheRustcWrapperExit254'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' '-f' "$GUNBC_FLOOR_LOG" ']' && 'grep' '-q' 'sccache: encountered fatal error' "$GUNBC_FLOOR_LOG"; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='SccacheFatalError'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' '-f' "$GUNBC_FLOOR_LOG" ']' && 'grep' '-q' 'failed to spawn' "$GUNBC_FLOOR_LOG"; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='ProcessSpawnFailure'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' '-f' "$GUNBC_FLOOR_LOG" ']' && 'grep' '-q' 'Resource temporarily unavailable' "$GUNBC_FLOOR_LOG"; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='ResourceTemporarilyUnavailable'; fi
+          if (! '[' '-f' "$GUNBC_FLOOR_RECEIPT" ']') || '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' || ('[' "$GUNBC_FLOOR_CLASS" '=' 'infra' ']' && (! ('[' '-f' "$GUNBC_FLOOR_RECEIPT" ']' && 'grep' '-q' 'class=structural' "$GUNBC_FLOOR_RECEIPT"))) || ('[' "$GUNBC_FLOOR_CLASS" '=' 'none' ']' && (! ('[' '-f' "$GUNBC_FLOOR_RECEIPT" ']' && 'grep' '-q' 'class=structural' "$GUNBC_FLOOR_RECEIPT")) && (! ('[' '-f' "$GUNBC_FLOOR_RECEIPT" ']' && 'grep' '-q' 'class=infra' "$GUNBC_FLOOR_RECEIPT"))); then 'printf' 'class=%s\nsignature=%s\nexit=%s\n' "$GUNBC_FLOOR_CLASS" "$GUNBC_FLOOR_SIGNATURE" "$GUNBC_FLOOR_EXIT" > "$GUNBC_FLOOR_RECEIPT"; if '[' "$GUNBC_FLOOR_CLASS" '=' 'infra' ']'; then 'echo' '::error title=environment::floor_class='"$GUNBC_FLOOR_CLASS"' signature='"$GUNBC_FLOOR_SIGNATURE"' exit='"$GUNBC_FLOOR_EXIT"'; this is not a verdict about the diff. Attempt receipt: '"$GUNBC_FLOOR_RECEIPT"; fi; if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']'; then 'echo' '::error title=subject::floor_class='"$GUNBC_FLOOR_CLASS"' exit='"$GUNBC_FLOOR_EXIT"'; read the step log for the subject defect'; fi; fi
+          'exit' "$GUNBC_FLOOR_EXIT"
+
+        if: "!cancelled() && github.event_name == 'merge_group' && steps.build_witness_fold.outcome == 'success'"
       - name: Declare which ledger rows this repair covers
         id: repair_declaration
         run: |-
diff --git a/DESIGN.md b/DESIGN.md
index 5bd1d0faae4..e96ca32829a 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -262,4 +262,4 @@ One row per class, each carrying its recognition rule and its receipts, as a fil
 - **`gunbc test <label>` is the dedicated CLI for invoking a v2 measurement, and a new one is a row rather than a flag** (operator ruling, 2026-09-16). The seam is `gunbc.target_binding` `TargetProducer` bound to a `gunbc.instrument_targets` label, and the host note says the extension shape outright: *adding one is a row in `instrument_registry` and an arm here; it is not a new route*. What that buys is not tidiness: the label carries its own refusal vocabulary, so an unknown or pattern label REFUSES with exit 2 rather than reporting a pass, and the three terminations stay distinct — 0 held, 1 an observation that did not hold, 2 no observation — which is the conflation §5 forbids, closed by construction for every instrument at once. The subject is the instrument's own fact and never a CLI option, so an invocation cannot quietly measure a different corpus while reporting the same target's standing. **What this rules out is the alternative that keeps suggesting itself:** a flag on `claim_executor`, whose ~20 flags are hand-parsed in a 2783-line `main` over 44,451 lines of `cli_run.rs` with NO `.dag` authority at all — v2 work that lands there is unmodeled by construction, and `--self-host` was withdrawn in the same change that added `//gunbc/instruments:self-host` rather than left standing beside it, because two routes to one fact is the §3 fork. `gunbc`'s own surface is modeled (`gunbc.cli_dispatch_surface` → `gunbc_cli_dispatch_generated.rs`); `claim_executor`'s is not, and the gap is the point.
 - **Two CLIs, and which one a session wants is decided by which compiler is running.** `gunbc` is the SEED's CLI — `std.compiler_entry` `RetainedHostCliKernel`, a clap surface dispatching into hand-authored host Rust (`v1_compiler.cli_run`) — so its verbs are unreachable from a self-emitted binary BY CONSTRUCTION, not by omission: an emitted crate does not contain that module. The v2-exclusive door is `v2.cli.compile_cli`, `.dag` in `src/v2/cli/`, declaring the fourth driver `std.compiler_entry` `NativeCliDriver`. It parses argv, decides the verb, decides every refusal, decides what to emit and decides the process exit (`std.process` `ProcessExit`); its rendered main performs only the four operations no `.dag` fold can — read argv, walk and read the source roots the PLAN named, write stdout, set the status — and hands each back as a VALUE. **That boundary is measured, not chosen for taste:** a resource method on an ordinary `fn` is a located compiler refusal (`Filesystem.Read` off a plain function refuses with *receiver type 'Primitive(Filesystem)' establishes no method surface*), because a resource METHOD is admitted only where the function declares that resource through its `uses` clause — an effect requirement, never a function kind: `workflow` was never a semantic kind, only the emitter predicate `v1.compiler.emit_rust` `is_workflow_item`, and gunbc#11528 DELETED it. What keeps the source-root walk in the rendered main is therefore not that boundary but TWO EMISSION GAPS: the free primitive `filesystem_read` PANICS on a missing file instead of returning the typed outcome §5 requires of a door whose job is to refuse precisely, and the emitted surface carries no directory listing, which a walk needs before it can be a fold at all. An emitted binary DOES read files — `filesystem_read` is typed by `v1.compiler.infer_method` `builtin_function_registry`, bridged by `extdeps.languages.rust.emit` `rt_function_registry` and realized by `v1.compiler.runtime_rust` `rt_filesystem` as `std::fs::read_to_string`. Both gaps close in EMISSION and neither closes by growing the interpreter, so neither makes this boundary permanent. The shim shape is deliberately the capability `gunbc.source_root_eval_driver_seed_growth` names as the trigger retiring ITS row — *the rendered main becomes one call into that fold* — so the new door adds no seed debt. **Why a second entry module rather than a mode on the first:** one emitted crate has one entry point and the emitter admits exactly one `compiler_pipeline_entry` declaration per closure (`compiler_pipeline_entry_is_ambiguous` refuses two by name), and the CLI's closure reaches no part of `v2.compiler.compile`, so exactly-one holds by construction rather than by a flag choosing between them. The two generations are two instrument rows: `gunbc test //gunbc/instruments:self-host` is the seed emitting and building `v2.compiler.compile`, and `gunbc test //gunbc/instruments:v2-native-cli` is the seed emitting and building the CLI closure — two labels because they are two compilations, so a regression in either is reported under a name that says which. Neither is the second generation; that is the BUILT CLI emitting a closure, and it needs this door to exist first.
 - explicit actuator (CI / tooling): `gunbc run --source-root dag --source-root src/v2 --entry dag/gunbc/repo/repo_local_git_config.dag --function converge`
-- **CI** is one emission, `gunbc.witness_floor_workflow` → `.github/workflows/witnesses.yml`, invoking our own binary once per LANE: `claim_executor --required-ci --source-root dag --source-root src/v2 --required-lane build` and the same with `--required-lane witnesses`, in two parallel jobs, plus an aggregating job that carries the required context and reads BOTH lane results — that last is what makes a lane block rather than merely be waited on, so read `gunbc.witness_floor_workflow` `required_lanes_roster` for the current membership rather than this sentence. **The job roster is closed to growth: adding a job needs operator sign-off, because a job is a standing claim on a paid runner on every pull request and on every queued landing** — the 2026-09-04 ruling cut three of seven on that basis (`rust-unit-tests`, `fabric-evidence`, `emit-copy-qualification-battery`), and the reasoning an author owes before proposing a lane is stated at `witness_floor_lane_jobs`. The push-on-main trigger was CUT on 2026-09-15 under the same reasoning applied to an event rather than a job: with the merge queue enabled, the required run on the queue's composed revision proves the sha that lands, so the push run re-ran a proof that already existed — one required run per landing, not two. Which phases a lane owns is decided in the binary, never in the YAML — the partition is an exhaustive match, so a phase belonging to no job fails to compile. **Read the roster from the run's own announcement, not from here:** every required run prints one `phase <name>` line per phase it owns and one `ROUTED to lane <other>` line per phase it does not. Several capabilities that used to gate are currently declared rung drops — see §4b.
+- **CI** is one emission, `gunbc.witness_floor_workflow` → `.github/workflows/witnesses.yml`, invoking our own binary once per LANE: `claim_executor --required-ci --source-root dag --source-root src/v2 --required-lane witnesses` in the `floor` job on every pull request and merge_group, and the same with `--required-lane build` (the stage0 mirrors: generated-artifact and regen-fixed-point) as a later step of that job on merge_group ONLY (operator decision 2026-09-23, `gunbc.compiler_gate_workflow` `compiler_gate_stage0_regen_step`), plus an aggregating job that carries the required context and reads every lane result — that last is what makes a lane block rather than merely be waited on, so read the emitting authority for the current membership rather than this sentence. **The job roster is closed to growth: adding a job needs operator sign-off, because a job is a standing claim on a paid runner on every pull request and on every queued landing** — the 2026-09-04 ruling cut three of seven on that basis (`rust-unit-tests`, `fabric-evidence`, `emit-copy-qualification-battery`), and the reasoning an author owes before proposing a lane is stated at `witness_floor_lane_jobs`. The push-on-main trigger was CUT on 2026-09-15 under the same reasoning applied to an event rather than a job: with the merge queue enabled, the required run on the queue's composed revision proves the sha that lands, so the push run re-ran a proof that already existed — one required run per landing, not two. Which phases a lane owns is decided in the binary, never in the YAML — the partition is an exhaustive match, so a phase belonging to no job fails to compile. **Read the roster from the run's own announcement, not from here:** every required run prints one `phase <name>` line per phase it owns and one `ROUTED to lane <other>` line per phase it does not. Several capabilities that used to gate are currently declared rung drops — see §4b.
diff --git a/dag/gunbc/design_document.dag b/dag/gunbc/design_document.dag
index 254911f5cb4..26f9d542cb5 100644
--- a/dag/gunbc/design_document.dag
+++ b/dag/gunbc/design_document.dag
@@ -278,7 +278,7 @@ fn building_checks_blocks() -> List<MarkdownBlock> {
       li(text: "**`gunbc test <label>` is the dedicated CLI for invoking a v2 measurement, and a new one is a row rather than a flag** (operator ruling, 2026-09-16). The seam is `gunbc.target_binding` `TargetProducer` bound to a `gunbc.instrument_targets` label, and the host note says the extension shape outright: *adding one is a row in `instrument_registry` and an arm here; it is not a new route*. What that buys is not tidiness: the label carries its own refusal vocabulary, so an unknown or pattern label REFUSES with exit 2 rather than reporting a pass, and the three terminations stay distinct — 0 held, 1 an observation that did not hold, 2 no observation — which is the conflation §5 forbids, closed by construction for every instrument at once. The subject is the instrument's own fact and never a CLI option, so an invocation cannot quietly measure a different corpus while reporting the same target's standing. **What this rules out is the alternative that keeps suggesting itself:** a flag on `claim_executor`, whose ~20 flags are hand-parsed in a 2783-line `main` over 44,451 lines of `cli_run.rs` with NO `.dag` authority at all — v2 work that lands there is unmodeled by construction, and `--self-host` was withdrawn in the same change that added `//gunbc/instruments:self-host` rather than left standing beside it, because two routes to one fact is the §3 fork. `gunbc`'s own surface is modeled (`gunbc.cli_dispatch_surface` → `gunbc_cli_dispatch_generated.rs`); `claim_executor`'s is not, and the gap is the point."),
       li(text: "**Two CLIs, and which one a session wants is decided by which compiler is running.** `gunbc` is the SEED's CLI — `std.compiler_entry` `RetainedHostCliKernel`, a clap surface dispatching into hand-authored host Rust (`v1_compiler.cli_run`) — so its verbs are unreachable from a self-emitted binary BY CONSTRUCTION, not by omission: an emitted crate does not contain that module. The v2-exclusive door is `v2.cli.compile_cli`, `.dag` in `src/v2/cli/`, declaring the fourth driver `std.compiler_entry` `NativeCliDriver`. It parses argv, decides the verb, decides every refusal, decides what to emit and decides the process exit (`std.process` `ProcessExit`); its rendered main performs only the four operations no `.dag` fold can — read argv, walk and read the source roots the PLAN named, write stdout, set the status — and hands each back as a VALUE. **That boundary is measured, not chosen for taste:** a resource method on an ordinary `fn` is a located compiler refusal (`Filesystem.Read` off a plain function refuses with *receiver type 'Primitive(Filesystem)' establishes no method surface*), because a resource METHOD is admitted only where the function declares that resource through its `uses` clause — an effect requirement, never a function kind: `workflow` was never a semantic kind, only the emitter predicate `v1.compiler.emit_rust` `is_workflow_item`, and gunbc#11528 DELETED it. What keeps the source-root walk in the rendered main is therefore not that boundary but TWO EMISSION GAPS: the free primitive `filesystem_read` PANICS on a missing file instead of returning the typed outcome §5 requires of a door whose job is to refuse precisely, and the emitted surface carries no directory listing, which a walk needs before it can be a fold at all. An emitted binary DOES read files — `filesystem_read` is typed by `v1.compiler.infer_method` `builtin_function_registry`, bridged by `extdeps.languages.rust.emit` `rt_function_registry` and realized by `v1.compiler.runtime_rust` `rt_filesystem` as `std::fs::read_to_string`. Both gaps close in EMISSION and neither closes by growing the interpreter, so neither makes this boundary permanent. The shim shape is deliberately the capability `gunbc.source_root_eval_driver_seed_growth` names as the trigger retiring ITS row — *the rendered main becomes one call into that fold* — so the new door adds no seed debt. **Why a second entry module rather than a mode on the first:** one emitted crate has one entry point and the emitter admits exactly one `compiler_pipeline_entry` declaration per closure (`compiler_pipeline_entry_is_ambiguous` refuses two by name), and the CLI's closure reaches no part of `v2.compiler.compile`, so exactly-one holds by construction rather than by a flag choosing between them. The two generations are two instrument rows: `gunbc test //gunbc/instruments:self-host` is the seed emitting and building `v2.compiler.compile`, and `gunbc test //gunbc/instruments:v2-native-cli` is the seed emitting and building the CLI closure — two labels because they are two compilations, so a regression in either is reported under a name that says which. Neither is the second generation; that is the BUILT CLI emitting a closure, and it needs this door to exist first."),
       li(text: "explicit actuator (CI / tooling): `gunbc run --source-root dag --source-root src/v2 --entry dag/gunbc/repo/repo_local_git_config.dag --function converge`"),
-      li(text: "**CI** is one emission, `gunbc.witness_floor_workflow` → `.github/workflows/witnesses.yml`, invoking our own binary once per LANE: `claim_executor --required-ci --source-root dag --source-root src/v2 --required-lane build` and the same with `--required-lane witnesses`, in two parallel jobs, plus an aggregating job that carries the required context and reads BOTH lane results — that last is what makes a lane block rather than merely be waited on, so read `gunbc.witness_floor_workflow` `required_lanes_roster` for the current membership rather than this sentence. **The job roster is closed to growth: adding a job needs operator sign-off, because a job is a standing claim on a paid runner on every pull request and on every queued landing** — the 2026-09-04 ruling cut three of seven on that basis (`rust-unit-tests`, `fabric-evidence`, `emit-copy-qualification-battery`), and the reasoning an author owes before proposing a lane is stated at `witness_floor_lane_jobs`. The push-on-main trigger was CUT on 2026-09-15 under the same reasoning applied to an event rather than a job: with the merge queue enabled, the required run on the queue's composed revision proves the sha that lands, so the push run re-ran a proof that already existed — one required run per landing, not two. Which phases a lane owns is decided in the binary, never in the YAML — the partition is an exhaustive match, so a phase belonging to no job fails to compile. **Read the roster from the run's own announcement, not from here:** every required run prints one `phase <name>` line per phase it owns and one `ROUTED to lane <other>` line per phase it does not. Several capabilities that used to gate are currently declared rung drops — see §4b."),
+      li(text: "**CI** is one emission, `gunbc.witness_floor_workflow` → `.github/workflows/witnesses.yml`, invoking our own binary once per LANE: `claim_executor --required-ci --source-root dag --source-root src/v2 --required-lane witnesses` in the `floor` job on every pull request and merge_group, and the same with `--required-lane build` (the stage0 mirrors: generated-artifact and regen-fixed-point) as a later step of that job on merge_group ONLY (operator decision 2026-09-23, `gunbc.compiler_gate_workflow` `compiler_gate_stage0_regen_step`), plus an aggregating job that carries the required context and reads every lane result — that last is what makes a lane block rather than merely be waited on, so read the emitting authority for the current membership rather than this sentence. **The job roster is closed to growth: adding a job needs operator sign-off, because a job is a standing claim on a paid runner on every pull request and on every queued landing** — the 2026-09-04 ruling cut three of seven on that basis (`rust-unit-tests`, `fabric-evidence`, `emit-copy-qualification-battery`), and the reasoning an author owes before proposing a lane is stated at `witness_floor_lane_jobs`. The push-on-main trigger was CUT on 2026-09-15 under the same reasoning applied to an event rather than a job: with the merge queue enabled, the required run on the queue's composed revision proves the sha that lands, so the push run re-ran a proof that already existed — one required run per landing, not two. Which phases a lane owns is decided in the binary, never in the YAML — the partition is an exhaustive match, so a phase belonging to no job fails to compile. **Read the roster from the run's own announcement, not from here:** every required run prints one `phase <name>` line per phase it owns and one `ROUTED to lane <other>` line per phase it does not. Several capabilities that used to gate are currently declared rung drops — see §4b."),
     ]),
   ]
 }
diff --git a/dag/gunbc/witness/compiler_gate_workflow.dag b/dag/gunbc/witness/compiler_gate_workflow.dag
index dab06992a80..7cc86198531 100644
--- a/dag/gunbc/witness/compiler_gate_workflow.dag
+++ b/dag/gunbc/witness/compiler_gate_workflow.dag
@@ -35,7 +35,8 @@ import extdeps.github.actions {
   Workflow, Job, Step, UsesStep, RunStep,
   WorkflowPermissions, PermRead,
   RunnerSpec, HostedRunner, Ubuntu2404Arm,
-  github_event_name_pull_request
+  github_event_name_pull_request,
+  github_event_name_merge_group
 }
 import gunbc.action_use_admission {
   checkout_action, upload_artifact_action,
@@ -60,6 +61,7 @@ import gunbc.witness_floor_workflow {
   witness_floor_build_step,
   witness_floor_required_bins,
   witness_floor_run_script,
+  build_lane_run_script,
   witness_floor_precondition,
   witness_toolchain_homes_isolated_guard_step,
   witness_step_status_guard,
@@ -411,6 +413,66 @@ fn compiler_gate_drift_step() -> Step {
   }
 }
 
+// THE STAGE0 MIRRORS ARE CHECKED ON THE QUEUE'S COMPOSED REVISION, AND ONLY THERE, BOTH
+// GENERATIONS DEEP. Operator decision msg_6e36a6a2 (2026-09-23), which supersedes msg_4a9045fc's
+// generation-1-only ruling and msg_f1ade7cf-77e4-4896-a8b3-476747692c37's ~20 min pricing.
+// The drift step above reads gunbc.generated_artifact alone; the ~158 compile_stage0 mirrors are
+// adjudicated by claim_executor's build lane -- the GeneratedArtifact phase (first generation) and
+// the RegenFixedPoint phase (second generation against the first's receipt) -- and no job had run
+// that lane since #11742, so std_measure.rs drifted onto main under a green required run
+// (gunbc#12067) and more mirrors had drifted by the time this step first executed.
+//
+// THE LANE'S OWN COMMAND, so which phases run is still decided by the binary's exhaustive
+// partition (gunbc.witness_floor_workflow build_lane_run_script over gunbc.fabric_witness_run
+// build_lane_run_command), never by this YAML. Measured on the fleet (run 35890770775, after
+// #12100 removed the field-name re-export leak that had inflated generation 1 to 30 min): the
+// whole lane, both generations, took 22.5 min, and the floor job ~58 min against
+// compiler_gate_floor_timeout_minutes.
+//
+// A STEP ON THIS JOB, NOT A NEW JOB. The floor lane already checks out and builds claim_executor
+// from this tree; a separate job would pay that prelude again on every queued landing.
+//
+// A SEPARATE PROCESS AFTER THE FLOOR EXITS, which is the measured constraint rather than a
+// preference: the floor process peaks at its slot's memory.high (run 35716368507) and the stage0
+// pass near 12.9 GiB, so the two fit sequentially and never additively.
+//
+// MERGE_GROUP ONLY BECAUSE A PULL REQUEST DOES NOT LAND. The queue's run judges the sha that
+// becomes main; the price is that an author learns of drift at queue time. `!cancelled()` rather
+// than the default success(): a floor red must not disarm this check (see witness_floor_workflow's
+// measured correction).
+//
+// gunbc.rung_drop.floor_cut_regen_second_generation_agreement IS NOT RETIRED BY THIS STEP. Its
+// trigger is second-generation refusal for EVERY phase that regenerates a committed population,
+// shown by a red on a generation-unstable fixture under this execution model. RegenFixedPoint
+// compares a second generation for the stage0 mirror population only (it reads
+// target/stage0-regen-receipt.json); the registry-rostered projections have no second
+// generation, and no unstable fixture has been run.
+data compiler_gate_stage0_regen_step_name: String = "Stage0 mirrors match what this seed emits, both generations (merge_group only): required CI build lane"
+
+fn compiler_gate_stage0_regen_condition() -> String {
+  concat(
+    witness_step_status_guard(),
+    concat(
+      concat("github.event_name == '", concat(github_event_name_merge_group, "' && ")),
+      "steps.build_witness_fold.outcome == 'success'"
+    )
+  )
+}
+
+fn compiler_gate_stage0_regen_step() -> Step {
+  RunStep {
+    name: Present { value: compiler_gate_stage0_regen_step_name },
+    id: Present { value: "stage0_regen" },
+    run: concat(wrap_command_with_floor_attempt_receipt(command: build_lane_run_script()), "\n"),
+    shell: none,
+    env: none,
+    working_directory: none,
+    if_condition: Present { value: compiler_gate_stage0_regen_condition() },
+    continue_on_error: none,
+    timeout_minutes: none
+  }
+}
+
 fn compiler_gate_repair_condition() -> String {
   concat(
     concat("failure() && steps.", concat(compiler_gate_drift_step_id, ".outcome == 'failure'")),
@@ -557,6 +619,11 @@ fn compiler_gate_floor_bound_steps() -> List<CompilerGateBoundStep> {
       role: capability_neutral,
       step_name: "Registry-rostered generated artifacts (gunbc.generated_artifact) match their authorities; the stage0 mirrors are NOT checked here",
     },
+    CompilerGateBoundStep {
+      step: compiler_gate_stage0_regen_step(),
+      role: consumes_only(capabilities: [RustfmtCapability]),
+      step_name: compiler_gate_stage0_regen_step_name,
+    },
     CompilerGateBoundStep {
       step: compiler_gate_repair_declaration_step(),
       role: capability_neutral,
@@ -607,6 +674,7 @@ fn compiler_gate_floor_capability_closure_holds() -> Bool {
 
 fn compiler_gate_floor_scripts_are_renderable() -> Bool {
   wrap_command_is_renderable(command: witness_floor_run_script())
+    && wrap_command_is_renderable(command: build_lane_run_script())
     && wrap_command_is_renderable(command: repo_self_build_command(bins: witness_floor_required_bins))
     && required_ci_measurement_scripts_are_renderable()
 }
diff --git a/dag/gunbc/witness/witness_floor_workflow.dag b/dag/gunbc/witness/witness_floor_workflow.dag
index bc877852c9c..c485847445d 100644
--- a/dag/gunbc/witness/witness_floor_workflow.dag
+++ b/dag/gunbc/witness/witness_floor_workflow.dag
@@ -2585,6 +2585,15 @@ fn witness_floor_triggers() -> List<WorkflowTrigger> {
 // same tree. `rust_clippy_all_targets_step` is the worked example: it kept its step id, its
 // verdict and its coverage, and stopped costing a job, by moving onto `required-witnesses-build`.
 //
+// THE SECOND WORKED EXAMPLE, AND ITS SIGN-OFF (operator decision msg_6e36a6a2, 2026-09-23, which
+// supersedes msg_4a9045fc and the ~20 min pricing of msg_f1ade7cf-77e4-4896-a8b3-476747692c37).
+// This file's build lane -- the stage0 mirrors' generated-artifact and regen-fixed-point phases,
+// which no job had run since #11742 -- returns as ONE merge_group-only STEP on the emitted floor
+// job (gunbc.compiler_gate_workflow compiler_gate_stage0_regen_step), not as a job: that job
+// already checks out and builds claim_executor, and the lane measured 22.5 min on the fleet (run
+// 35890770775), fitting after the floor process exits. The sign-off covers exactly that step on
+// that event; it admits no per-PR run and no new job.
+//
 // THIS COMMENT IS RATIONALE, NOT A GATE. No `Accepted` program reads it, so it stops nobody --
 // it records WHY the roster is small so the next author meets the reasoning rather than
 // rediscovering the outage. The construction that would make an over-budget roster unwritable is
diff --git a/dag/test/claim/compiler_gate_workflow_witness_test.dag b/dag/test/claim/compiler_gate_workflow_witness_test.dag
index 8c0f6c5ec69..8c52c0891ca 100644
--- a/dag/test/claim/compiler_gate_workflow_witness_test.dag
+++ b/dag/test/claim/compiler_gate_workflow_witness_test.dag
@@ -68,3 +68,56 @@ test fn w_RED_the_gate_floor_job_adjudicates_the_receipt_it_produces() -> Bool {
   let p = floor_step_positions(job: compiler_gate_floor_job())
   p.producer >= 0 && p.adjudicator >= 0 && p.producer < p.adjudicator
 }
+
+// ── THE STAGE0 MIRRORS ARE ADJUDICATED ON THE MERGE QUEUE, AND ONLY THERE ──────────────────────
+//
+// operator decision msg_6e36a6a2 (2026-09-23, superseding msg_4a9045fc and msg_f1ade7cf): the build
+// lane over the compile_stage0 mirrors, both generations, runs as a step of the floor job on merge_group and on no other
+// event. This claim reads the emitted job: some step runs `--required-lane` with no measurement receipt (the build lane's command; the witnesses lane is the one carrying a receipt),
+// its condition names the merge_group event, its condition carries a status function so a floor
+// red cannot disarm it, and it comes AFTER the floor's measurement producer (a separate process
+// after the floor exits, the measured memory constraint). Deleting the step, dropping its event
+// gate (a per-PR run the ruling declined), or binding it ahead of the floor reds this. Whether the
+// lane's own refusal discriminates is not this claim's subject: that is the binary's, and the
+// planted-drift control on the PR that added the step is its execution receipt.
+type Stage0RegenPositions {
+  next: Int
+  producer: Int
+  stage0: Int
+  gated: Bool
+}
+
+fn step_if_text(step: Step) -> String {
+  match step {
+    RunStep { name: _, id: _, run: _, shell: _, env: _, working_directory: _, if_condition: c, continue_on_error: _, timeout_minutes: _ } => match c {
+      Present { value: v } => v
+      Absent => ""
+    }
+    UsesStep { name: _, id: _, uses: _, with: _, env: _, if_condition: _, continue_on_error: _, timeout_minutes: _ } => ""
+  }
+}
+
+test fn w_RED_the_stage0_mirrors_are_adjudicated_on_merge_group_only_after_the_floor() -> Bool {
+  let p = fold_list(
+    xs: compiler_gate_floor_job().steps,
+    empty: Stage0RegenPositions { next: 0, producer: -1, stage0: -1, gated: false },
+    cons: fn(acc, step) {
+      let run = step_run_text(step: step)
+      let cond = step_if_text(step: step)
+      let is_producer = !string_contains(s: run, pattern: "--adjudicate-measurement-receipt")
+        && string_contains(s: run, pattern: "--measurement-receipt")
+      let is_stage0 = string_contains(s: run, pattern: "--required-lane")
+        && !string_contains(s: run, pattern: "--measurement-receipt")
+      Stage0RegenPositions {
+        next: acc.next + 1,
+        producer: if is_producer && acc.producer < 0 { acc.next } else { acc.producer },
+        stage0: if is_stage0 && acc.stage0 < 0 { acc.next } else { acc.stage0 },
+        gated: if is_stage0 && acc.stage0 < 0 {
+          string_contains(s: cond, pattern: "github.event_name == 'merge_group'")
+            && string_contains(s: cond, pattern: "!cancelled()")
+        } else { acc.gated },
+      }
+    }
+  )
+  p.producer >= 0 && p.stage0 > p.producer && p.gated
+}
diff --git a/src/v1/stage0/src/v1_compiler_emit.rs b/src/v1/stage0/src/v1_compiler_emit.rs
index 808ef1780f1..f7c784b84bf 100644
--- a/src/v1/stage0/src/v1_compiler_emit.rs
+++ b/src/v1/stage0/src/v1_compiler_emit.rs
@@ -66,7 +66,6 @@ pub use crate::v1_compiler_infer_env::UnitVariantContribution;
 pub use crate::v1_compiler_infer_env::{authored_name, empty_symbol_index, lookup_type_for};
 pub use crate::v1_compiler_infer_env::{GlobalBareLookupState, TypeBinding, TypeEnv};
 pub use crate::v1_compiler_infer_items::item_is_effectful_callee;
-pub use crate::v1_compiler_infer_items::item_resource_names;
 pub use crate::v1_compiler_infer_items::{ItemInfo, ResolvedGraph, TypedModule};
 pub use crate::v1_compiler_infer_lookup::lookup_func_sig;
 pub use crate::v1_compiler_infer_service::{