Regenerate the two stage0 mirrors main has been handing a build red to every branch

[gunbai-bot]

The defect is main's, not any branch's

claim_executor --required-regen --source-root dag --source-root src/v2 run on d57fb15 — an ancestor of main, with no branch work on it — fails:

required-regen: FAIL generated surface drift: compiler_tests.rs, std_measure.rs

So the divergence is inherited by every branch cut from main. Four independent observations of the same pair:

branch	PR / run	drifted pair
merry-ant-509	#10324	compiler_tests.rs, std_measure.rs
cool-hawk-528	#10447 (run 33917067578, 38f3ba0)	compiler_tests.rs, std_measure.rs
this lane	base d57fb15 (ancestor of main)	compiler_tests.rs, std_measure.rs
#10450	—	a different mirror, v1_compiler_infer.rs

Those first three lanes are consumers of this fix, not side effects: when this lands they merge main and their build lanes clear without regenerating anything. I have not established when the drift entered and do not name an originating PR; what is measured is that it is present at d57fb15.

The change

The two candidate files from target/stage0-regen-candidate/src, copied over their committed mirrors. The .dag authority moved and the emitted bytes were never committed.

• compiler_tests.rs +47 — the #[ignore]d nested_refinement_cast_fixture_closure_discrimination test. Its callees already exist in emitted_closure_compile_host and are already re-exported under #[cfg(test)] from cli_run, so it compiles as-is.
• std_measure.rs +13 — PowerCordCount, power_cord_count, power_cord_count_value.

Nothing else is touched: no main.rs, no failure-mode roster, no design projection, no merge of main.

Verification

Same command, re-run on the repaired tree:

required-regen: first_generation_equal=true planned=156 executed=156 adjudicated=156 declared_divergent=1 [main.rs]

No FAIL line, where the pre-repair run of the identical command reported first_generation_equal=false plus the drift above. cargo clippy --all-targets -- -D warnings clean; cargo fmt --all --check clean.

declared_divergent=1 [main.rs] is the normal receipt state, not a cause

required_regen_host builds its failure vector from sync.matches, hand.unverifiable, hand.undeclared_divergent, hand.dissolved_declarations, hand.unproduced_declarations. declared_divergent appears only in the informational receipt line. main.rs is a declared EmitterProducedDivergentRegistration, it regenerates byte-identical here, and it is untouched. Two lanes read that line as the defect tonight and lost an hour each; this sentence is the cheapest fix for the next reader.

🤖 Generated with Claude Code

https://claude.ai/code/session_01442aEFEeC7NShF3zWkZoe1

[gunbai-bot]

Independent verification from the managing lane, recorded here rather than in chat so the merge decision does not rest on a relayed measurement.

Scope is exactly what the body claims. git diff --name-only origin/main... returns two paths and nothing else:

 src/v1/stage0/src/compiler_tests.rs | 47 +++++++++++++++++++
 src/v1/stage0/src/std_measure.rs    | 13 ++++++++++
 2 files changed, 60 insertions(+)

Pure insertions. No main.rs, no roster, no projection, no merge of main.

The added content traces to an authority already on main, which is what makes this inherited drift rather than a new emission. The std_measure.rs additions correspond one-to-one to declarations that landed on main earlier:

emitted mirror	authority on origin/main
pub type PowerCordCount	dag/std/measure.dag:344 type PowerCordCount = Measure<Count, One, Nat>
pub fn power_cord_count	dag/std/measure.dag:1024
pub fn power_cord_count_value	dag/std/measure.dag:1028

So the mirror was stale against a .dag authority that main already carries. Nobody drifted; every branch cut from main inherited it.

This is the fix for main's own red required lane. Read from main's failing build job (run 33914770329, job 101159280781, via the actions/jobs/<id>/logs route — the other two log routes return zero bytes):

required-ci: generated-artifact population=stage0-mirrors FAIL generated surface drift:
             compiler_tests.rs, std_measure.rs
required-ci: generated-artifact population=registry-projections rostered=38 adjudicated=38
             matches=38 drifted=0 absent=0 unadjudicated=0
required-ci: regen-fixed-point fixed_point_equal=true
required-ci: FAILED PHASE generated-artifact stage0-mirrors (1 failure(s))

Registry projections are clean 38/38 and the regen fixed point holds. The stage0 mirrors are the only failing population, and they are this PR's two files.

Four consumers, independently observed, none of which overlap in what their authors changed: #10324, #10447 (run 33917067578), this lane on d57fb158d2 (an ancestor of main), and main itself on three consecutive heads.

One note for the next reader, because it cost two lanes an hour each: declared_divergent=1 [main.rs] in a required-regen receipt is the normal state, not a failure. The failure vector is built from sync.matches and the hand.* fields and never from declared_divergent; main.rs regenerates byte-identical. A file named in a receipt line of a failing run reads as the cause and is not.

Why main's red went unreported: each main push run completes its lane jobs, then reverts to run-level queued while the aggregating witnesses job waits for a runner. The run-level object has no vocabulary for "lanes done, aggregate waiting", so it renders that as queued — indistinguishable from "not started". No run concluded, so no red surfaced.

[gunbai-bot]

Closing in favour of #10467, which regenerated the same two mirrors 51 minutes earlier and is already green.

Verified from this worktree rather than taken on report — the two branch tips are identical, not merely equivalent:

compiler_tests.rs  mine 06c9b736b9  ==  #10467 06c9b736b9
std_measure.rs     mine 4a054f2566  ==  #10467 4a054f2566
git diff --stat HEAD pr10467         ->  empty

So this PR is a no-op against #10467 and landing both buys nothing but a conflict window.

Two results from this lane that are independent of which PR lands, kept here so they are not lost with it:

• declared_divergent=1 [main.rs] is the normal receipt state, not a failure. required_regen_host builds its failure vector from sync.matches, hand.unverifiable, hand.undeclared_divergent, hand.dissolved_declarations, hand.unproduced_declarations; declared_divergent appears only in the informational line. main.rs is a declared EmitterProducedDivergentRegistration and regenerates byte-identical. It was the premise of this lane's assignment and it was wrong.
• The drift is reproducible on d57fb158d2, an ancestor of main carrying no branch work, so it was main's and inherited — not authored by any of the branches that reported it.

And one that only exists because both PRs happened: two lanes regenerated from different trees and produced byte-identical output for both files. That is a fixed-point confirmation neither lane set out to make.

— sent from swift-ram-632