Repair the derived stage0 partition: three unrostered modules and one inverted crate tier

[gunbai-bot]

cargo build --release at the workspace root — the first item under DESIGN's own Building & checks bullet — fails on main. This repairs it, verified by execution.

The class

Two module rosters stand over one file set. src/v1/stage0/src/lib.rs (the monolith, 160 pub mod) is complete; the seven partition-crate lib.rs files share those same sources through #[path] includes and carry their own rosters. Nothing decides that the two agree, so a module added to the monolith is invisible to the split crates until someone runs a build no required lane runs.

This is DESIGN's parallel-representation failure, and its decision-continuity twin one layer out: an artifact derived from a roster, whose derivation stopped running, while consumers kept trusting the artifact.

It is three modules, not one — and a tier inversion

The reported specimen was one module. That was a prefix, not a total: cargo stops at the first failing crate, so the printed count is where the compiler happened to stop. A per-crate visibility scan (own pub mod plus the transitive pub use <pkg>::* chain, against every included file's crate::X references) finds three:

crate	missing
stage0_extdeps_languages	extdeps_languages_rust_capabilities
stage0_v1_infer	v1_compiler_coercion, v1_compiler_type_head_exposure

The second half is not two more roster lines. v1_compiler_infer_emit_info imports crate::v1_compiler_artifact, owned by stage0_v1_artifact — which depended on stage0_v1_infer. v1_compiler_coercion reaches artifact too, so neither could join infer while artifact sat above it. Measured deps show the edge pointed the wrong way: v1_compiler_artifact needs only {std_types, v1_rt, v1_std_core}, and v1_compiler_languages needs no infer module at all.

So the tiers are swapped — artifact below infer — in the authority rows, the generated mirror, the manifests, the pub use chains and the workspace member order, and the four real import edges the module DAG was missing are added.

Why nothing caught it

claim_executor is a bin of the monolith, whose roster is complete, so every required phase builds a crate that compiles. The partition crates are workspace members nothing in CI builds; the Rust suite left CI 2026-07-11 and clippy 2026-07-08 by operator ruling.

What this does NOT fix

The producer exists and has no caller. v1.compiler.stage0_crates renders both the partition lib.rs (render_stage0_layered_core_lib / _foundation_lib / _emit_core_lib_outcome) and its Cargo.toml (emit_stage0_crate_manifest) from the authority rows — and stage0_crate_boundary_emit_outcome is named by nothing outside its own module, its emitted mirror, and workspace_members. --required-regen does not cover these crates. Modeled derivation, zero executed route.

So this repairs the instance and leaves the class: the same omission lands again with the next module. That is stated rather than hedged, because this class has regressed once already (#7641, same crate, three weeks ago).

Rung — unchanged, and low

• previous: mitigatable · current: mitigatable
• bounded residue: the three modules and the one tier edge repaired here. No mechanism refuses a fourth omission.
• next-rung trigger: give the producer a live entry point and a required phase that fails (not warns, not reports) on a partition crate that does not compile — landed together. A producer with no route is the defect this PR diagnoses, so producing without routing relocates it rather than closes it. Follow-up PR, agreed with the requesting lane.
• Deriving the assignment itself — a new module rostered with no human edit — is blocked on the declared stage0_module_dag_interface_grounding debt (resolve_partition_outcome answers PolicyResolverUnimplemented; the cross-unit import edges are themselves a hand roster), dissolving on v2.compiler.source_authority ModuleStorageIndex. That is the class's own trigger, not effort withheld.

Evidence

• RED — cargo build --release, remote, main efc880aef43: E0433/E0432 on extdeps_languages_rust_capabilities; the E0282 beside it is downstream of the resolution failure, not a fourth defect.
• Intermediate, discriminating — with only that first fix applied: E0433/E0432 on v1_compiler_artifact, v1_compiler_coercion, v1_compiler_type_head_exposure. Predicted by the scan before the run, then confirmed by it.
• GREEN — Finished \release` profile [optimized] target(s) in 6m 01s`, exit 0, one remote dispatch.

🤖 Generated with Claude Code

https://claude.ai/code/session_012WJNiTYqhzCcWJM6o5L5fQ

[gunbai-bot]

Status on the reds, and one of them is real. Three runs exist on e139f32; they are not the same failure and only one is mine.

Two are killed steps, not failures. Jobs 97986688558 (build) and 97989292128 (floor) both show every step success up to the lane step, and the lane step itself carries a null conclusion — no step failed, the runner died mid-step. The rollup renders that as an ordinary red. Nothing in the diff caused it and there is nothing to fix in it.

One is a genuine failure, and it is a real gap in this PR:

required-regen: elapsed_ms=576801 first_generation_equal=false planned=135 executed=135 declared_divergent=1
required-ci: regen FAIL generated surface drift: gunbc_stage0_crate_partition_generated.rs

This PR edits dag/gunbc/stage0_crate_partition_generated.dag and does not carry the regenerated emitted Rust mirror of it. So the branch introduces a disagreement between a generated authority and its own mirror. That is worse than the state it inherited: on main the two agree while both being stale, here they disagree.

How it was found, because the route matters more than the fix. Not from this red — from the follow-up work. I built the producer entry point for the partition boundary files and ran it read-only: 14 files, 9 byte-for-byte matches, 5 drifted, the 5 being exactly the files this PR hand-edits. The 9 matches are the positive control: they establish the producer is faithful, so the 5 are a finding rather than a broken renderer. Running it with --write then reverted this PR's own repair, because the binary's embedded rows come from the stale mirror.

Two independent instruments then agreed on the same file by name — that local run, and this CI lane. That agreement is the result; had they disagreed, that would have outranked both.

Fix in progress: install the regenerated mirror from a --required-regen candidate tree, here rather than in a follow-up, since a half-regenerated authority on main is worse than either coherent state.

— sent from neat-pike-374