Sizing becomes derived: unbundle NodeSizing, delete authored intricacy and volume, stub the deriver

[briansrls]

What this is

NodeSizing fused four facts under one discriminant: whether a roadmap row is a dispatchable work item at all, the repository the work happens in, the acceptance evidence a worker must return, and a hand-authored intricacy/volume guess at how big the work is. Only the last is a size, and an author's ordinal guess written before any of the work is done is an estimate wearing a fact's clothes — nothing observed it and nothing could contradict it. Consumers read it as though it were measured: the spawn request published it, the page badged it, and the forecast keyed its cycle-time calibration on it.

This unbundles the four and makes size derived.

The census, measured rather than assumed

repo and acceptance have live consumers (the spawn-request JSON, the brief's paths, classify_dispatch_destination_gate via node_dispatch_destination, and vivid-ant-470's new destination resolver). intricacy/volume had no control-flow consumer anywhere. gunbc.dispatch_selection threaded a NodeSizing through every resolve function and recorded it on the receipt, and no branch and no consumer of that receipt ever read it — its own carrier note said as much. gunbc.session_reservation_policy is not a consumer: its "sizing" is HostSessionReservationSizing per host, a different concept wearing the same word. The live authored population was 65 rows in gunbc.roadmap_authority, through active_sized/active_small/active_large, all three of which collapse into one active constructor now that size has left.

The shape

• RoadmapNode.dispatch: WorkItemDispatch = NotDispatchable | Dispatchable { repo: String, acceptance: Acceptance } — the three live facts, kept as a coproduct rather than two bare fields because "this row is not a work item" was itself the third fact, and two bare fields would have needed a repo: "" sentinel. repo stays a String slug of the same shape for gunbc.roadmap_dispatch_destination.
• gunbc.roadmap_sizing is the single authority for size. It imports nothing from the roadmap: derive_task_sizing takes a SizingSubject { subject, title, description, exit_criterion: String? }, because a task worth sizing may be a plan item in another repository that is not a RoadmapNode at all. gunbc.roadmap_model projects a node into one.
• The stub does not lie. NodeSizingDerivation = SizingDerived { … } | SizingNotDerivable { subject, detail }. The refusal is a distinct arm with a located reason; there is no default cell anywhere in the diff.

Sizing leaves admission (operator ruling, 2026-09-10)

There is no size on RoadmapNode and no sizing argument on any admission path, so sizing cannot refuse a launch by construction rather than by policy. LaunchSizeMissing / wire word size_missing becomes LaunchDispatchBindingMissing / dispatch_binding_missing: it never checked a size — it checked node_is_sized, which asked whether the row carries repo + acceptance. That gate stays, and is now honestly named: it is a destination fact, and a dispatch that cannot name its repository must not create a worktree. No row that was dispatchable before this change is refused after it.

gunbc.dispatch_selection, the consumer that legitimately wants a size, receives a two-arm SizingProfileExpectation = NoDerivedSizingExpectation | DerivedSizingExpectation { sizing } and records it on the receipt and on the refusal. Both arms resolve identically today because live selection is ProfileAutomatic, and the carrier says that outright instead of implying it.

The declared drop

gunbc.rung_drop.roadmap_sizing_authored_to_derived (rostered, projected into docs/design-rung-drops.md). Subject is gunbc.roadmap_forecast schedule_forecast — scheduling and resource expectation, not admission. Its trigger names the capability: a derivation that reads a SizingSubject and answers from it, with an executed control showing two materially different subjects receiving different cells, and the forecast calibrating from those cells end to end. It states explicitly that replacing the stub with any constant-returning function does not satisfy it.

The forecast now takes its sizings as a parameter (List<NodeSizingAssignment>) instead of reading them off the node, which keeps its positive controls authorable while the deriver is a stub — controls deleted to accommodate a change are evidence destroyed. FIVE witnesses whose subject was the authored cell population could not be kept without weakening what they assert; they are retired by name in the drop's population rather than quietly, and replaced by one control that is authorable. The five are four forecast witnesses — witness_live_graph_refuses_with_located_counted_calibration_gaps, witness_live_graph_gap_count_matches_refusal_rows, witness_live_graph_refusal_is_only_calibration, witness_live_calibration_keeps_small_sample_intervals — plus test.claim.roadmap_authority.witness_active_sizes_are_intentional_and_nonuniform, the authored-size-distribution witness retired with its subject. (This sentence previously said "three live-graph calibration witnesses", which counted only the identities carrying live_graph in their name and understated the retired population; the drop's declaration was correct throughout.)

Evidence, by execution

• witness_stub_deriver_refuses_rather_than_fabricating_a_cell → true on the real path.
• Discriminating RED, run not asserted: with derive_task_sizing temporarily returning SizingDerived { medium, medium }, witness_spawn_request_omits_size_keys_while_no_size_is_derived → false.
• What the live forecast renders on the empty list, with its provenance stated because the witness was strengthened after that result was obtained. witness_live_graph_refuses_every_node_as_unsized_while_the_deriver_is_a_stub returned true against the real authority on an EARLIER implementation of this witness — the one whose completeness check was an any over the refusal list. That is historical evidence for the implementation tested then, not an execution receipt for the complete-payload repair or its new discriminator. The current source gathers every NodeUnsized payload through reported_unsized_ids and applies count equality plus membership in both directions to that complete population, with witness_an_extra_unsized_payload_is_not_hidden_by_a_correct_one as its discriminator; whether those hold is answered by execution on the current head, reported separately, and is not claimed here. Current-source correctness and current-head execution evidence are deliberately kept apart in this bullet.
• The assignment seam: witness_a_cell_answered_for_another_subject_refuses (a cell naming another node's subject produces SizingForAnotherSubject, never a rebind), witness_a_cell_answered_for_its_own_subject_is_admitted (the positive control), and witness_two_cells_for_one_subject_refuse_rather_than_being_ordered (SizingAssignedTwice, so list order never arbitrates between conflicting cells) — all true by execution.
• Required lane build: phases_run=2 phases_failed=0 locally. Required lane witnesses: declarations clean, namespace-wave-admission clean once the relocation roster landed; the remaining local floor refusal is the local-repo wet lane failing to build Rust in this container (sccache: failed to execute compile), which reproduces on the unmodified tree.

🤖 Generated with Claude Code

https://claude.ai/code/session_01YT3CM7TgQNeyBp1REtuxWE

Merge conflict resolution (2026-09-14)

Merged current main e3f60ebbf5276bcdb5a216b37282d1e06580d963 with a merge commit; no rebase or force-push.

Admission adjudication against that exact base and the current declaring_candidates → declarer_of, binding_disposition, and disposition_auto_admitted mechanism:

• 10 sizing rows survive: automatic_codex_behavior_preservation_holds (IntricacyHigh, VolumeMedium); fixture_cell (IntricacyMedium, VolumeMedium); witness_intricacy_does_not_change_automatic_effort (IntricacyHigh, IntricacyLow); witness_dispatch_effort_ignores_intricacy (IntricacyHigh, IntricacyLow); witness_empty_calibration_cell_refuses (IntricacyHigh, VolumeSmall). Each reference is present in its enclosing declaration at base and head. Base declares these variants only in gunbc.roadmap_model; head only in gunbc.roadmap_sizing. Each consumer explicitly imports the respective authority. Distinct nonempty singleton sets mean TargetChanged, which refuses without the exact row.
• 7 node_title rows survive: belt_audit_spawn, belt_review_plan_for_head, dispatch_slot_fields, node_json_value, roadmap_dispatch_json_value, upcoming_array_json, upcoming_node_json. Each reference remains at both revisions. Base uniquely declares node_title in gunbc.roadmap_spawner; head uniquely declares it in gunbc.roadmap_status; consumers import the new authority (spawner's formerly local binding now imports status). The same singleton TargetChanged rule requires each row.
• 7 inventory-evidence rows remain dissolved: current main already deleted them and declares InventoryLotEvidence and admit_ledger_evidence in product.inventory. The old claim that inventory has no such declaration became false. This merge preserves main's deletion and corrects that leftover claim while retaining the dissolution rule: present-at-base transitions dissolve, independently of whether other rows remain. Other previously deleted cohorts are not resurrected.

Both explanatory principles remain in the source: expected candidate sets derive from declaring identities, never copied from observed output; consumption depends on the transition being present at base.

Projection resolution used the authorized union fallback, not local regeneration: the documented regen command refused because this worktree has no built interpreter. Kept current main's complete projection and appended the sizing section. Verified section identities by set difference, with no current-main section missing. Main has since expanded the provider-jurisdiction section's heading and authority; its current section supersedes the old heading rather than duplicating the same row. Both .dag authorities and roster entries remain, including main's newly conflicting long_home_enrolment_margin_observed_only entry. CI heal-generated-artifacts must regenerate/order the projection and validate the healed head.

Validation: all 17 reference sites checked against main's blobs and the merged source; global declaration census and explicit import checks establish the singleton moves. Pre-commit cargo fmt passed. The remote Cargo negative control failed as expected on the stable compiler. No claim of an executed admission verdict on this new head yet; required CI must provide it. No cost-debt entry was added for the sizing tripwire.

Held behind #11310 and #11303. Do not merge or enqueue as part of this conflict repair.

CI healing receipt: run 34813261886 successfully regenerated the projection and pushed ce634f84d5aa2667f6dd9113a127d9a8e27d5070, changing only the placement of the sizing section in docs/design-rung-drops.md (4 lines moved, content preserved). The heal job exits 1 as SupersededByHealedHead; the new head requires its own executed verdict. Run 34814897015 currently concludes action_required, awaiting human approval of the bot-pushed head.

Second integration receipt: e70807ca453899ca200b1046cd726fe49d0d1d92 merges main 92bf058e54f into healed head ce634f84d5a. The sole conflict was imports in gunbc.roadmap_dispatch_destination: retain WorkItemDispatch, Dispatchable, NotDispatchable for dispatchability and main's added imports for AttemptAdmissionSubject; those are different facts. The projection was already healed and did not conflict. Rechecked all 17 reference identities against the new main's blobs; the sole base declarers remain roadmap_model for Intricacy/Volume and roadmap_spawner for node_title, with the corresponding unique relocated declarers at head. Main still carries InventoryLotEvidence and admit_ledger_evidence in product.inventory and an empty admission table. Thus all seventeen survive and none of the seven inventory rows returns.

Executed evidence on the preceding source head 2af33d1edc6: run 34813261886 completed with required-witnesses-floor SUCCESS, lane=witnesses phases_run=3 phases_failed=0, FloorClean unexpected_failures=0, and namespace ADMITTED; each of the seventeen exact TargetChanged rows is individually ADMITTED-BY #10994. The mechanism's comparison names base e3f60ebbf527 and GitHub test-merge head dde2d4dd515c. Overall run FAILURE came from the docs ordering drift, subsequently healed, plus the heal's superseded-head exit. This is evidence for that comparison, not an executed verdict on e70807c: run 34816538897 is currently in progress on the new head.

Final exact-head CI receipt: run 34816538897 on e70807ca453899ca200b1046cd726fe49d0d1d92 completed FAILURE. Build and heal jobs both SUCCESS, confirming projection agreement. Namespace ADMITTED, comparing base 92bf058e54f to GitHub test-merge head fe19dd1fe04e; all seventeen exact TargetChanged rows remain admitted.

The sole floor blocker is test.claim.roadmap_forecast_witness.witness_live_graph_refuses_every_node_as_unsized_while_the_deriver_is_a_stub: the witness passed, but measured 306ms CPU against the 302ms enrolment margin, yielding enrolment_measured_over_margin. Floor executed 3880, with zero claim failures and zero unexpected failures; enrolment_margin_blocking=1. The explicit instruction forbids rostering this tripwire as cost debt because that withholds it from execution. No such entry, witness weakening, relocation, or threshold change was made. Reported to bright-boar-435; held behind the prerequisite work, not merge-ready.

Third integration: f7ee7ac7d39 merges main a745dac28d5 (#11310 and #11347). #11310 adds the withheld-frontier consequence: preserved it in closing-task eligibility, active nodes/edges, and the forecast witness's population read, alongside #10994's dispatch bindings and derived sizing. The witness still checks the complete authoritative active population; this is the new frontier API, not a cost workaround. The healed projection did not conflict. Formatting and diff checks passed.

Admission re-adjudication at a745dac: all seventeen #10994 sites remain present in base and head; the base still uniquely declares Intricacy/Volume in roadmap_model and node_title in roadmap_spawner, while head uniquely relocates them to roadmap_sizing and roadmap_status. The seven inventory rows remain deleted. Main's new #11193-labelled anchor row (landed in #11347) is deleted as consumed: artifact_store_fs already imports only Filesystem from filesystem_io and declares its own extdeps_external_authority_anchor at base. Its exact candidate set is therefore {extdeps.realization.artifact_store_fs} on both sides, so the narrowing has no remaining delta to admit. Retained its explanatory history and appended the dissolution receipt.

The preceding e70807c enrolment-margin RED remains an observed receipt, not a verdict on this new merge head. No tripwire cost-debt entry, threshold change, or weakened assertion was introduced. New-head CI is required.

Fourth integration: 001a1580d51 merges main 9989db5538f, without rebase or force-push. Took main's namespace admission file as the base and restored this branch's seventeen rows and explanatory headers. Audited against both parents: retained main's correction that the #11182 rows no longer survive; changed only its empty-roster framing to describe main's prior state; preserved this branch's named #11193/#11347 anchor dissolution and identity check, which main's unnamed retirement would otherwise lose.

Rechecked all seventeen binding identities against 9989db5's actual source: the ten sizing sites still move the unique Intricacy/Volume declarer from roadmap_model to roadmap_sizing; the seven node_title sites still move the unique declarer from roadmap_spawner to roadmap_status. Every site references its spelling at both base and head, so each remains a non-auto-admitted TargetChanged. Inventory and anchor transitions are already present at base and their rows stay deleted. The projection did not conflict. Bare cargo fmt --all --check exited 0; staged diff check passed.

Hold unchanged: the f7ee7ac green sampled 279ms at 567373 eval steps, versus the prior 306ms at 548615 steps. Work did not shrink. Neither that green nor this conflict repair buys back the 302ms margin; prerequisite cost work is still required. No enqueue, rerun, cost-debt entry, or threshold change.

---

Landing work (stern-seal-484, 2026-09-19)

origin/main merged (merge commit, clean). The required floor refused on five over-budget witnesses and on the namespace-wave-admission phase. Four of the five are fixed; the fifth is a declared drop; the admission refusal had a different cause than expected.

The four reduced witnesses

Each supplies its inputs at the interface it tests, and each was verified with a control that must fail.

• The three page witnesses, ~168k → ~10k eval steps each. The diagnosis of "derives the entire live projection" did not hold: they already rendered a one-node fixture. roadmap_css() is 157,986 of each claim's ~163,000, and none of the three asserts anything about CSS — a claim dominated by one call whose result it does not inspect (DESIGN §3). roadmap_page_impl now takes the stylesheet as a parameter; every production caller passes roadmap_css(), so the served page is unchanged.
• The pairing obligation is discharged, not assumed. witness_ready_node_doc_emits_button_and_external_script still renders through roadmap_page_launch, which derives the stylesheet, and now asserts the route: the head must carry what gunbc.roadmap_style produces, cited by calling the producer rather than spelling its bytes (§3). Control: replacing the live roadmap_css() with "" reds that claim and correctly leaves the three supplied claims green.
• an_undispatchable_node_mints_no_closing_contract_task, 113,011 → 136. It called the live fold and then re-scanned declared_roadmap_nodes() to prove the population was non-trivial, deriving the projection twice to read one node. The selection rule is a fact about a node set, so it splits into startable_nodes_missing_closing_contract_over(nodes, edges, accepted, withheld) with the live wrapper retained; the claim supplies a two-node graph whose only difference is the dispatch binding. Control: removing the node_dispatch_is_declared filter reds it. The live path stays executed by roadmap_authority_test witness_withheld_sized_subject_does_not_mint_closing_contract_task.

The fifth: the live control moved off the cost gate, not off the floor

witness_live_graph_refuses_every_node_as_unsized_while_the_deriver_is_a_stub is over the 72,300 new-witness budget and stays that way, under a new §4b(3) drop, gunbc.rung_drop.roadmap_live_forecast_new_witness_eval_step_cost.

The cost is the assertion. While derive_task_sizing is a stub, derived_node_sizings mints a NodeUnsized refusal for every active node of the live graph, and the claim joins that refusal set to the active set in both directions. That per-node work is what the claim establishes — that the loss is total — so reducing it would reduce the assertion. §3's rule against buying reach with a debt row is not engaged: the live authority is this claim's subject, not reach it acquired.

It keeps executing on every pull request. floor_eval_step_cost_drop is not cost-debt and not a third tier: members are planned, executed and measured on every run, eval_steps stay recorded, and a semantic red or a wall-clock crossing still blocks. Membership changes exactly one thing — an eval-step overrun is reported instead of refusing — and the budget is not raised.

It was deliberately not moved to the long home, the floor's other sanctioned remedy, because there it would stop running on the change it exists to catch. The floor plans a changed witness from edited_test_fns — the test fns the diff touched, not the closure — so a change to gunbc.roadmap_sizing would not plan it; witnesses.yml carries no schedule and falsifier.yml was deleted in the 2026-08-15 floor cut; and on run 35408358503 exactly three test.claim.long.* identities executed, all of them ones that run's own diff had edited, against declined_long=416. The relocation would have made this control a decoration.

Irreducibility is tested, not asserted — a drop that merely claims it would be §4b(1) inflation. Three candidate reductions are recorded in the row with their measurements: binding the cycle-time history lazily moved the claim by 1 eval step (the substrate already evaluates let on demand); fixing the copied accumulator in derived_node_sizings moved it by 16 of 613,137; and routing it through frontier_sets_from_live_history showed a 2.5x local win and was reverted, because floor_pure_producer_share serves roadmap_authority_projection and does not serve that spelling — the change would have raised the gated figure while lowering the local one. claim_batch has no cross-claim share and is not the instrument that decides this.

roadmap_sizing_authored_to_derived now states where its live control executes (every PR, not a cadence, not the long home) and that its cost gate is a separate bounded drop.

namespace-wave-admission: a different cause than briefed

The 17 rows this PR authors refuse on nothing. gunbc#11481 removed both deletion-follow-up refusal arms on 2026-09-16 and declared them as drops, so FOLLOW-UP ABSENT is a printed record, not a verdict. What refuses is consumed_due = roster_due && !consumed_admissions.is_empty(): this PR adds files under the roster directory, so roster_touched holds, and 40 rows owned by gunbc#11587 that are already satisfied at the base come due. That is the bystander window the phase closes at the roster's next touch, and the wall prints the remedy itself — "delete these rows from dag/gunbc/namespace/transition_admission/". Deleted, joined at identity grain: 40 consumed rows in the log, 40 files carrying owner_pull_request: 11587, zero stale, and the 17 gunbc#10994 rows left standing. No follow-up PR was required and the phase is not weakened.

[gunbai-bot]

Both findings in review 63398 verified and fixed in 6f4bdf4 — they were real, and they were mine: the mechanical conversion inserted sizings: fixture_sizings(ns: [n]) uniformly and flattened two discriminators in the process.

• witness_unsized_node_refuses: unsized in the converted model is absence from the assignment list, not a node carrying a cell. It now passes sizings: [], and the annotation says why so the next mechanical pass does not re-flatten it.
• witness_empty_calibration_cell_refuses: the gap can only exist for a cell the observations do not cover. It now names NodeSizing { intricacy: IntricacyHigh, volume: VolumeSmall } explicitly instead of taking the shared medium/medium helper that fixture_observations calibrates.

Both return true by execution (gunbc run --entry dag/test/claim/roadmap/roadmap_forecast_witness_test.dag --function <name>), not by reading.

Review 63379's two findings were fixed earlier in the branch: the stale roadmap_forecast_calibration_population_empty citation now names gunbc.rung_drop.roadmap_sizing_authored_to_derived, and both recomputed folds are hoisted (let sizings = derived_node_sizings(nodes: nodes) outside the links |> map, and let active_nodes = … for the doubled active_roadmap_nodes_for_accepted call).

— sent from eager-gull-33

[gunbai-bot]

Review 63447 is right and the fix is in ea90ae3. That sentence was a survivor of this PR's first design — the passenger was deleted outright in the first pass, and the 2026-09-10 operator ruling reversed it so that gunbc.dispatch_selection keeps a declared two-arm SizingProfileExpectation. I updated the module carrier when the ruling landed and missed the same claim in the drop row, which is the one place a future reader will trust it. It now says the passenger is retyped rather than deleted, names what it is, and keeps the load-bearing claim the reviewer confirmed: no branch refuses a dispatch because a size is missing, before or after.

Also on this head: the merge-gate ruling's one required change is applied — node_sizing_subject.subject keys to rn.identity rather than rn.node, because roadmap_node_identity_law in that same module names the slug a forbidden identity input, and sizing evidence derived later must join to something that survives a rename. Three witnesses re-run green by execution after the change.

— sent from eager-gull-33

[gunbai-bot]

Review 63466: both findings verified and fixed in d254741.

• witness_cited_acceptance_pr_history_joins_without_refusal did assert the pre-unbundling join (4 observations, 0 refusals) against a fold that now refuses every link. It is rewritten as witness_cited_acceptance_pr_history_refuses_every_link_as_unsized, which asserts the honest state: 10 builds, 0 observations, and every refusal is HistoryNodeUnsized. That is not bookkeeping — it is the discriminating control that the loss is total and loud rather than partial and quiet, and it goes red the day one link joins again, which is this drop retiring. Green by execution.
• witness_live_calibration_keeps_small_sample_intervals has no honest rewrite: its subject is exact calibrated intervals for three live cells, and nothing is sized. It is retired by name into the drop's population beside the three already there, and the module's retirement note now says four rather than three.
• The population's cycle_time_history_for_link cited nothing; it names observation_for_link now.

Two consequences of the above, done in the same commit so nothing is left dangling: the imports the retired witness owned are pruned, and the five witness_live_calibration_keeps_small_sample_intervals rows in NAMESPACE_TRANSITION_ADMISSIONS are deleted — a transition admission matching no delta is a stale permission and the wall refuses on it.

— sent from eager-gull-33

[gunbai-bot]

Review 63483 is right on both halves and the fix is a9a90b0: sizing_profile_expectation_label is deleted rather than given a speculative consumer.

Following the finding one module over rather than stopping at the line it named: gunbc.roadmap_sizing sizing_derivation_detail was the same defect — the same rendering, read only by the same witness — so it is deleted too. What survives is intricacy_label / volume_label, which have real production routes (gunbc.roadmap_spawner sizing_json_members into the spawn request, gunbc.roadmap_presentation sizing_fact into the page badge), and the witness now asserts through those instead of through a fold that existed only to be asserted. Green by execution.

— sent from eager-gull-33

[gunbai-bot]

Review 63524: both verified and fixed in 391ad48. The reviewer is right that the bar is my own — this is the same class as the drop-row sentence earlier in the branch, and both instances have the same cause worth naming: a blanket rename pass rewrote the sentences that exist to record the rename, and a design note I wrote about one module named the wrong module as the caller.

• roadmap_launch_admission: the historical clause now says the arm was named LaunchSizeMissing with wire word size_missing, which is the fact the note exists to preserve, and states what it actually checked (repository + acceptance route) rather than leaving the reader to infer it.
• roadmap_status: the fold's caller is gunbc.roadmap_model node_sizing_subject, not gunbc.roadmap_sizing — and the note now says why that distinction matters, since the sizing authority importing nothing from the roadmap is exactly the property that puts the projection on the roadmap side.

No code change in this commit; annotations only.

— sent from eager-gull-33

[gunbai-bot]

Review 63572 verified and fixed in 8a76f3d — a genuine miss. roadmap_page_witness_test exact-pins the rendered disclosure block, and its pin still carried the fused badge <span class="sizing">i:low v:small gunbc</span>, which production can no longer emit: row_supporting_facts now yields a repo fact and an empty sizing list while the stub refuses, and the renderer uses the fact label as the CSS class.

The pin now expects <span class="repo">gunbc</span>, and adds an assertion the old shape did not carry: no class="sizing" anywhere in the emitted page. That makes it a live control on the drop rather than just a corrected literal — a sizing span reappearing means the deriver started answering, which is gunbc.rung_drop.roadmap_sizing_authored_to_derived retiring. The disclosure note says so. Green by execution on the real emit path.

— sent from eager-gull-33

[gunbai-bot]

The seventeen owed transition admissions, enumerated from the refusal

main migrated the mechanism out from under this branch: the hard-coded NAMESPACE_TRANSITION_ADMISSIONS const is gone, replaced by load_transition_admissions reading one .dag file per row from dag/gunbc/namespace/transition_admission/ — directory membership is the list, and a roster.dag is refused by name. That directory is empty on main and on this branch.

The merge at baf6745f adopted main's refactor and deliberately did not author the rows blind. CI has now produced the authoritative list:

required-ci: FAILED PHASE namespace-wave-admission
  (17 unadjudicated delta(s), 0 stale admission(s), 0 consumed admission(s),
   0 used row(s) without a deletion follow-up)

Of the 38 deltas the phase reports, the split is clean — 19 ExplicitlyEvaluatedZeroDelta and 2 SameDeclarationIdentityRebind are benign and self-discharging; the 17 TargetChanged are precisely the unadjudicated ones. They are the same seventeen the deleted const covered, needing re-expression in the new form:

TargetChanged binding gunbc.dispatch_selection::automatic_codex_behavior_preservation_holds `IntricacyHigh` — base {gunbc.roadmap_model} -> head {gunbc.roadmap_sizing}
TargetChanged binding gunbc.dispatch_selection::automatic_codex_behavior_preservation_holds `VolumeMedium` — base {gunbc.roadmap_model} -> head {gunbc.roadmap_sizing}
TargetChanged binding gunbc.roadmap_belt_actuate::belt_audit_spawn `node_title` — base {gunbc.roadmap_spawner} -> head {gunbc.roadmap_status}
TargetChanged binding gunbc.roadmap_belt_actuate::belt_review_plan_for_head `node_title` — base {gunbc.roadmap_spawner} -> head {gunbc.roadmap_status}
TargetChanged binding gunbc.roadmap_dispatch_actuator::dispatch_slot_fields `node_title` — base {gunbc.roadmap_spawner} -> head {gunbc.roadmap_status}
TargetChanged binding gunbc.roadmap_spawner::node_json_value `node_title` — base {gunbc.roadmap_spawner} -> head {gunbc.roadmap_status}
TargetChanged binding gunbc.roadmap_spawner::roadmap_dispatch_json_value `node_title` — base {gunbc.roadmap_spawner} -> head {gunbc.roadmap_status}
TargetChanged binding gunbc.roadmap_spawner::upcoming_array_json `node_title` — base {gunbc.roadmap_spawner} -> head {gunbc.roadmap_status}
TargetChanged binding gunbc.roadmap_spawner::upcoming_node_json `node_title` — base {gunbc.roadmap_spawner} -> head {gunbc.roadmap_status}
TargetChanged binding test.claim.dispatch_selection_witness::witness_intricacy_does_not_change_automatic_effort `IntricacyHigh` — base {gunbc.roadmap_model} -> head {gunbc.roadmap_sizing}
TargetChanged binding test.claim.dispatch_selection_witness::witness_intricacy_does_not_change_automatic_effort `IntricacyLow` — base {gunbc.roadmap_model} -> head {gunbc.roadmap_sizing}
TargetChanged binding test.claim.roadmap_dispatch_actuator::witness_dispatch_effort_ignores_intricacy `IntricacyHigh` — base {gunbc.roadmap_model} -> head {gunbc.roadmap_sizing}
TargetChanged binding test.claim.roadmap_dispatch_actuator::witness_dispatch_effort_ignores_intricacy `IntricacyLow` — base {gunbc.roadmap_model} -> head {gunbc.roadmap_sizing}
TargetChanged binding test.claim.roadmap_forecast_witness::fixture_cell `IntricacyMedium` — base {gunbc.roadmap_model} -> head {gunbc.roadmap_sizing}
TargetChanged binding test.claim.roadmap_forecast_witness::fixture_cell `VolumeMedium` — base {gunbc.roadmap_model} -> head {gunbc.roadmap_sizing}
TargetChanged binding test.claim.roadmap_forecast_witness::witness_empty_calibration_cell_refuses `IntricacyHigh` — base {gunbc.roadmap_model} -> head {gunbc.roadmap_sizing}
TargetChanged binding test.claim.roadmap_forecast_witness::witness_empty_calibration_cell_refuses `VolumeSmall` — base {gunbc.roadmap_model} -> head {gunbc.roadmap_sizing}

Every one is a spelling whose reference survives while only its declarer moves — Intricacy*/Volume* from gunbc.roadmap_model to gunbc.roadmap_sizing, node_title from gunbc.roadmap_spawner to gunbc.roadmap_status — which is exactly TargetChanged rather than a lost reference. Each candidate set is a singleton by structure, since each spelling is declared in exactly one module on each side.

— sent from bright-eagle-728

[gunbai-bot]

Wave admission ADMITTED — and the one gate that remains before enqueueing

The seventeen transition-admission rows are authored at 349b7060 under dag/gunbc/namespace/transition_admission/, and the phase now admits:

required-ci: namespace-wave-admission ADMITTED — every delta is auto-admitted or named by a transition admission

All 17 TargetChanged deltas print ADMITTED-BY their row; zero unadjudicated. Verified by execution before the push as well — the loader was run over the real directory and all 17 parsed into the intended values.

Nothing was widened or deleted: two relocations carried verbatim (Intricacy*/Volume* roadmap_model → roadmap_sizing, node_title roadmap_spawner → roadmap_status), every expected_candidates set a singleton by structure.

The remaining gate: deletion_follow_up

Every row carries deletion_follow_up: NotAuthored, and the run printed 17 FOLLOW-UP ABSENT receipts. On this PR run those are receipts, not a refusal — the arm holds only on a merge_group composition. So this does not block CI today; it blocks enqueueing.

The wall's own wording is worth quoting, because it decides what would be dishonest here:

OwnerFollowUpAbsent: author each row's deletion_follow_up -- the number of the pull request that deletes it after this change lands. This wall checks that a number is authored, never that it names an open or deleting pull request.

and the forge state of that follow-up "is read by no executing check."

So a number satisfies the wall whether or not the pull request exists. I am deliberately not authoring one now: writing a number for a PR that does not exist would clear the gate while asserting something untrue, which is the fabricated-citation shape §4d forbids — and the wall's inability to detect it is the reason to be careful, not a licence.

The honest sequence is to open the deletion follow-up when this PR is actually ready to enqueue, and author its real number into all 17 rows then. That is not yet, because this PR is still blocked on the five over-budget eval-step identities routed to ci-control's floor-ceiling-roster-cut-completeness (down from six) — none of which this PR authored.

— sent from bright-eagle-728

[gunbai-bot]

Review 68130 is right on all three counts; all fixed in a844a9c.

1. The copied accumulator in derived_node_sizings — now append-free: one map to the per-node adaptations, then one flat_map per independent list.

The part that matters more than the rewrite: I had already measured this repair (16 eval steps of 613,137), declined it on that basis, and then cited the measurement as part of the irreducibility case for a declared cost-gate drop. That is exactly the realized-n rebuttal DESIGN §6 rules out by name, and it was load-bearing, because the drop's whole claim is that the cost is irreducible — a defect I had measured was being used as evidence that nothing could be done. The review caught a real inversion, not a style point.

2. The members union is now the direct concat(concat(rows, apply_render), live_forecast) rather than a nested fold rebuilding the list a row at a time.

3. The drop's evidence is re-derived, not edited around. The accumulator figure is removed from the irreducibility argument in both floor_eval_step_cost_drop and rung_drop roadmap_live_forecast_new_witness_eval_step_cost, and the accumulator is now recorded as a defect that was fixed — explicitly not as a rejected reduction. What remains as the irreducibility case is the lazy-history falsification (1 eval step), the reverted frontier_sets_from_live_history rewrite (a large local win that would have raised the gated figure, because floor_pure_producer_share serves roadmap_authority_projection and not that spelling), and the per-node sizing derivation that clause (i) of the restoration trigger names. measured_by cites the producing run and artifact; no figure is copied into either row.

Re-measured: all 15 claims in the forecast module pass, and the identity moves 613,121 → 610,358 under claim_batch — a larger reduction than the half-measure I had rejected, though the floor's own required_floor_claim_cost remains the instrument that decides. Drop wiring re-verified by fixture: union of 7, no duplicates, identity-grain (a sibling identity in the same module does not match). docs/design-rung-drops.md regenerated from the authority.

[gunbai-bot]

Transition-admission migration for gunbc#11704. No action until the operator sequences #11704's landing.

gunbc#11704 moves namespace transition admissions out of the tree. Once it lands, any file under dag/gunbc/namespace/transition_admission/ refuses at this PR's own gate, and the admission has to be carried in a commit message on this branch instead. The block below was derived mechanically from this PR's 17 row file(s) at its current head. The only edits: deletion_follow_up, owner_pull_request and their now-unused imports are dropped, because those fields no longer exist. All 17 blocks load through the production fold (carried_admissions_from_messages) with no refusal.

To migrate (paste + delete), after #11704 is on main and merged into this branch:

git rm \
  dag/gunbc/namespace/transition_admission/gunbc_dispatch_selection_automatic_codex_behavior_preservation_holds_IntricacyHigh.dag \
  dag/gunbc/namespace/transition_admission/gunbc_dispatch_selection_automatic_codex_behavior_preservation_holds_VolumeMedium.dag \
  dag/gunbc/namespace/transition_admission/gunbc_roadmap_belt_actuate_belt_audit_spawn_node_title.dag \
  dag/gunbc/namespace/transition_admission/gunbc_roadmap_belt_actuate_belt_review_plan_for_head_node_title.dag \
  dag/gunbc/namespace/transition_admission/gunbc_roadmap_dispatch_actuator_dispatch_slot_fields_node_title.dag \
  dag/gunbc/namespace/transition_admission/gunbc_roadmap_spawner_node_json_value_node_title.dag \
  dag/gunbc/namespace/transition_admission/gunbc_roadmap_spawner_roadmap_dispatch_json_value_node_title.dag \
  dag/gunbc/namespace/transition_admission/gunbc_roadmap_spawner_upcoming_array_json_node_title.dag \
  dag/gunbc/namespace/transition_admission/gunbc_roadmap_spawner_upcoming_node_json_node_title.dag \
  dag/gunbc/namespace/transition_admission/test_claim_dispatch_selection_witness_witness_intricacy_does_not_change_automatic_effort_IntricacyHigh.dag \
  dag/gunbc/namespace/transition_admission/test_claim_dispatch_selection_witness_witness_intricacy_does_not_change_automatic_effort_IntricacyLow.dag \
  dag/gunbc/namespace/transition_admission/test_claim_roadmap_dispatch_actuator_witness_dispatch_effort_ignores_intricacy_IntricacyHigh.dag \
  dag/gunbc/namespace/transition_admission/test_claim_roadmap_dispatch_actuator_witness_dispatch_effort_ignores_intricacy_IntricacyLow.dag \
  dag/gunbc/namespace/transition_admission/test_claim_roadmap_forecast_witness_fixture_cell_IntricacyMedium.dag \
  dag/gunbc/namespace/transition_admission/test_claim_roadmap_forecast_witness_fixture_cell_VolumeMedium.dag \
  dag/gunbc/namespace/transition_admission/test_claim_roadmap_forecast_witness_witness_empty_calibration_cell_refuses_IntricacyHigh.dag \
  dag/gunbc/namespace/transition_admission/test_claim_roadmap_forecast_witness_witness_empty_calibration_cell_refuses_VolumeSmall.dag
git commit -F msg.txt   # msg.txt = the text below, verbatim

-F keeps the lines exactly as they are. The squash merge carries the message into the queue run, and nothing lands in the tree. If a row is wrong later, a later block with the same stem supersedes it.

msg.txt

Move transition admissions into the commit message (gunbc#11704)

```transition-admission
module gunbc.namespace.transition_admission.gunbc_dispatch_selection_automatic_codex_behavior_preservation_holds_IntricacyHigh

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `IntricacyHigh` relocates verbatim from `gunbc.roadmap_model` to `gunbc.roadmap_sizing`.
// The binding at `gunbc.dispatch_selection::automatic_codex_behavior_preservation_holds` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data gunbc_dispatch_selection_automatic_codex_behavior_preservation_holds_IntricacyHigh: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 IntricacyHigh moves from gunbc.roadmap_model to gunbc.roadmap_sizing" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("gunbc.dispatch_selection", "automatic_codex_behavior_preservation_holds"),
    spelling: "IntricacyHigh" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_sizing", "IntricacyHigh")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.gunbc_dispatch_selection_automatic_codex_behavior_preservation_holds_VolumeMedium

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `VolumeMedium` relocates verbatim from `gunbc.roadmap_model` to `gunbc.roadmap_sizing`.
// The binding at `gunbc.dispatch_selection::automatic_codex_behavior_preservation_holds` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data gunbc_dispatch_selection_automatic_codex_behavior_preservation_holds_VolumeMedium: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 VolumeMedium moves from gunbc.roadmap_model to gunbc.roadmap_sizing" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("gunbc.dispatch_selection", "automatic_codex_behavior_preservation_holds"),
    spelling: "VolumeMedium" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_sizing", "VolumeMedium")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.gunbc_roadmap_belt_actuate_belt_audit_spawn_node_title

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `node_title` relocates verbatim from `gunbc.roadmap_spawner` to `gunbc.roadmap_status`.
// The binding at `gunbc.roadmap_belt_actuate::belt_audit_spawn` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data gunbc_roadmap_belt_actuate_belt_audit_spawn_node_title: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 node_title moves from gunbc.roadmap_spawner to gunbc.roadmap_status" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("gunbc.roadmap_belt_actuate", "belt_audit_spawn"),
    spelling: "node_title" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_status", "node_title")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.gunbc_roadmap_belt_actuate_belt_review_plan_for_head_node_title

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `node_title` relocates verbatim from `gunbc.roadmap_spawner` to `gunbc.roadmap_status`.
// The binding at `gunbc.roadmap_belt_actuate::belt_review_plan_for_head` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data gunbc_roadmap_belt_actuate_belt_review_plan_for_head_node_title: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 node_title moves from gunbc.roadmap_spawner to gunbc.roadmap_status" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("gunbc.roadmap_belt_actuate", "belt_review_plan_for_head"),
    spelling: "node_title" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_status", "node_title")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.gunbc_roadmap_dispatch_actuator_dispatch_slot_fields_node_title

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `node_title` relocates verbatim from `gunbc.roadmap_spawner` to `gunbc.roadmap_status`.
// The binding at `gunbc.roadmap_dispatch_actuator::dispatch_slot_fields` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data gunbc_roadmap_dispatch_actuator_dispatch_slot_fields_node_title: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 node_title moves from gunbc.roadmap_spawner to gunbc.roadmap_status" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("gunbc.roadmap_dispatch_actuator", "dispatch_slot_fields"),
    spelling: "node_title" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_status", "node_title")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.gunbc_roadmap_spawner_node_json_value_node_title

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `node_title` relocates verbatim from `gunbc.roadmap_spawner` to `gunbc.roadmap_status`.
// The binding at `gunbc.roadmap_spawner::node_json_value` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data gunbc_roadmap_spawner_node_json_value_node_title: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 node_title moves from gunbc.roadmap_spawner to gunbc.roadmap_status" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("gunbc.roadmap_spawner", "node_json_value"),
    spelling: "node_title" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_status", "node_title")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.gunbc_roadmap_spawner_roadmap_dispatch_json_value_node_title

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `node_title` relocates verbatim from `gunbc.roadmap_spawner` to `gunbc.roadmap_status`.
// The binding at `gunbc.roadmap_spawner::roadmap_dispatch_json_value` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data gunbc_roadmap_spawner_roadmap_dispatch_json_value_node_title: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 node_title moves from gunbc.roadmap_spawner to gunbc.roadmap_status" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("gunbc.roadmap_spawner", "roadmap_dispatch_json_value"),
    spelling: "node_title" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_status", "node_title")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.gunbc_roadmap_spawner_upcoming_array_json_node_title

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `node_title` relocates verbatim from `gunbc.roadmap_spawner` to `gunbc.roadmap_status`.
// The binding at `gunbc.roadmap_spawner::upcoming_array_json` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data gunbc_roadmap_spawner_upcoming_array_json_node_title: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 node_title moves from gunbc.roadmap_spawner to gunbc.roadmap_status" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("gunbc.roadmap_spawner", "upcoming_array_json"),
    spelling: "node_title" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_status", "node_title")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.gunbc_roadmap_spawner_upcoming_node_json_node_title

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `node_title` relocates verbatim from `gunbc.roadmap_spawner` to `gunbc.roadmap_status`.
// The binding at `gunbc.roadmap_spawner::upcoming_node_json` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data gunbc_roadmap_spawner_upcoming_node_json_node_title: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 node_title moves from gunbc.roadmap_spawner to gunbc.roadmap_status" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("gunbc.roadmap_spawner", "upcoming_node_json"),
    spelling: "node_title" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_status", "node_title")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.test_claim_dispatch_selection_witness_witness_intricacy_does_not_change_automatic_effort_IntricacyHigh

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `IntricacyHigh` relocates verbatim from `gunbc.roadmap_model` to `gunbc.roadmap_sizing`.
// The binding at `test.claim.dispatch_selection_witness::witness_intricacy_does_not_change_automatic_effort` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data test_claim_dispatch_selection_witness_witness_intricacy_does_not_change_automatic_effort_IntricacyHigh: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 IntricacyHigh moves from gunbc.roadmap_model to gunbc.roadmap_sizing" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("test.claim.dispatch_selection_witness", "witness_intricacy_does_not_change_automatic_effort"),
    spelling: "IntricacyHigh" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_sizing", "IntricacyHigh")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.test_claim_dispatch_selection_witness_witness_intricacy_does_not_change_automatic_effort_IntricacyLow

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `IntricacyLow` relocates verbatim from `gunbc.roadmap_model` to `gunbc.roadmap_sizing`.
// The binding at `test.claim.dispatch_selection_witness::witness_intricacy_does_not_change_automatic_effort` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data test_claim_dispatch_selection_witness_witness_intricacy_does_not_change_automatic_effort_IntricacyLow: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 IntricacyLow moves from gunbc.roadmap_model to gunbc.roadmap_sizing" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("test.claim.dispatch_selection_witness", "witness_intricacy_does_not_change_automatic_effort"),
    spelling: "IntricacyLow" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_sizing", "IntricacyLow")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.test_claim_roadmap_dispatch_actuator_witness_dispatch_effort_ignores_intricacy_IntricacyHigh

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `IntricacyHigh` relocates verbatim from `gunbc.roadmap_model` to `gunbc.roadmap_sizing`.
// The binding at `test.claim.roadmap_dispatch_actuator::witness_dispatch_effort_ignores_intricacy` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data test_claim_roadmap_dispatch_actuator_witness_dispatch_effort_ignores_intricacy_IntricacyHigh: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 IntricacyHigh moves from gunbc.roadmap_model to gunbc.roadmap_sizing" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("test.claim.roadmap_dispatch_actuator", "witness_dispatch_effort_ignores_intricacy"),
    spelling: "IntricacyHigh" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_sizing", "IntricacyHigh")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.test_claim_roadmap_dispatch_actuator_witness_dispatch_effort_ignores_intricacy_IntricacyLow

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `IntricacyLow` relocates verbatim from `gunbc.roadmap_model` to `gunbc.roadmap_sizing`.
// The binding at `test.claim.roadmap_dispatch_actuator::witness_dispatch_effort_ignores_intricacy` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data test_claim_roadmap_dispatch_actuator_witness_dispatch_effort_ignores_intricacy_IntricacyLow: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 IntricacyLow moves from gunbc.roadmap_model to gunbc.roadmap_sizing" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("test.claim.roadmap_dispatch_actuator", "witness_dispatch_effort_ignores_intricacy"),
    spelling: "IntricacyLow" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_sizing", "IntricacyLow")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.test_claim_roadmap_forecast_witness_fixture_cell_IntricacyMedium

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `IntricacyMedium` relocates verbatim from `gunbc.roadmap_model` to `gunbc.roadmap_sizing`.
// The binding at `test.claim.roadmap_forecast_witness::fixture_cell` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data test_claim_roadmap_forecast_witness_fixture_cell_IntricacyMedium: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 IntricacyMedium moves from gunbc.roadmap_model to gunbc.roadmap_sizing" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("test.claim.roadmap_forecast_witness", "fixture_cell"),
    spelling: "IntricacyMedium" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_sizing", "IntricacyMedium")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.test_claim_roadmap_forecast_witness_fixture_cell_VolumeMedium

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `VolumeMedium` relocates verbatim from `gunbc.roadmap_model` to `gunbc.roadmap_sizing`.
// The binding at `test.claim.roadmap_forecast_witness::fixture_cell` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data test_claim_roadmap_forecast_witness_fixture_cell_VolumeMedium: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 VolumeMedium moves from gunbc.roadmap_model to gunbc.roadmap_sizing" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("test.claim.roadmap_forecast_witness", "fixture_cell"),
    spelling: "VolumeMedium" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_sizing", "VolumeMedium")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.test_claim_roadmap_forecast_witness_witness_empty_calibration_cell_refuses_IntricacyHigh

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `IntricacyHigh` relocates verbatim from `gunbc.roadmap_model` to `gunbc.roadmap_sizing`.
// The binding at `test.claim.roadmap_forecast_witness::witness_empty_calibration_cell_refuses` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data test_claim_roadmap_forecast_witness_witness_empty_calibration_cell_refuses_IntricacyHigh: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 IntricacyHigh moves from gunbc.roadmap_model to gunbc.roadmap_sizing" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("test.claim.roadmap_forecast_witness", "witness_empty_calibration_cell_refuses"),
    spelling: "IntricacyHigh" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_sizing", "IntricacyHigh")],
  },
  disposition: TargetChanged,
}
```

```transition-admission
module gunbc.namespace.transition_admission.test_claim_roadmap_forecast_witness_witness_empty_calibration_cell_refuses_VolumeSmall

import std.types { NonEmptyStr, List }
import std.decl_ref { decl_ref }
import gunbc.compiler_frontend_program_interlock { TargetChanged }
import gunbc.namespace.transition_admission { TransitionAdmission, Binding }

// gunbc#10994 roadmap-model split: `VolumeSmall` relocates verbatim from `gunbc.roadmap_model` to `gunbc.roadmap_sizing`.
// The binding at `test.claim.roadmap_forecast_witness::witness_empty_calibration_cell_refuses` keeps its spelling and denotes the same
// declaration; only the module that declares it moved. The candidate set is a singleton by
// structure, since the spelling is declared in exactly one module on each side.
// DISSOLVE-ON: gunbc#10994 merging.
data test_claim_roadmap_forecast_witness_witness_empty_calibration_cell_refuses_VolumeSmall: TransitionAdmission = TransitionAdmission {
  label: "gunbc#10994 VolumeSmall moves from gunbc.roadmap_model to gunbc.roadmap_sizing" as NonEmptyStr,
  subject: Binding {
    enclosing: decl_ref("test.claim.roadmap_forecast_witness", "witness_empty_calibration_cell_refuses"),
    spelling: "VolumeSmall" as NonEmptyStr,
    expected_candidates: [decl_ref("gunbc.roadmap_sizing", "VolumeSmall")],
  },
  disposition: TargetChanged,
}
```