diff --git a/harness/DECISIONS.md b/harness/DECISIONS.md
index fc32dfce..b91f4dc1 100644
--- a/harness/DECISIONS.md
+++ b/harness/DECISIONS.md
@@ -546,3 +546,32 @@ compatibility as a necessary placement constraint in a future initial coordinate
 assignment with connection ordering and corridor/label space. Compound geometry,
 automatic side changes and native tracing remain separate required evidence.
 This is branch-specific experimental evidence, not an integrated capability.
+
+## Keep cyclic groups coherent before assigning global ranks — 2026-09-25
+
+The [SCC placement experiment](experiments/scc-placement-20260925/results.md)
+at `2426d286` supports condensation of sibling-subtree cycles as a useful
+structural step. Independent reconstruction finds four ten-node components in
+the sparse case. Compact blocks remove the old layered prototype's shared top
+corridor: raw pairwise sharing falls from 40,522 to 32, with fewer crossings and
+less area than that prototype. The released router is unchanged. The full
+comparison includes original and Arrange-reset controls; this is not a universal
+improvement across all measures or scenes.
+
+Preserve effective geometry at the placement-transfer boundary. An old
+projected size can depend on children that subsequently move inward; retaining
+the old authored size then loses an explicitly requested minimum. The corrected
+example importer makes one conditional simultaneous minimum restoration and
+still demands exact final projection. All 14 frozen cases now complete; the
+13 prior successful outputs remain exactly unchanged, with conservation,
+roundtrip and ten-call checks recorded. This is an experimental transfer
+contract, not a production command or history integration.
+
+Do not adopt the whole candidate yet. The two-container case still ignores
+external-neighbor order within each parent and is worse than the old layered
+zero-sharing witness. Sparse residual label conflicts, folded route retracing,
+bipartite sharing and area tradeoffs remain distinct issues. The next bounded
+comparison should preserve coherent SCC ranks while using actual cross-boundary
+neighbors to order siblings. Treat label association separately from route
+sharing, preserve the full quality vector, and retain native tracing as a later
+acceptance gate. No global gap or routing-penalty sweep follows from this result.
diff --git a/harness/auto-layout-investigation-20260925.md b/harness/auto-layout-investigation-20260925.md
index d31e3c58..e72dd4ae 100644
--- a/harness/auto-layout-investigation-20260925.md
+++ b/harness/auto-layout-investigation-20260925.md
@@ -138,3 +138,14 @@ shared-run and label/stroke measures. Preserve the compatibility result without
 adopting this repair as Arrange. Initial connection ordering and reserved routing/
 label space, with compound handling, remain the next planner questions; more
 repair iterations or router penalty tuning are not supported by this evidence.
+
+The [coherent cyclic-group experiment](experiments/scc-placement-20260925/results.md)
+then isolates the old native candidate's rank-stretching problem. Sparse sharing
+falls from 40,522 to 32 with unchanged released routing. A corrected importer
+preserves requested effective container minima after child movement; all 14
+frozen cases complete and the 13 previously successful results remain exact.
+This is useful structural evidence, not an Arrange replacement. Cross-boundary
+child ordering, local label conflicts and folded backtracking remain explicit
+witnesses. Source, failed/successful runs, conservation and independent reviews
+are linked from the result. Gitea remains authoritative for live ownership and
+publication status; no integrated checkpoint or release change is implied.
diff --git a/harness/experiments/scc-placement-20260925/conservation-review-run02.md b/harness/experiments/scc-placement-20260925/conservation-review-run02.md
new file mode 100644
index 00000000..c0ca61b5
--- /dev/null
+++ b/harness/experiments/scc-placement-20260925/conservation-review-run02.md
@@ -0,0 +1,15 @@
+# SCC conservation review — corrected run02
+
+Source `2426d286483ab0445663221cd6010a3dadb89a97`; all14 cases supported. Independent Python-only raw-Project audit passes every reconstructed conservation/minimum/enclosure check and all38 receipt file hash/size bindings. No Rust, compiler, routing or GUI execution by reviewer. Original run01 script, failure record and review remain untouched.
+
+All13 previously successful complete after-Projects **and complete metric objects are exactly equal** to run01. The newly supported `two_containers_reversed_children` has roots at(40,40) and(494,40), each stored308×446; children at(72,136),(72,300),(526,136),(526,300), each stored224×94. Final projected child heights132 leave valid32left/96top minimum padding; final root projection matches308×446.
+
+Independently evaluated the new conditional restoration, rather than allowing arbitrary size changes: these are noncollapsed, unported, ordinary parents whose original projected minimum is308×446. With original authored size and the final child geometry, core's24-unit side/footer and64-unit header enclosure would produce280×416 at the exact same position. The supplied unchanged effective minimum therefore requires explicit stored restoration to308×446. Both parents satisfy this condition; no other previously passing Project changes. This closes the recorded single-case transfer defect, not a new SCC-policy improvement.
+
+The complete expected Project retains semantic records, other diagrams, authored anchor arrays, identities/order and all nongeometry fields. Three eligible authored routes reset as in run01. Folded workshop's three latent descendants still independently follow their actual Allocation/semantic ancestor by(-680,0), with expanded sizes retained. No dormant/promoted authored-route translation or nonempty attachment coverage is present; do not infer it from the policy code.
+
+All14 records report exact same-input output, exact calls2–10 against both first and previous, and exact JSON/single-source round trips. These are recorded Rust checks; repeated full Projects and source strings are not serialized for independent reconstruction. Exact intended node plans remain a source-gate assertion: the audit checks emitted final geometry against permitted full-model changes/minima/enclosures, not an independent SCC-packing implementation. No native quality or production acceptance follows.
+
+Standalone checker `audit-scc-conservation-v2-20260925.py` SHA256 `66a1621ac04e73bf08637047ed623c7154c0219a3076be7246004e6bf134d4e2`; result `scc-conservation-audit-run02-20260925.json` SHA256 `2897af5f3d131e2633a8dc5c9385307516c7c4db227349b374d4d062423a425e`. Both are under `.local`.
+
+Invocation: `python audit-scc-conservation-v2-20260925.py .local/scc-placement-20260925/run02 NEW_OUTPUT_JSON 2426d286483ab0445663221cd6010a3dadb89a97 .local/scc-placement-20260925/run01`. Expected source pin is mandatory and output refuses overwrite.
diff --git a/harness/experiments/scc-placement-20260925/conservation-review.md b/harness/experiments/scc-placement-20260925/conservation-review.md
new file mode 100644
index 00000000..fc475215
--- /dev/null
+++ b/harness/experiments/scc-placement-20260925/conservation-review.md
@@ -0,0 +1,17 @@
+# Independent SCC Project-conservation review
+
+Read-only arithmetic/JSON audit of `.local/scc-placement-20260925/run01`, source `4dd764fa6cfc6920350383e523ba5a597412ddf4`. No Rust/compiler/router/GUI rerun. Auditable standalone Python checker: `audit-scc-conservation-20260925.py` SHA256 `7ebe5726c49c0918a9fbd55f74e16cac484ccec9d13f9cada7a7b36672ff1035`. Final machine result `scc-conservation-audit-final-20260925.json` SHA256 `c9156b710323d940a712ca8973a2e823a422faf96ad9c509193968ecf2f7fdd9`.
+
+All14 cases accounted for:13 supported; `two_containers_reversed_children` rejects with `Final Rust projection differs from intended node geometry`. Its absence of an after-Project prevents conservation/enclosure/repeat checks; this is unsupported coverage, not a passed case. Read back38 receipt bindings with exact byte sizes/hashes; no mismatch.
+
+For every supported case, independently reconstructed the entire expected Project from before-Project, final emitted projected positions/effective dimensions, actual semantic endpoint-owner placements, preoperation visible non-promoted edge eligibility and original route records. Compared the complete structure exactly, rather than trusting conservation booleans. All pass. Only declared target placement geometry and three eligible authored route resets change: mixed, reversed mixed, and authored_detour_and_label. Route entry identities/order and remaining fields are retained. All semantic records, other diagrams and authored port-anchor arrays remain exact. Projected identity/visual-parent inventory and frozen minimum sizes remain valid. Existing effective dimensions retain authored stored sizes; compact collapsed dimensions retain expanded stored sizes.
+
+The folded workshop supplies actual latent movement: Rescue response, Send advice and Assess incident each translate by(-680,0) with collapsed owner `75920e7a-4586-58b7-9eb2-7e0a3d8a1825`. This was independently recovered through source Allocation/role/per-leaf performer and semantic ancestry relationships, not inferred merely from equal observed deltas. All hidden sizes/metadata remain exact. Supported final child enclosures satisfy left/right/bottom32 and non-State top96. This does not test State-specific header geometry.
+
+All13 supported records report same-input exactness, nine repeat comparisons for calls2–10 equal both previous and first, and exact JSON/single-source round trips without errors. Those flags originate in Rust: repeated full Projects and source strings are not serialized, so this audit does not claim independent reexecution of them. Exact intended PlacementPlan nodes are also absent; the source final-reprojection gate checks that relation. This audit independently validates allowed full-Project changes, minima and enclosures using the emitted final projection, not a separate derivation of the SCC packing output.
+
+No surviving dormant/promoted authored routes occur in supported fixtures; retained-route equal-delta translation and nonempty authored attachment cases therefore remain unexercised here. They must not be claimed from the checker implementing that policy. No quality, native workflow, full-router success or production adoption follows from conservation.
+
+Audit development truth: initial local JSON reported one folded mismatch because the Python enum reader omitted unit-string bodies such as `{"Sa":"Function"}`. Inspecting the raw source established that checker defect; it was corrected before final assessment. Original JSON remains preserved, along with the intermediate v2 result. Final rerun additionally checks projected minima and visual-parent identity; all checks pass. No model or research source was edited.
+
+Reproduce with Python only: `python audit-scc-conservation-20260925.py RUN_DIRECTORY NEW_OUTPUT_JSON`. Output creation refuses overwrite. Input strings are explicitly UTF-8; the checker invokes no application binaries.
diff --git a/harness/experiments/scc-placement-20260925/criteria.md b/harness/experiments/scc-placement-20260925/criteria.md
new file mode 100644
index 00000000..b37c2ddf
--- /dev/null
+++ b/harness/experiments/scc-placement-20260925/criteria.md
@@ -0,0 +1,43 @@
+# SCC placement: independent pre-result criteria
+
+2026-09-25. Proposed experiment criteria for issue32, not production acceptance. Read `connection-corridor-sharing-diagnosis-20260925.md` and the previous placement/clearance findings. Research HEAD at inspection is `ae9dad54b749201c988fc398dbbc580db43e746f`. No new candidate source was reviewed for this record; author was asked to signal readiness. No compiler, router, engine or GUI execution.
+
+**Proceed with one bounded SCC-condensation placement experiment, but make the planning graph and its relationship to authored containment explicit.** The observed native prototype interleaves four10-node sparse SCCs across16 ranks; moving to component-aware ordering directly tests that diagnosis. A compact perimeter is a falsifiable packing choice, not a consequence of SCC membership: strongly connected graphs are not generally simple cycles and need not have a crossing-free perimeter drawing.
+
+## Material design risks to settle before results
+
+1. **Do not confuse a hierarchy quotient with the actual connection graph.** At a containment level, mapping endpoints onto child/subtree representatives can introduce a proxy cycle even when underlying leaf connections are acyclic. Conversely, running independent leaf SCCs inside each parent can miss a real cycle crossing two containers. Preserve authored parent relationships; never reparent semantic nodes merely to make an SCC into a box. Record the exact vertices and mapped edges used for each SCC calculation, including planning parent and representative mapping. Call quotient components local placement blocks when appropriate; do not claim they prove global semantic SCC coherence.
+2. **Perimeter order is a separate decision.** A component with ten vertices has many possible circular orders. An alias order or DFS order can recreate long backward edges, crossings and shared outer corridors, even after rank stretching disappears. Freeze a deterministic order before outputs, keep the edge-ID permutation, and disclose which connection information determines internal order. Do not rotate/reverse individual cases after seeing results. Singleton, two-node component and self-loop handling must be explicit; no duplicate placement at a repeated perimeter corner.
+3. **Undirected means no authored direction.** An undirected relation can inform adjacency/proximity, but must not silently acquire a semantic arrow to satisfy the SCC algorithm. If treated as two directed adjacency arcs, state that it intentionally merges connected regions into placement blocks and may hide the directed condensation structure. If excluded from directed rank/SCC formation, keep it in geometry/quality evaluation and describe that weaker influence. A deterministic geometric orientation is another possible policy, but must remain a placement-only preference. Do not repeat the previous workshop omission without reporting unsupported cases.
+4. **Local label gaps still have to cover actual routes.** A gap computed for one rank boundary does not guarantee space for long edges, perimeter return paths or the final Rust label location. Keep the released renderer/router as the observation source. Do not persist computed bends/label overrides or change the cutoffs to improve this comparison. Estimated label bounds remain a planning approximation; actual text and association require later native review.
+
+## Preservation and projection gates
+
+Use original visible placement identities and the actual projected forest, not semantic element IDs alone. Preserve complete authored containment, semantic endpoint/port identity, direction, names, relation data, filters, fold flags, entry order and other views. Freeze reset eligibility from the pre-operation projection; use the existing audited original-to-final import/reset/retained-route translation exactly once. A no-position-change result may still perform the declared route reset and must be reported accordingly.
+
+For a visible collapsed node, retain its compact projected dimensions exactly and preserve stored expanded size. Treat it as opaque for packing. Its promoted visible edges can influence placement without turning promoted owners into actual semantic owners. Hidden descendants follow the importer's nearest visible collapsed ancestor translation; never use local compact coordinates as their expanded geometry or relayout them secretly. Ineligible/folded route metadata remains stored with the existing translation policy, ready for expansion. Unrelated filtered/out-of-projection placements remain governed by the declared import scope. The frozen folded workshop has no nonempty authored-route sentinel: preservation there alone cannot prove suspension/restoration of arbitrary hidden pins.
+
+Expanded containers must contain their final projected children below the appropriate header and above any footer/port-content requirement. Use the core geometry minima for the applicable projection rather than universal64-unit assumptions for all kinds. Growing a container may change relative port tips, port spacing and automatic sides; recompute the actual final projection. Final-size constraint disagreement is a failure, not a reason to overwrite anchors. Check finite positions/sizes, no illegal shrink/overlap, complete projected IDs, and exact intended versus final node geometry.
+
+Authored port anchors and dormant explicit attachments remain exact. Automatic port-side/slot changes are geometric outputs, not automatically conservation failures. Record every change and inspect the final mandatory leads. Repeated projection/packing must not cause side or size oscillation. A lead-incompatibility rejection is useful but necessary-only: final routing must still be checked for NoClearPath, warnings, unrelated node/header penetration and identity-specific collisions.
+
+## Falsifiers on the fixed comparison
+
+Keep all five frozen realistic cases and all nine existing small fixtures. Report unsupported/failed cases separately from outputs; never silently substitute a flattened or unfolded version. Keep the same reset baseline and unchanged released routing, and preserve the old prototype and prior external placements as references. New fixture construction or parameter selection must not be driven by these outputs.
+
+- **Structural diagnosis:** for sparse40, independently recover the four10-node actual SCC memberships and relate them to placement blocks. Report each component's bounding span and its condensation rank interval. A proxy implementation that still interleaves those flat components or spreads a component over unrelated global ranks does not test the proposed remedy correctly. Mixed's six-node SCC and four singletons are a second independent topology check.
+- **Dominant ambiguity:** recompute pairwise interval multiplicity on the final drawing. The sparse y28 trunk contributed38880/40522 and mixed y28 contributed4006/4228. Track the same edge groups wherever they move, as well as the new global worst corridor. Removing occupancy at literal y28 while recreating comparable sharing on another boundary is not success. Report unique corridor length, distinct-edge multiplicity and raw pairwise sharing separately; do not reinterpret a distinct-port trunk as an intentional bus.
+- **Tradeoffs:** report proper/T/bend/endpoint contacts, nonterminal sharing, every new/resolved label/node and label/stroke conflict, route length/bends, drawing bounds and warnings. A compact arrangement that reduces area but increases ambiguous contacts is a tradeoff, not a quality pass. A large area gain bought with unreadable label packing is also a failed hypothesis. No weighted total determines adoption.
+- **Compound capability:** the original/folded workshop must receive an actual declared supported result or explicit refusal. For supported compound cases, independently inspect child/header containment, port/edge promotion and hidden metadata. Passing flat sparse/mixed does not establish this milestone's hierarchy objective. The earlier two-container crossed-child fixture is useful here: check whether block order and child order cooperate rather than simply aligning container centers.
+- **Port/lead compatibility:** preserve fixed-port fixture anchors and original opposing-side meaning; do not solve the task by moving an authored port. Final absence of incompatible leads must be followed by the normal full-route warning/penetration gate. Reject a new hard routing failure even when aggregate sharing decreases.
+- **Repeatability:** same input yields identical Project; ten repeated candidate calls should settle after the first accepted arrangement, with no cumulative size inflation, shifting origin, side oscillation or hidden-coordinate drift. Keep mixed's fixed relation-ID permutation and semantic correspondence. Identical pixels are not required for every graph symmetry, but new failed trace tasks or severe order sensitivity cannot be hidden by selecting favorable IDs.
+
+All14 cases need complete accounting. The small fixtures are explanatory witnesses, not training examples whose success compensates for realistic failures. Bound component recursion, graph/work/span, and any reprojection iterations; unsupported topology and bound exhaustion must discard the private candidate without partial model changes.
+
+## What would justify the next step
+
+A useful result would show that coherent components materially reduce the diagnosed long shared corridors on both sparse and mixed cases, without a new hard route/containment/identity failure, while producing explicit compound results. This would support further initial coordinate-assignment work. It would not yet establish readable engineer traceability or a generally optimal planner.
+
+If actual SCC blocks become compact but long return paths still coincide, inspect internal cycle ordering and available local corridors from that fixed output before proposing another scalar router penalty. If compound quotient cycles or final-port/lead requirements prevent a faithful placement, the failure should revise the planning interface rather than force a proxy result into the Project. Do not increase iteration limits, choose a winning rotation, or add a second packing heuristic after results merely to make this corpus pass.
+
+Before adoption, reuse the predeclared source-to-target and label-association tasks at a common readable scale with ordinary selection/pan/zoom recorded. Include fan-out, distinct ports, cycle return and promoted endpoints. Geometry improvements, even across every frozen case, do not replace that native evidence or production history/source round trips.
diff --git a/harness/experiments/scc-placement-20260925/design.md b/harness/experiments/scc-placement-20260925/design.md
new file mode 100644
index 00000000..13c6d4a1
--- /dev/null
+++ b/harness/experiments/scc-placement-20260925/design.md
@@ -0,0 +1,62 @@
+# Connection corridors: next bounded #32 experiment
+
+Decision after ae9dad54: **test jointly assigned derived separation of existing orthogonal routes on a fixed placement**, before another placement-only spacing algorithm. Keep it an isolated geometry experiment. Do not integrate it into Arrange or change the released router until the named tracing witnesses and preservation checks pass. A small shared-run separator can test an actual missing mechanism; a new set of node gaps cannot ensure that the existing router consumes those gaps.
+
+No external claims, source changes, builds, routing runs or GUI work underpin this note. Sources are the current research routing/projection code, `auto_layout_probe/layered.rs`, and the frozen connection-layout / placement-clearance experiments.
+
+## The decisive limitation
+
+There is no proof that *no* placement-only method can improve shared routing: the mixed ELK placement did improve it through the released router. The stronger assumption that reserving distinct empty corridors in node placement **enforces** distinct routed lanes is false under the present interface. `RoutingSpace::new` uses obstacle boundaries; `fast_path` builds direct/one-axis alternatives; `crossing_cost` only gives coincident spans a soft cost. No placement result carries edge-to-corridor membership into routing. Two connections may still choose the same shorter trunk regardless of how much unused space was reserved elsewhere. The old layered prototype illustrates the practical risk: huge sparse/mixed shared runs despite larger gaps. The clearance repair proves terminal compatibility but sparse sharing666→761 and crossings20→22 prove that compatibility is not lane allocation.
+
+This is not a reason to adopt an entire new engine. It is a reason to test a route-space operation whose output is actually used, rather than interpreting free space as an edge reservation.
+
+## Material options
+
+| Approach | What it can directly control | Unresolved failure / cost | Choice |
+| --- | --- | --- | --- |
+| Initial coordinate assignment with distinct connection corridors | Node order, available width/height and containment; avoids known stub incompatibility. | Without route-to-corridor constraints, released routing may ignore all lane distinctions. Adding such constraints is already a joint placement/routing interface. Global per-edge spacing can explode area. | Necessary later for insufficient corridors; not the next isolated experiment. |
+| Joint derived route separation after an initial route | Actual connection strokes, with fixed tips/stubs and obstacles. Can distinguish coincident nonterminal trunks without moving nodes or changing semantic ports. | Must handle order conflicts, route topology, turns, labels and insufficient clearance; careless nudging creates collisions or touches. | Preferred next bounded diagnostic. Preserve topology and refuse difficult bundles instead of silently forcing them. |
+| Improve rank/order using virtual long-edge vertices | Adjacent-layer crossing order and space occupied by edges skipping ranks; fixes a real limitation of the current prototype's node-only incoming-neighbor means. | Straight-line/layer crossing reduction is not a guarantee about orthogonal trunks chosen by the independent router. Feedback/undirected/compound edges need policy. | Next placement improvement if fixed-route separation establishes that enough useful free space exists; do not present it as a direct shared-run fix. |
+
+## Concrete experimental interface and lifecycle
+
+One example-only function: `separate_routes(project, diagram, final_view, original_routed) -> Result<RoutedView, Diagnostic>`. Borrow the Project and view; return only derived geometry plus explicit moved-bundle/refusal facts. Initially require a flat, unfolded, complete projected scene, all relevant automatic routes free of authored pins, and no existing NoClearPath or unrelated-node penetration. The predeclared input set includes repaired sparse ELK, both mixed ELK orderings, and the small diamond/bipartite witnesses. Keep original routing as the paired control. No node geometry or anchor changes occur during this experiment.
+
+Final automatic ports are already settled by projection. Their tips and full18-unit leads are fixed barriers/anchors for this operation, including shared semantic endpoints. Authored port anchors and explicit endpoint attachments remain exact. Protect common same-owner/same-port leads; do not require physically impossible separation of coincident terminal ink. Distinct ports must not be merged merely because coordinates coincide. Treat any authored pinned route as wholly fixed in the initial scope; defer partial between-pin movement. Preserve its label override. Generated bends must never be written to EdgeRoute.waypoints.
+
+If later integrated, derive it every time `route_diagram` computes geometry from the current Project, not only immediately after Arrange. Otherwise Save/reopen or an unrelated redraw would lose the result. Preview must use the same derivation and respect cached unchanged routes or explicitly invalidate the appropriate bundle; that is an integration requirement, not work needed for the first example experiment. Arrange continues to commit only selected diagram presentation geometry and its existing eligible-route reset in one history transaction. Undo/Redo, other views, dormant/promoted route metadata and original-to-final translations retain their accepted behavior.
+
+## Minimal bounded algorithm to falsify
+
+1. From the frozen routed polylines, find positive shared **nonterminal** spans, grouped by orientation and overlapping longitudinal intervals. Split analysis intervals at segment endpoints; retain edge and original segment identity. No routing weights change and no new search grid is introduced.
+2. For each small bundle, inspect the entire connected orthogonal run/turn chain that would move. Determine available transverse bounds from actual inflated obstacles, protected terminal leads and fixed routes. Assign a consistent edge order from branch attachments on both ends; if the two end orders conflict, mark unsupported rather than concealing an unavoidable crossing through arbitrary UUID ordering. Canonical semantic/placement ties are deterministic, with explicit relation-ID permutation sensitivity retained.
+3. Solve all coordinates in that bundle together: neighboring tracks get a fixed declared separation, original coordinates are preferred, and adjacent perpendicular segments extend/shorten to meet the moved tracks. Do not independently move overlapping subsegments, which would produce broken routes. Any new connector needed near a protected stub is an explicit derived orthogonal dogleg, checked in full. First scope may simply refuse bundles requiring such a connector; record how many target witnesses are thereby unsupported.
+4. Use a fixed small bundle/segment bound and one deterministic pass, followed by complete recomputation of geometric validity. No iterative tweak-until-metric-improves loop. If constraints lack room, either leave that bundle exactly original with an explicit refusal or fail the whole experiment according to the predeclared case protocol; never report it as repaired. Other bundles must not be treated as non-obstacles while solving, and later changes must not invalidate earlier separation.
+5. Recompute automatic label placement on final paths using the same core label placement machinery. An example cannot honestly carry old bounds onto moved paths and call the resulting label metrics final. This is the main small core seam potentially needed beyond the example: factor the existing post-route label settlement phase for reuse, without changing its policy. If parent declines that extraction initially, retain labels as fixed obstacles and label the result geometry-only; it cannot pass label-aware Arrange acceptance.
+
+This is a bounded parallel-segment constraint problem, not a whole orthogonal graph drawing framework. Avoid promoting a speculative reusable solver before one small bundle and one realistic scene demonstrate value. If the smallest useful bundle requires pervasive topology changes, stop and record that limitation; the next candidate is explicit corridor-aware routing coupled to placement, not hundreds of ad hoc bend exceptions.
+
+## Finite evaluation and stop conditions
+
+Use fixed geometry with an analytically separable two-route shared middle span and immutable terminal leads; a shared-port witness must retain its common lead while separating only beyond it. Include a too-narrow corridor (explicit refusal), opposite branch order (refusal or explicitly counted crossing), one fixed pinned route, and one real sparse shared-run bundle. Pair with diamond/bipartite and both mixed relation-ID variants already available. No parameter sweep.
+
+Require exact Project, node geometry, semantic ports and endpoint tips/stubs; every output orthogonal; no new unrelated node/lead penetration, no lost hard pin, no newly introduced improper self-overlap/degenerate backtracking. Compare actual shared-run identities/lengths, proper and T/bend contacts, and label/stroke/label-node collisions after label settlement. The concrete user-facing target is tracing two formerly coincident connections from their branch points without an ambiguous shared middle run. A native trace task is still needed before adoption; an export diagram can provide review evidence but not replace interaction.
+
+Success means at least the declared bundle and one realistic route-tracing witness separate with no new hard violation or label interference and a recorded acceptable path/area cost. A lower total shared length obtained by moving ambiguity to a different pair is failure. Idempotence means applying the separator to its own derived result makes no further change; Save/reopen recomputation from the same Project must match the original derived output. Do not claim full Arrange support: nested ancestor headers, folded promotions, undirected branch ordering and partial authored-pin routing are explicit later gates. Semantic direction is not invented for undirected edges; separator ordering derives from geometry and endpoints, and reversing an undirected edge must not change its physical lane assignment.
+
+Stop after this fixed candidate is compared. If it only works by moving nodes, consumes excessive space, or fails the real witness because free corridors cannot preserve branch order, that is actionable evidence for a combined rank/order + corridor assignment planner. Virtual long-edge vertices then become part of routing constraints shared with coordinate assignment, rather than another placement proxy whose route result is assumed.
+
+
+## Revision after grouped-sharing/SCC diagnosis
+
+**Priority revised: SCC condensation with compact block placement is the justified next experiment; defer the joint separator.** This supersedes the initial next-action recommendation above, while preserving its alternatives and interface warning. New evidence is `connection-corridor-sharing-diagnosis-20260925.md` and its independently reconstructed interval/SCC data. The predeclared implementation contract is `harness/experiments/scc-placement-20260925/plan.md`.
+
+The diagnosis resolves an uncertainty that my initial recommendation left too broad. Sparse has four ten-member SCCs interleaved over16 ranks;38880/40522 shared units (95.95%) occupy the same y28 outside corridor. Mixed has4006/4228 (94.75%) there. These are long stretched feedback/forward routes caused by incoherent component ranking plus aligned row boundaries and globally inflated gaps, not primarily the small local lane collision exhibited by repaired ELK geometry. A joint separator would treat a large structural symptom while retaining avoidable rank spans. Coherent condensation order and compact SCC membership directly change the implicated cause with the released router unchanged.
+
+The frozen plan is a meaningful distinct candidate: SCCs per actual sibling quotient, condensation DAG ranks, compact perimeter for cyclic members, local label gaps, explicit final projection/lead checks and no iterative rescue. It is more appropriate now than virtual long-edge vertices: dummy vertices can improve ordering across coherent ranks but cannot undo an incorrectly split/interleaved SCC rank assignment. Among block rows and a compact perimeter, the predeclared perimeter is a reasonable single hypothesis because it bounds cyclic-member extent and distributes turn opportunities; it is **not** a proven cycle embedding. A strongly connected group need not be one simple cycle, directed DFS successor order need not make every adjacent perimeter pair connected, and chords can still cross or share trunks. Do not describe the perimeter as an optimal cycle layout.
+
+Specific plan risks to retain in evaluation: a minimum30-unit gap only addresses a particular facing-port clearance case, not all final automatic-port choices; nested quotient SCCs are not leaf semantic SCCs; undirected edges must retain direction-free treatment and still be observed for routing quality; fixed anchors can oppose perimeter flow; expanded/folded footprints and local-label estimates must not induce repeated size growth. The plan's explicit final reprojection failure and original-to-final import policy address these as boundaries rather than silently assuming success. Header/enclosure checks and ten-call stability are essential, as declared.
+
+The decisive falsifier is not merely fewer global ranks. Require coherent condensation order, reduced component span and the diagnosed top-corridor contribution, with no new hard geometry violation or comparable ambiguity shifted to another axis/pair. Retain area, labels, contacts and actual named trace tasks. If the perimeter introduces another outside shared loop or rejects a real case because of mandatory leads, preserve that counterexample without parameter tuning. Then select long-edge ordering for rank/order failure, or joint derived separation for a genuinely local residual channel failure.
+
+Nothing here proves placement alone always enforces distinct lanes: that earlier interface limitation remains exact. Nor does the diagnosis prove that a coupled router is necessary. It supplies a narrower, more causal and cheaper first experiment than the initial separator recommendation. No new run or implementation was performed for this revision.
diff --git a/harness/experiments/scc-placement-20260925/diagnosis.md b/harness/experiments/scc-placement-20260925/diagnosis.md
new file mode 100644
index 00000000..c581ba3b
--- /dev/null
+++ b/harness/experiments/scc-placement-20260925/diagnosis.md
@@ -0,0 +1,54 @@
+# Corridor sharing diagnosis
+
+Read-only UTF-8 analysis of frozen `elk-reference-20260925/rust-run03/arrange-corpus/stdout.jsonl` and `placement-clearance-20260925/run02/subsystems_40_sparse-elk/stdout.jsonl`. No engine/router/compiler/native execution. Full source hashes, grouped intervals, edge identities/names/endpoints/sides, largest pairs and independently reconstructed SCC/ranks are in `connection-corridor-sharing-groups-20260925.json` (SHA256 `f9114eaafa22f1d618783b4a62a570d24387645451aafc2123561b53ed16968f`).
+
+## Main finding
+
+**The dominant layered failure is rank stretching plus aligned obstacle-boundary corridors. SCC-aware placement is a more direct first controllable experiment than requiring a joint routing engine.** Routing channel choice contributes, but these records do not show that a coupled router is necessary. They also do not prove that any proposed SCC packing will improve the full metric vector.
+
+Independent sweep: group all positive orthogonal segments by axis and fixed coordinate, split at every endpoint, count distinct edge identities on each atomic interval, and accumulate length × choose(edge count,2). This exactly reproduces all four raw shared-length totals. Edge contribution counts each incident pair once per edge, so summing contributions doubles the total; this is not unique physical ink length.
+
+| Scene | Raw pairwise sharing | Horizontal | Vertical | Common-terminal excluded |
+|---|---:|---:|---:|---:|
+| Sparse layered |40522|39174|1348|0|
+| Mixed layered |4228|4042|186|54|
+| Sparse ELK placement + Rust |666|0|666|0|
+| Sparse clearance repair + Rust |761|0|761|0|
+
+All four scenes are flat: no visual parents or compound-header explanation. Sparse sharing is entirely nonterminal; mixed remains4174 after the54 common-terminal units. Shared endpoint ownership is not itself a common physical terminal: distinct port channels remain distinct connections.
+
+## Sparse: five long routes crowd the same top boundary
+
+At y28 alone, shared pairwise length is38880, 95.95% of40522. This is exactly the top y40 node row minus12 clearance. The dominant interval x1746..3926 has five edges over2180 units, contributing21800 pairwise units. Adjacent x3926..5878 has four edges and contributes11712; x1258..1746 has four and contributes2928. Thus a few continuous outside runs, not thousands of independent intersections, dominate the score.
+
+Five edges on the largest interval:
+
+- `flow_15` Assessment Decode to Validate: source x528,y40 Right → target x5896,y40 Left; total incident sharing17046.
+- `flow_16` Assessment Validate to Enrich: x5896,y40 Left → x40,y220 Right;17890.
+- `flow_41` Communications Decide handoff to Assessment Aggregate: x6384,y40 Left → x40,y428 Right;18676, the maximum contributor.
+- `flow_42` Communications Publish handoff to Assessment Package: x7360,y40 Left → x1016,y220 Right;16590.
+- `flow_46` Assessment Publish handoff to Planning Package: x1504,y40 Right → x3944,y40 Left;8720.
+
+These are distinct semantic ports, not a legitimate shared bus. Both forward long edges and backwards edges use the same corridor. Automatic side selection follows the stretched final geometry; sparse has no authored anchors to explain those choices.
+
+Independent directed reachability finds **four SCCs of10 nodes**, not one40-node SCC. Reproducing the prototype's alias-ordered cycle breaking yields16 global ranks and exactly the observed x positions40,528,…7360 (488 pitch =224 node width +264 global gap). SCC members span ranks0..9,0..12,0..13 and2..15: components are interleaved and stretched rather than treated as compact units. Cycle breaks are Assessment Acquire, Assessment Aggregate, Assessment Enrich and Assessment Package. Source `layered.rs::ranks` breaks the first canonical remaining vertex even if an upstream SCC is still cyclic; later longest-path assignment uses already assigned predecessors. Thus even edges between different SCCs can become long backward connections in the resulting global order.
+
+The global horizontal gap is derived from the maximum estimated edge-label width plus24, rather than local edge needs. It multiplies the cost of long rank spans. Three incoming-neighbour ordering passes only sort existing ranks; they cannot repair rank assignment, and do not introduce virtual vertices for long edges. Source `place` starts each rank at the same top y40, supplying a common outer obstacle boundary. This chain explains the geometry without attributing the entire problem to a routing coefficient.
+
+## Mixed: same mechanism at smaller scale
+
+Mixed has one6-node SCC plus four singletons. The SCC spans ranks1..6; the whole graph uses seven ranks with474 pitch (224+250 global gap). Cycle breaks Actuator, Archive and Correlate include an initially blocked singleton, again showing that canonical cycle breaking is not condensation-DAG ordering.
+
+At y28, three dominant routes contribute4006/4228 (94.75%). Interval x1230..2178 carries `flow_04` Validated observations, `flow_08` Actuator dispatch and `flow_10` Operator acknowledgement:948×3=2844. Another948-unit interval carries dispatch/acknowledgement; the final214 units carry validated observations/acknowledgement. The largest contributor is acknowledgement3212; dispatch2892, validated observations2110. Unlike sparse, Dispatch's Right port is authored, so any future layout must honor that side rather than solving the overlap by changing its anchor.
+
+## ELK and repair are a different, local channel issue
+
+The666→761 increase has no horizontal sharing. Largest unchanged interval is x8517,y938..1030: three edges (`flow_12`,`flow_17`,`flow_38`) contribute276; this is18 units left of target-column x8535. Some terminate on different ports of Communications Package; another targets Assessment Aggregate, so the full interval is not common-terminal reuse.
+
+Exact pairwise delta decomposition: `flow_19/flow_42` gains152; `flow_30/flow_51` loses11; `flow_50/flow_53` loses57; `flow_29/flow_48` gains11. Net95. The new152-unit channel is x4504,y526..678, again18 units left of x4522. This is a side effect of changed placement and derived rerouting after clearance repair, not persistence of the huge layered top trunk.
+
+The released router processes routes sequentially and uses a soft collinear penalty min(overlap×0.12,80) per occupied segment; this is not a global no-sharing allocation rule. That source fact explains why channel reuse remains permitted, but does not establish why every alternative was rejected or that changing the penalty is the right solution. No cost tuning follows from this diagnosis.
+
+## Next falsifiable comparison
+
+Freeze these same input graphs and unchanged released routing. First compare an SCC-condensation ordering with explicit local packing/feedback treatment against the current alias cycle break. Preserve semantic ports/anchors and evaluate actual reprojection, rank span, backwards-edge span, shared interval multiplicities, crossings, labels, area and leads. Failure to reduce the y28 corridor without trading it for comparable hidden contacts/area falsifies the proposed structural benefit. A separate long-edge virtual-vertex ordering experiment is meaningful after ranks are coherent; it cannot by itself repair the present stretched SCC assignment. Local channel allocation can then be evaluated for the residual ELK/repair vertical runs at fixed geometry. Neither stage should be declared necessary or successful before measurement.
diff --git a/harness/experiments/scc-placement-20260925/evidence/manifest.json b/harness/experiments/scc-placement-20260925/evidence/manifest.json
new file mode 100644
index 00000000..ce786f63
--- /dev/null
+++ b/harness/experiments/scc-placement-20260925/evidence/manifest.json
@@ -0,0 +1,851 @@
+{
+  "schema": 1,
+  "source_commit": "2426d286483ab0445663221cd6010a3dadb89a97",
+  "archive": {
+    "file": "scc-placement-2426d286.zip",
+    "bytes": 6041259,
+    "sha256": "fbf40882ed807a1b40db8b3b9b9c846b060db02cbcc60611c18f9620c1fd59c9"
+  },
+  "members": [
+    {
+      "member": "collector/archive-scc-placement-20260925.py",
+      "bytes": 3887,
+      "sha256": "bcf1910bd5110c3c14c5bf4dd612fd65d2c686f8d9a5d45405b58ec7c5b1b486"
+    },
+    {
+      "member": "collector/run-routing-corpus-check-20260925.py",
+      "bytes": 2793,
+      "sha256": "2726a397bd4ecb4dcfff6fc170a66ce2655229079f42335faa2a4bfe4a202f6d"
+    },
+    {
+      "member": "collector/run-scc-placement-20260925.py",
+      "bytes": 3628,
+      "sha256": "40c33c2703768eaa512553322ccc628fbdc3630c2968c4cc8ce127a6c6714757"
+    },
+    {
+      "member": "collector/write-scc-results-20260925.py",
+      "bytes": 9848,
+      "sha256": "ad2ea7ac903f5557c2e5d522d04ea0a589b991ed3ca7c0840ec40d04d42d38ef"
+    },
+    {
+      "member": "gates/18-scc-example-tests/command/changes.patch",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "gates/18-scc-example-tests/command/context.json",
+      "bytes": 3505,
+      "sha256": "a38ff5f35a5578eb37f41bf2b6487634813861025bc3ad4d125251605f223a12"
+    },
+    {
+      "member": "gates/18-scc-example-tests/command/inputs-after.json",
+      "bytes": 1755092,
+      "sha256": "9e23948f6a23224909279ed38c366f45ff472aaf7c3dd94be74b5cd8ea3637e7"
+    },
+    {
+      "member": "gates/18-scc-example-tests/command/inputs-before.json",
+      "bytes": 1755092,
+      "sha256": "9e23948f6a23224909279ed38c366f45ff472aaf7c3dd94be74b5cd8ea3637e7"
+    },
+    {
+      "member": "gates/18-scc-example-tests/command/output.log",
+      "bytes": 440,
+      "sha256": "3510acc240220b72c1269b9b927656cd426fc4d62c975d96d13d50889e245943"
+    },
+    {
+      "member": "gates/18-scc-example-tests/command/result.json",
+      "bytes": 4168,
+      "sha256": "97d627584143e47a0bde6154edaaf403c07d248b60fc47cd3ffe1f6f8bb4f1e4"
+    },
+    {
+      "member": "gates/18-scc-example-tests/command/stderr.log",
+      "bytes": 336,
+      "sha256": "8e11399e5c28b4f0b364568f06d4922bfca59fb7b1dd0c4c73df3f88d60257ad"
+    },
+    {
+      "member": "gates/18-scc-example-tests/environment.json",
+      "bytes": 9466,
+      "sha256": "d9d984528a82c0db3c2e009db91104d7b7c1233921793802bbeb87677f35daf8"
+    },
+    {
+      "member": "gates/18-scc-example-tests/orchestration.log",
+      "bytes": 180,
+      "sha256": "fdad0fe87d49b532b04b2612c3bde4f1a3114e12613189bb91952469bc635825"
+    },
+    {
+      "member": "gates/19-scc-corrected-tests/command/changes.patch",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "gates/19-scc-corrected-tests/command/context.json",
+      "bytes": 3507,
+      "sha256": "6030b5f305c844259023aae178f5cc99ec8d6af4b45582f2e333fc52a4061a00"
+    },
+    {
+      "member": "gates/19-scc-corrected-tests/command/inputs-after.json",
+      "bytes": 1755092,
+      "sha256": "53a042b82d8a6ce79de30e6bc6cfdc71f32e7762a82373ce1315423b5e5eae39"
+    },
+    {
+      "member": "gates/19-scc-corrected-tests/command/inputs-before.json",
+      "bytes": 1755092,
+      "sha256": "53a042b82d8a6ce79de30e6bc6cfdc71f32e7762a82373ce1315423b5e5eae39"
+    },
+    {
+      "member": "gates/19-scc-corrected-tests/command/output.log",
+      "bytes": 536,
+      "sha256": "833b6716dd2533562e8faa1062259da5b4d3ba2ebd89cd67393900b97b4c739c"
+    },
+    {
+      "member": "gates/19-scc-corrected-tests/command/result.json",
+      "bytes": 4174,
+      "sha256": "d6905113e765158dbfb9cbfb4c87f6c8eff7f36337a2e7b2845b5d51ef72ee71"
+    },
+    {
+      "member": "gates/19-scc-corrected-tests/command/stderr.log",
+      "bytes": 336,
+      "sha256": "4c991e05c9de1d64fd1747c686af26eec1f97a27c3626001fd900de70b60fa6b"
+    },
+    {
+      "member": "gates/19-scc-corrected-tests/environment.json",
+      "bytes": 9466,
+      "sha256": "d9d984528a82c0db3c2e009db91104d7b7c1233921793802bbeb87677f35daf8"
+    },
+    {
+      "member": "gates/19-scc-corrected-tests/orchestration.log",
+      "bytes": 182,
+      "sha256": "314d9dd697a24da445f8e4533eb7b14197cdcff58d260b0a667fa9c0b00962b2"
+    },
+    {
+      "member": "gates/20-scc-clippy/command/changes.patch",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "gates/20-scc-clippy/command/context.json",
+      "bytes": 3535,
+      "sha256": "3a999e9dd4d245bc01b9b264273e8525818b4892766deef6527bcdcd26c64e20"
+    },
+    {
+      "member": "gates/20-scc-clippy/command/inputs-after.json",
+      "bytes": 1755092,
+      "sha256": "53a042b82d8a6ce79de30e6bc6cfdc71f32e7762a82373ce1315423b5e5eae39"
+    },
+    {
+      "member": "gates/20-scc-clippy/command/inputs-before.json",
+      "bytes": 1755092,
+      "sha256": "53a042b82d8a6ce79de30e6bc6cfdc71f32e7762a82373ce1315423b5e5eae39"
+    },
+    {
+      "member": "gates/20-scc-clippy/command/output.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "gates/20-scc-clippy/command/result.json",
+      "bytes": 4184,
+      "sha256": "b8aec050f2e1b5074717edede43ff3acfb3f42d251376e54fa116b16c09b47c9"
+    },
+    {
+      "member": "gates/20-scc-clippy/command/stderr.log",
+      "bytes": 830,
+      "sha256": "836381446c6b5aa7b0d0bd4e1321375595cf6f4001390e37c6042a3ae8a8ccbc"
+    },
+    {
+      "member": "gates/20-scc-clippy/environment.json",
+      "bytes": 9466,
+      "sha256": "d9d984528a82c0db3c2e009db91104d7b7c1233921793802bbeb87677f35daf8"
+    },
+    {
+      "member": "gates/20-scc-clippy/orchestration.log",
+      "bytes": 175,
+      "sha256": "82805760283baab8da36de90c204a723f71d90e00eb33d6cab99f58c9e89053c"
+    },
+    {
+      "member": "gates/21-scc-tests/command/changes.patch",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "gates/21-scc-tests/command/context.json",
+      "bytes": 3497,
+      "sha256": "e2ab8c21c637919f4e8d6e2d1ecea96289165bacdc468b8b0dd870977c6193d7"
+    },
+    {
+      "member": "gates/21-scc-tests/command/inputs-after.json",
+      "bytes": 1755092,
+      "sha256": "3c16e04dbe3215742da10626cd465e68cf32ccb7685b2bc5ab084548e70c30cb"
+    },
+    {
+      "member": "gates/21-scc-tests/command/inputs-before.json",
+      "bytes": 1755092,
+      "sha256": "3c16e04dbe3215742da10626cd465e68cf32ccb7685b2bc5ab084548e70c30cb"
+    },
+    {
+      "member": "gates/21-scc-tests/command/output.log",
+      "bytes": 536,
+      "sha256": "833b6716dd2533562e8faa1062259da5b4d3ba2ebd89cd67393900b97b4c739c"
+    },
+    {
+      "member": "gates/21-scc-tests/command/result.json",
+      "bytes": 4144,
+      "sha256": "5611dc41970a0f2ca240a7bd32aa8261851b05026a6df1ad85dcb0ce26735ebd"
+    },
+    {
+      "member": "gates/21-scc-tests/command/stderr.log",
+      "bytes": 336,
+      "sha256": "4eb583fbb1c6eb53b6fd0a17ef6a8faef02c5e5a678459d78ff101dc597db837"
+    },
+    {
+      "member": "gates/21-scc-tests/environment.json",
+      "bytes": 9466,
+      "sha256": "d9d984528a82c0db3c2e009db91104d7b7c1233921793802bbeb87677f35daf8"
+    },
+    {
+      "member": "gates/21-scc-tests/orchestration.log",
+      "bytes": 172,
+      "sha256": "ecfa25a2732e5b5f2c7e9cf457de494dd89c43e8ba64d2caffebef38ef288185"
+    },
+    {
+      "member": "gates/22-scc-clippy/command/changes.patch",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "gates/22-scc-clippy/command/context.json",
+      "bytes": 3535,
+      "sha256": "7641413d4d7712c0a1070e9634cd8b28bcc7f827c225ebda55aac45ce9208da0"
+    },
+    {
+      "member": "gates/22-scc-clippy/command/inputs-after.json",
+      "bytes": 1755092,
+      "sha256": "3c16e04dbe3215742da10626cd465e68cf32ccb7685b2bc5ab084548e70c30cb"
+    },
+    {
+      "member": "gates/22-scc-clippy/command/inputs-before.json",
+      "bytes": 1755092,
+      "sha256": "3c16e04dbe3215742da10626cd465e68cf32ccb7685b2bc5ab084548e70c30cb"
+    },
+    {
+      "member": "gates/22-scc-clippy/command/output.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "gates/22-scc-clippy/command/result.json",
+      "bytes": 4182,
+      "sha256": "39395b4dcf3c66f3e490cd6bb4d2fa8f4ac40ba5ffd46708287f9012cd9b61a9"
+    },
+    {
+      "member": "gates/22-scc-clippy/command/stderr.log",
+      "bytes": 176,
+      "sha256": "7be90bc986d32ae1b1f4bf7e877bbcb73389e60288af76e6af2b6626e8cd2626"
+    },
+    {
+      "member": "gates/22-scc-clippy/environment.json",
+      "bytes": 9466,
+      "sha256": "d9d984528a82c0db3c2e009db91104d7b7c1233921793802bbeb87677f35daf8"
+    },
+    {
+      "member": "gates/22-scc-clippy/orchestration.log",
+      "bytes": 173,
+      "sha256": "3ff1bf85e86dabef766aad475314f4134a0cf663887bb74785ed8373b536b5ae"
+    },
+    {
+      "member": "gates/23-scc-release/command/changes.patch",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "gates/23-scc-release/command/context.json",
+      "bytes": 3524,
+      "sha256": "a7f20125d78395643742fe1157d883f001d1d94e53697ca9c469ddb3340a7531"
+    },
+    {
+      "member": "gates/23-scc-release/command/inputs-after.json",
+      "bytes": 1755092,
+      "sha256": "3c16e04dbe3215742da10626cd465e68cf32ccb7685b2bc5ab084548e70c30cb"
+    },
+    {
+      "member": "gates/23-scc-release/command/inputs-before.json",
+      "bytes": 1755092,
+      "sha256": "3c16e04dbe3215742da10626cd465e68cf32ccb7685b2bc5ab084548e70c30cb"
+    },
+    {
+      "member": "gates/23-scc-release/command/output.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "gates/23-scc-release/command/result.json",
+      "bytes": 4173,
+      "sha256": "3e5adf5bad50cacfdb02b10568d3699531e365380682fd247bc7e43df112b21a"
+    },
+    {
+      "member": "gates/23-scc-release/command/stderr.log",
+      "bytes": 179,
+      "sha256": "cd616b849f5be8e680183b2ec2fee33ca301a0151ddde93fcb2947a512bc287a"
+    },
+    {
+      "member": "gates/23-scc-release/environment.json",
+      "bytes": 9470,
+      "sha256": "1cda80470e5893747b1aad7eda5ef51d57069441e810698cd7f94f7a7521bfe5"
+    },
+    {
+      "member": "gates/23-scc-release/orchestration.log",
+      "bytes": 174,
+      "sha256": "bebcb80f84dc83fa0f718f41203fd3cdf52b70b2c7636fca4d1b432924c89d5f"
+    },
+    {
+      "member": "gates/24-scc-transfer-tests/command/changes.patch",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "gates/24-scc-transfer-tests/command/context.json",
+      "bytes": 3506,
+      "sha256": "de2ae28d115235da55dd61bea562a752d982b27730ea30ebfecaee5aca972ecd"
+    },
+    {
+      "member": "gates/24-scc-transfer-tests/command/inputs-after.json",
+      "bytes": 1755092,
+      "sha256": "67557a240c92ce4b7d9395dccf4d8c783c95012b5ed04b3836e511117c34ae65"
+    },
+    {
+      "member": "gates/24-scc-transfer-tests/command/inputs-before.json",
+      "bytes": 1755092,
+      "sha256": "67557a240c92ce4b7d9395dccf4d8c783c95012b5ed04b3836e511117c34ae65"
+    },
+    {
+      "member": "gates/24-scc-transfer-tests/command/output.log",
+      "bytes": 810,
+      "sha256": "ada006a93f2d7512c1134d58dc3a163f1c3203e05812192ab267143979ba931e"
+    },
+    {
+      "member": "gates/24-scc-transfer-tests/command/result.json",
+      "bytes": 4171,
+      "sha256": "872ae3bfb6f724d53c3b82eb158df3bb402154ae3e8f08283c39b6256f84a915"
+    },
+    {
+      "member": "gates/24-scc-transfer-tests/command/stderr.log",
+      "bytes": 336,
+      "sha256": "f580a0e0f692d052343e2f196ee8b7506c89d0cf423ca1e261cc8388abbeaef6"
+    },
+    {
+      "member": "gates/24-scc-transfer-tests/environment.json",
+      "bytes": 9466,
+      "sha256": "d9d984528a82c0db3c2e009db91104d7b7c1233921793802bbeb87677f35daf8"
+    },
+    {
+      "member": "gates/24-scc-transfer-tests/orchestration.log",
+      "bytes": 181,
+      "sha256": "aa10d2e705dfe95b2a1aa57aaa630e474c98247216d85dc7011173ae2f86c1e8"
+    },
+    {
+      "member": "gates/25-scc-transfer-clippy/command/changes.patch",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "gates/25-scc-transfer-clippy/command/context.json",
+      "bytes": 3544,
+      "sha256": "54ef12b091c100fe7e4dc15eb7f51160a4a30e8f3b716c021921c41acdc7df54"
+    },
+    {
+      "member": "gates/25-scc-transfer-clippy/command/inputs-after.json",
+      "bytes": 1755092,
+      "sha256": "67557a240c92ce4b7d9395dccf4d8c783c95012b5ed04b3836e511117c34ae65"
+    },
+    {
+      "member": "gates/25-scc-transfer-clippy/command/inputs-before.json",
+      "bytes": 1755092,
+      "sha256": "67557a240c92ce4b7d9395dccf4d8c783c95012b5ed04b3836e511117c34ae65"
+    },
+    {
+      "member": "gates/25-scc-transfer-clippy/command/output.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "gates/25-scc-transfer-clippy/command/result.json",
+      "bytes": 4209,
+      "sha256": "7b037ce78415017a21577e32bda7c73b1658e222d53753cc00b53bf2ab74b510"
+    },
+    {
+      "member": "gates/25-scc-transfer-clippy/command/stderr.log",
+      "bytes": 176,
+      "sha256": "ec857d6226e95672a08768dfbd776562e3e9c329f9031c660c407d64edb1f452"
+    },
+    {
+      "member": "gates/25-scc-transfer-clippy/environment.json",
+      "bytes": 9466,
+      "sha256": "d9d984528a82c0db3c2e009db91104d7b7c1233921793802bbeb87677f35daf8"
+    },
+    {
+      "member": "gates/25-scc-transfer-clippy/orchestration.log",
+      "bytes": 182,
+      "sha256": "7fd6a5c356f4640a43faf5c91c01327f995a4d93f93c0a9b508ef6131a03c26d"
+    },
+    {
+      "member": "gates/26-scc-transfer-release/command/changes.patch",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "gates/26-scc-transfer-release/command/context.json",
+      "bytes": 3533,
+      "sha256": "46588f276ededd1c28852659b30af3b13d074421a134106a0b75679f0a50d379"
+    },
+    {
+      "member": "gates/26-scc-transfer-release/command/inputs-after.json",
+      "bytes": 1755092,
+      "sha256": "67557a240c92ce4b7d9395dccf4d8c783c95012b5ed04b3836e511117c34ae65"
+    },
+    {
+      "member": "gates/26-scc-transfer-release/command/inputs-before.json",
+      "bytes": 1755092,
+      "sha256": "67557a240c92ce4b7d9395dccf4d8c783c95012b5ed04b3836e511117c34ae65"
+    },
+    {
+      "member": "gates/26-scc-transfer-release/command/output.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "gates/26-scc-transfer-release/command/result.json",
+      "bytes": 4200,
+      "sha256": "1e531e586f3ee85a502186662fa97cd67119229554edd46ccbc2175d4af36bdc"
+    },
+    {
+      "member": "gates/26-scc-transfer-release/command/stderr.log",
+      "bytes": 179,
+      "sha256": "c09d2543f7352e8fa827be3f41debe0d84b7fec666e8b2d27f3f4d0693a6a07a"
+    },
+    {
+      "member": "gates/26-scc-transfer-release/environment.json",
+      "bytes": 9470,
+      "sha256": "1cda80470e5893747b1aad7eda5ef51d57069441e810698cd7f94f7a7521bfe5"
+    },
+    {
+      "member": "gates/26-scc-transfer-release/orchestration.log",
+      "bytes": 183,
+      "sha256": "39f7e83972586ac72325f0a1a9275c778b92af4e05c412c216c32c108657caca"
+    },
+    {
+      "member": "inputs/corpus/manifest.json",
+      "bytes": 10593,
+      "sha256": "a58a6956e26b414e88fafd4fdb92e006050653a4149178f08df84128e3917717"
+    },
+    {
+      "member": "inputs/corpus/mixed_dispatch.json",
+      "bytes": 32787,
+      "sha256": "81d25af021cbad18af4262a220ba60372e51ca19083b7e80f2b19196baf05990"
+    },
+    {
+      "member": "inputs/corpus/mixed_dispatch_edge_ids_reversed.json",
+      "bytes": 32787,
+      "sha256": "25c95be6b6e7ad9ebcdc83aacc13fbbaa5a56651ba2843f8d1658c075ed789f8"
+    },
+    {
+      "member": "inputs/corpus/subsystems_40_sparse.json",
+      "bytes": 124043,
+      "sha256": "ad0ee7a0ab9c9f3c5f26a6d839f6627a82aa38858a3d5cc1ca87f5a8d795533e"
+    },
+    {
+      "member": "inputs/corpus/workshop_sa_folded.json",
+      "bytes": 102922,
+      "sha256": "ea5fd285d11795e5e543e4144349c32c92a5b328b8c5e2d1be8b75b70703dc97"
+    },
+    {
+      "member": "inputs/corpus/workshop_sa_original.json",
+      "bytes": 102923,
+      "sha256": "cc9b26390594513c11b3d85b768d244b2df8e7bed8cb76c4bdf0dc24db1d2ef6"
+    },
+    {
+      "member": "inputs/prior-arrange-controls.jsonl",
+      "bytes": 1862455,
+      "sha256": "f924af4038ade0de2e0f44988fa28d2566019d8c4bc2bde70e61fe4813364d40"
+    },
+    {
+      "member": "inputs/released-route-control.jsonl",
+      "bytes": 470144,
+      "sha256": "9a31a676f23dea2f41daec39497f569d68231fa0fd66e5a1a476be97d5d61ac2"
+    },
+    {
+      "member": "reviews/audit-scc-conservation-20260925.py",
+      "bytes": 11022,
+      "sha256": "7ebe5726c49c0918a9fbd55f74e16cac484ccec9d13f9cada7a7b36672ff1035"
+    },
+    {
+      "member": "reviews/audit-scc-conservation-v2-20260925.py",
+      "bytes": 14082,
+      "sha256": "66a1621ac04e73bf08637047ed623c7154c0219a3076be7246004e6bf134d4e2"
+    },
+    {
+      "member": "reviews/audit-scc-placement-20260925.py",
+      "bytes": 7233,
+      "sha256": "9990be4df625d3f6e566502c4abd1672fc1a8e0077017ef17b98e8c8dfdaa2f5"
+    },
+    {
+      "member": "reviews/audit-scc-placement-v3-20260925.py",
+      "bytes": 8729,
+      "sha256": "8b238f010eeb81720a59a0ad290544f87934acb8070e58a3fd25f9eda9f47a0d"
+    },
+    {
+      "member": "reviews/connection-corridor-design-20260925.md",
+      "bytes": 14520,
+      "sha256": "02953ef1ae84c83b8c2c7f3b539c6be147ca2ae43f7dd94cf3836ff6f8ee3b30"
+    },
+    {
+      "member": "reviews/connection-corridor-sharing-diagnosis-20260925.md",
+      "bytes": 7467,
+      "sha256": "506bbec69bbe229161547906452fe11fb00a7fa8e46023ed3dcb0e2301f8fecb"
+    },
+    {
+      "member": "reviews/prior-sharing-groups.json",
+      "bytes": 88110,
+      "sha256": "f9114eaafa22f1d618783b4a62a570d24387645451aafc2123561b53ed16968f"
+    },
+    {
+      "member": "reviews/scc-conservation-audit-20260925.json",
+      "bytes": 44150,
+      "sha256": "736d0269bf7cab453abc150a12eece22cb3bc2372c3a3a173638d8aa7a84817e"
+    },
+    {
+      "member": "reviews/scc-conservation-audit-final-20260925.json",
+      "bytes": 46033,
+      "sha256": "c9156b710323d940a712ca8973a2e823a422faf96ad9c509193968ecf2f7fdd9"
+    },
+    {
+      "member": "reviews/scc-conservation-audit-run02-20260925.json",
+      "bytes": 51903,
+      "sha256": "2897af5f3d131e2633a8dc5c9385307516c7c4db227349b374d4d062423a425e"
+    },
+    {
+      "member": "reviews/scc-conservation-audit-v2-20260925.json",
+      "bytes": 44876,
+      "sha256": "fc1a1b0c5a5b9905b54c28f4719fd5ae9c5fcc998939f146523a2296375c9013"
+    },
+    {
+      "member": "reviews/scc-conservation-review-20260925.md",
+      "bytes": 3912,
+      "sha256": "4fa505eb8fdcda3a9225b363cb127755ae241809a7a07212b80a8d52513ac681"
+    },
+    {
+      "member": "reviews/scc-conservation-review-run02-20260925.md",
+      "bytes": 2963,
+      "sha256": "bdcd203edf2ba002d530d6d7e72b7cb2baeec9207b5b4c8de409dfdb5348214b"
+    },
+    {
+      "member": "reviews/scc-failure-diagnosis-20260925.md",
+      "bytes": 8906,
+      "sha256": "7a866902303fb83d14a673e1cede028c5a15517499e8e5f284fced4212f9a536"
+    },
+    {
+      "member": "reviews/scc-placement-criteria-20260925.md",
+      "bytes": 10647,
+      "sha256": "f2872610e5f78e2ccec8b487c2ac873505ecab8ad5f876f741142299fefab993"
+    },
+    {
+      "member": "reviews/scc-placement-implementation-20260925.md",
+      "bytes": 4776,
+      "sha256": "3436bf1cb500a72b4625ecb022b2035f67d08d909e9d5c9249ea676bc25a30cb"
+    },
+    {
+      "member": "reviews/scc-placement-independent-audit-20260925.json",
+      "bytes": 184175,
+      "sha256": "10e53afa7e19cf90cd66524451a2bf4723d98abcca8b1b1c4503d466e19c3df2"
+    },
+    {
+      "member": "reviews/scc-placement-independent-audit-run02-20260925.json",
+      "bytes": 200406,
+      "sha256": "cb1caa9b87a02ec9cdc793360b1d699e646fbe89605cd09dd578fe77440aed39"
+    },
+    {
+      "member": "reviews/scc-placement-independent-audit-v2-20260925.json",
+      "bytes": 193211,
+      "sha256": "519baf9fa49238aaa1e2b61e44b1c0e6b9d420b2ed7dcafe7b489d9e01396682"
+    },
+    {
+      "member": "reviews/scc-placement-result-review-20260925.md",
+      "bytes": 8052,
+      "sha256": "48fbac747679069e0d1d3d713cba6c65cf3d4d3cde220ac8ca939525fd8eec89"
+    },
+    {
+      "member": "reviews/scc-placement-result-review-run02-20260925.md",
+      "bytes": 4300,
+      "sha256": "c07bb1c43f0666f59dd6fecdd63b806ea35e3485db197f9b99caa1ec551f947c"
+    },
+    {
+      "member": "reviews/scc-placement-source-review-20260925.md",
+      "bytes": 10597,
+      "sha256": "24e496c3050b4d5cbbd1abaf2bf4587642cdfc742e245a2f041ba43ed2cce114"
+    },
+    {
+      "member": "reviews/scc-placement-source-review-v2-20260925.md",
+      "bytes": 5402,
+      "sha256": "fb3ac17e52f2c3a6cbfded78d2d72d64b4b15b388f4fdb943d7eb5b28d5d45ca"
+    },
+    {
+      "member": "run01/capture.json",
+      "bytes": 4068,
+      "sha256": "060fbf28e59dc7fceba30b856b1877efab8058381a5ae9363e20129005208015"
+    },
+    {
+      "member": "run01/mixed_dispatch/receipt.json",
+      "bytes": 1102,
+      "sha256": "69721d3e295a9a987da0333840c3ba5355ee0f24669ff071223f48e149e8026d"
+    },
+    {
+      "member": "run01/mixed_dispatch/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run01/mixed_dispatch/stdout.jsonl",
+      "bytes": 93898,
+      "sha256": "28a7f598746f4c0c58afd0321861e417b2715976cde52bf55361dce8c35b4d74"
+    },
+    {
+      "member": "run01/mixed_dispatch_edge_ids_reversed/receipt.json",
+      "bytes": 1173,
+      "sha256": "548fe7ca1e8c40b837de8e0490793f44e42661b28486065161138ae3b5bb6026"
+    },
+    {
+      "member": "run01/mixed_dispatch_edge_ids_reversed/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run01/mixed_dispatch_edge_ids_reversed/stdout.jsonl",
+      "bytes": 93308,
+      "sha256": "6a723a4899026c2df80327fb76c5dda8e5dc5e4e15e9e066991413c2246bade5"
+    },
+    {
+      "member": "run01/receipt.json",
+      "bytes": 15627,
+      "sha256": "f84bc9793636a9bb087d465d2d9bb22b39a3bc6ccae595fc60438db4b0c03f18"
+    },
+    {
+      "member": "run01/route-control/receipt.json",
+      "bytes": 1047,
+      "sha256": "6e744db4c7ceee5f93bfdbf3bfcdf3057443c7dbc42da385356f90239e6e982b"
+    },
+    {
+      "member": "run01/route-control/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run01/route-control/stdout.jsonl",
+      "bytes": 470144,
+      "sha256": "9a31a676f23dea2f41daec39497f569d68231fa0fd66e5a1a476be97d5d61ac2"
+    },
+    {
+      "member": "run01/small-controls/receipt.json",
+      "bytes": 866,
+      "sha256": "4a3b959ea27cefd67989ded74d4b3990236e1261a70ee4b98aead65e33ef4074"
+    },
+    {
+      "member": "run01/small-controls/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run01/small-controls/stdout.jsonl",
+      "bytes": 425661,
+      "sha256": "0ec2bc1f51542b41b5df0b89d2a87306716a49a22951c4dfeb128dd75247d074"
+    },
+    {
+      "member": "run01/small-scc/receipt.json",
+      "bytes": 874,
+      "sha256": "553e8a1840e44f2e14b11d24397b2434e7d6b9d2d14ac5accb8b1a0233d0ebca"
+    },
+    {
+      "member": "run01/small-scc/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run01/small-scc/stdout.jsonl",
+      "bytes": 205873,
+      "sha256": "b35cbe482f8ad23da068da5761bdc61cfb88de3b1fa982f90ce78f5e379c9742"
+    },
+    {
+      "member": "run01/subsystems_40_sparse/receipt.json",
+      "bytes": 1125,
+      "sha256": "7b60517dc2323d9834aa765580c5b6ffadae22f10840d5a7db5c9d58f2108577"
+    },
+    {
+      "member": "run01/subsystems_40_sparse/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run01/subsystems_40_sparse/stdout.jsonl",
+      "bytes": 361147,
+      "sha256": "452690f23dda57f62d115b6d88e42d7f0283b4c86081d5149d8738ba6052e53b"
+    },
+    {
+      "member": "run01/workshop_sa_folded/receipt.json",
+      "bytes": 1118,
+      "sha256": "c03d5851dea753a00884763c1201e742ba1e53bf49e112d27c03ccd58e178cc8"
+    },
+    {
+      "member": "run01/workshop_sa_folded/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run01/workshop_sa_folded/stdout.jsonl",
+      "bytes": 194613,
+      "sha256": "ddf05a2ca36950305090bd5d91ec2a6c617d2eae373c33ad84e9ff4157581c0c"
+    },
+    {
+      "member": "run01/workshop_sa_original/receipt.json",
+      "bytes": 1126,
+      "sha256": "109d91b60376fb5d040bf4502a438a343df438a760e6cdef2d61fdabe40f7edb"
+    },
+    {
+      "member": "run01/workshop_sa_original/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run01/workshop_sa_original/stdout.jsonl",
+      "bytes": 198272,
+      "sha256": "e30a2a6a30d1522cb2f8e9377e7eb8f0a81d1fe8b5aa18550f78c4829b8cc408"
+    },
+    {
+      "member": "run02/capture.json",
+      "bytes": 4086,
+      "sha256": "f077c04496d69ed9b9dcc775cd9dfecd0155938d9a4dc85309d8d7a20e14f18b"
+    },
+    {
+      "member": "run02/mixed_dispatch/receipt.json",
+      "bytes": 1100,
+      "sha256": "15d3cc1d5885e19551dce4de7a49760551c2fd339326dbf3def9f578dd6a10da"
+    },
+    {
+      "member": "run02/mixed_dispatch/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run02/mixed_dispatch/stdout.jsonl",
+      "bytes": 93898,
+      "sha256": "28a7f598746f4c0c58afd0321861e417b2715976cde52bf55361dce8c35b4d74"
+    },
+    {
+      "member": "run02/mixed_dispatch_edge_ids_reversed/receipt.json",
+      "bytes": 1173,
+      "sha256": "04ccd337cc5faff73128a8878b68fa14ccc2df8587daaa20fe0dfd1be244c71e"
+    },
+    {
+      "member": "run02/mixed_dispatch_edge_ids_reversed/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run02/mixed_dispatch_edge_ids_reversed/stdout.jsonl",
+      "bytes": 93308,
+      "sha256": "6a723a4899026c2df80327fb76c5dda8e5dc5e4e15e9e066991413c2246bade5"
+    },
+    {
+      "member": "run02/receipt.json",
+      "bytes": 15643,
+      "sha256": "30e39e35f606d81b280608c8091d8a93b6d3abf474cba98aac530ee438de5129"
+    },
+    {
+      "member": "run02/route-control/receipt.json",
+      "bytes": 1047,
+      "sha256": "6856288ab2bb710040764c08abab12aea3201315749259a8d59942a06dc96549"
+    },
+    {
+      "member": "run02/route-control/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run02/route-control/stdout.jsonl",
+      "bytes": 470144,
+      "sha256": "9a31a676f23dea2f41daec39497f569d68231fa0fd66e5a1a476be97d5d61ac2"
+    },
+    {
+      "member": "run02/small-controls/receipt.json",
+      "bytes": 866,
+      "sha256": "eb8e2c5d6aaaf93c46e03a55329fc1cb412552e83e50cffbc735e835b6b662bd"
+    },
+    {
+      "member": "run02/small-controls/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run02/small-controls/stdout.jsonl",
+      "bytes": 425661,
+      "sha256": "0ec2bc1f51542b41b5df0b89d2a87306716a49a22951c4dfeb128dd75247d074"
+    },
+    {
+      "member": "run02/small-scc/receipt.json",
+      "bytes": 874,
+      "sha256": "129709582dc204fe281f89d4e6a2ff29ba43cb3991d9c5808ecd92e392a9ea3d"
+    },
+    {
+      "member": "run02/small-scc/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run02/small-scc/stdout.jsonl",
+      "bytes": 220188,
+      "sha256": "0c8b9ef7888cd5ba99733f15d22478cdb2878ef02e22d297d02c8b3eea2e9e15"
+    },
+    {
+      "member": "run02/subsystems_40_sparse/receipt.json",
+      "bytes": 1125,
+      "sha256": "4814cc9f9583f1a8994a6cb70b04c4a3fbbbf5d5bb5fa5259bb297e19241cae3"
+    },
+    {
+      "member": "run02/subsystems_40_sparse/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run02/subsystems_40_sparse/stdout.jsonl",
+      "bytes": 361147,
+      "sha256": "452690f23dda57f62d115b6d88e42d7f0283b4c86081d5149d8738ba6052e53b"
+    },
+    {
+      "member": "run02/workshop_sa_folded/receipt.json",
+      "bytes": 1118,
+      "sha256": "b943c33a5ae497a34186fcc5a7e5d0be12164977af254527f56ee96d8719f53f"
+    },
+    {
+      "member": "run02/workshop_sa_folded/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run02/workshop_sa_folded/stdout.jsonl",
+      "bytes": 194613,
+      "sha256": "ddf05a2ca36950305090bd5d91ec2a6c617d2eae373c33ad84e9ff4157581c0c"
+    },
+    {
+      "member": "run02/workshop_sa_original/receipt.json",
+      "bytes": 1126,
+      "sha256": "651545fe8696abb0b1ef33b606e619e3248c977c525387f1de7b89dd4353b82d"
+    },
+    {
+      "member": "run02/workshop_sa_original/stderr.log",
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "member": "run02/workshop_sa_original/stdout.jsonl",
+      "bytes": 198272,
+      "sha256": "e30a2a6a30d1522cb2f8e9377e7eb8f0a81d1fe8b5aa18550f78c4829b8cc408"
+    }
+  ]
+}
diff --git a/harness/experiments/scc-placement-20260925/evidence/scc-placement-2426d286.zip b/harness/experiments/scc-placement-20260925/evidence/scc-placement-2426d286.zip
new file mode 100644
index 00000000..cb175f18
Binary files /dev/null and b/harness/experiments/scc-placement-20260925/evidence/scc-placement-2426d286.zip differ
diff --git a/harness/experiments/scc-placement-20260925/final-review.md b/harness/experiments/scc-placement-20260925/final-review.md
new file mode 100644
index 00000000..bb773815
--- /dev/null
+++ b/harness/experiments/scc-placement-20260925/final-review.md
@@ -0,0 +1,23 @@
+# SCC checkpoint final claim and archive review
+
+Reviewed the current results.md and immutable evidence archive for tested source `2426d286483ab0445663221cd6010a3dadb89a97`. Verdict: **no blocking finding for this experimental checkpoint**. This is evidence/claim acceptance, not production Arrange or native usability acceptance.
+
+## Verified facts
+
+- Independently opened the ZIP and checked every member against manifest bytes and SHA256, exact membership and uniqueness, plus ZIP CRC readback (`testzip`). All 168 members pass. Archive: 6,041,259 bytes; SHA256 `fbf40882ed807a1b40db8b3b9b9c846b060db02cbcc60611c18f9620c1fd59c9`.
+- Both run receipts bind unchanged before/after inputs, correct source pins, eight successful bounded children with no timeout, and exact captured stdout/stderr sizes/hashes. Both route-control byte streams hash to `9a31a676f23dea2f41daec39497f569d68231fa0fd66e5a1a476be97d5d61ac2`.
+- Independently matched **all 14** complete results-table rows against archived Arrange-reset controls and final candidate metrics, including crossings, raw shared length, all three label counts and rounded area ratios. The bipartite, folded, workshop and two-container regressions are disclosed, not hidden behind sparse-case gains.
+- Compared all raw input Projects across runs: unchanged. All 13 previously supported complete candidate objects remain exactly equal. The original two-container `Final Rust projection differs from intended node geometry` rejection is retained; run02 supports that case. All 14 emitted repeat and JSON/source roundtrip checks pass. These emitted checks are correctly distinguished from independently retained repeated full Projects, which are not serialized.
+- Gate receipts/logs support source 2426d286's 8 example tests, strict Clippy and optimized build (24–26); source 4dd764fa's 5 tests/Clippy/build (21–23); earlier packing tests; and the retained gate20 exit101 `needless_range_loop` failure. All gate input inventories report unchanged. No whole-workspace claim is made.
+
+## Interpretation and limits
+
+The transfer explanation agrees with the source review and independently derived run01 failure: preserve unchanged effective expanded minima only for qualifying position-exact, noncollapsed nodes that would otherwise shrink, then require one exact final projection. This restores the intended 308×446 parents without changing SCC packing/order/gaps. The unchanged 13 candidate objects strengthen this attribution; the newly supported two-container result still has 164 sharing and one label/node collision, so the correction is not presented as a quality improvement.
+
+The quality verdict is proportionate. Sparse coherent SCCs remove the dominant shared corridor, while residual label conflicts, folded retrace, relation-ID-dependent routing and area costs remain. The evidence supports keeping the structural hypothesis and conducting a bounded next experiment; it does not establish engineer traceability, general lane separation, glyph readability or product acceptance. Proposed external-neighbor sibling ordering should preserve the SCC witness and the fixed full-corpus comparison; its benefit remains unverified.
+
+Archive contents include both runs, failed gates, frozen five-case inputs, controls, scripts and independent reviews. Source is identified by commit; binaries are intentionally excluded but their capture hashes remain. Repository-relative build/CLI examples are suitable reproduction entry points after obtaining that source and locked dependencies. Archived supervisor scripts/receipts retain machine-local paths and Windows environment assumptions: they are provenance, not an automatically portable runner. Short observed runtimes are not performance guarantees; the work counter is weighted. Linux, native workflows, command/history integration, dormant-route translation and State-header coverage remain explicitly outside this checkpoint.
+
+Minor optional wording: “failed flat lead-clearance repair” could read “flat lead-clearance repair rejected on readability grounds”; that earlier repair did remove the targeted lead incompatibility. The surrounding linked results and current non-adoption verdict make this nonblocking.
+
+Review method: read-only archive/JSON/log/source-review inspection and offline comparisons. No compiler, router, GUI or test process rerun. No source/archive changes. Publication remains unconfirmed until parent obtains Gitea success and readback.
\ No newline at end of file
diff --git a/harness/experiments/scc-placement-20260925/implementation.md b/harness/experiments/scc-placement-20260925/implementation.md
new file mode 100644
index 00000000..14eac3fc
--- /dev/null
+++ b/harness/experiments/scc-placement-20260925/implementation.md
@@ -0,0 +1,34 @@
+# SCC-block placement prototype
+
+Research-only `examples/auto_layout_probe/condensed.rs`. APIs `candidate(&Project, Id)` and `candidate_with_diagnostics(&Project, Id)`; the latter returns `(Project, serde_json::Value)`. No compiler, formatter, engine or GUI run by implementation agent. Parent owns integration and execution.
+
+The implementation freezes actual projected node minima and visual-parent forest. It rejects Scenario and graphs over256stored nodes/1024visible edges. Folded placements are opaque projected leaves; the authoritative parent import preserves their stored expanded size and moves hidden descendants. No semantic parents, edge direction, port anchors or route fields are directly edited by the module.
+
+Process sibling groups bottom-up. Lift each visible endpoint to its immediate child subtree; form directed arcs only from directed edges. Bounded reachability computes exact SCCs of that **quotient graph**, which need not equal global semantic SCCs. Condensation longest-path ranks cannot interleave a component's members. Undirected links influence local spacing and deterministic same-rank proximity, never rank direction. Canonical alias/placement-ID order breaks ties, independent of edge IDs. Within each SCC, deterministic directed DFS successor walk chooses clockwise perimeter order.
+
+For a multi-node SCC, enumerate finite integer perimeter grids with enough slots. Use maximum member dimensions and local internal edge-label gaps; select minimum bounding area among physical aspect ratios≤2, then area/rows/columns ties. If no such grid exists within the bounded enumeration, select closest aspect, then area/rows/columns. This near-square restriction was approved before execution; unconstrained area minimization would produce a strip. Singletons retain their size. Fixed one-pass prior-neighbour ordering plus a canonical same-rank adjacency walk affects component proximity without changing ranks.
+
+Component and rank-cut gaps use relevant core-estimated label bounds plus32, minimum32, rather than one diagram-wide maximum. Each compound encloses its child layout with32horizontal/bottom padding and actual State header (otherwise64) plus32top separation, taking maxima against frozen projected minima. Absolute positions are accumulated through the visual forest at root origin40,40. Work cap20000000charged units, extent100000; no quality-score iteration or clearance repair loop.
+
+Exactly one parent `import_placement` call applies final positions/sizes and authoritative original-to-final route/reset/hidden translation policy. Its final reprojection gate rejects automatic-capacity or container-size divergence rather than repairing indefinitely. The actual final lead diagnostic rejects incompatible mandatory leads explicitly; an empty diagnostic is necessary only, not full-route or readability acceptance. Diagnostics expose parent groups, SCC membership/DFS walk/rank/grid/gap, lifted directed and undirected pairs, component offsets/envelopes and work usage.
+
+Two pure tests cover SCC separation across a one-way bridge and unique nonoverlapping ten-node perimeter slots. They are unexecuted. Repeat stability and meaningful preservation/geometry tests remain parent's run gates. Large local labels may still produce oversized SCCs; quotient cycles and cross-container semantic cycles are heuristic limitations, not equivalent semantic SCC claims. Routing used to obtain label bounds is bounded by existing core machinery but is not included in the prototype's own charged-loop count; this is not a runtime latency guarantee.
+
+## Parent integration addendum
+
+The preceding text is the implementation handoff before execution. Source
+ea18adc0 corrects perimeter scoring to use occupied cells, includes single-row
+and single-column candidates, and adds a two-node witness. It scores maximum
+member-cell envelopes, not an exact aspect guarantee for heterogeneous nodes.
+Source4dd764fa fixes a Clippy row-iteration warning; five example tests, strict
+Clippy and the release build pass. Run01 supports13 of14 frozen cases.
+
+Source2426d286 changes only the shared example importer and its tests, not SCC
+placement. One bounded conditional restoration preserves intended unchanged
+effective container minima after children move inward. Three regression tests
+cover that failure, expanded/folded identity and inconsistent-plan rejection.
+All eight example tests, strict Clippy and optimized build pass. Run02 supports
+all14 cases and leaves all13 prior successful candidate objects exactly equal.
+Independent quality reviews still reject production adoption. See the final
+results, transfer diagnosis, source review v2 and run02 reviews for the complete
+evidence and limitations; the early unexecuted status above is historical.
diff --git a/harness/experiments/scc-placement-20260925/result-review-run02.md b/harness/experiments/scc-placement-20260925/result-review-run02.md
new file mode 100644
index 00000000..911e008e
--- /dev/null
+++ b/harness/experiments/scc-placement-20260925/result-review-run02.md
@@ -0,0 +1,40 @@
+# Independent SCC run02 review
+
+Source2426d286; primary `scc-placement-20260925/run02`. Read-only audit using `audit-scc-placement-v3-20260925.py ROOT OUTPUT --previous RUN01`. No compiler, router, native or engine run. Original run01 reviews and both audit JSONs remain unchanged.
+
+**The importer correction restores the previously rejected compound case without changing any of the13 prior successful candidate outputs. All14 cases now return results; this remains an experimental candidate, not an accepted Arrange replacement.**
+
+## Exact regression and integrity checks
+
+Verified root receipt/capture/build and every child source pin agree, bound inputs before/after are identical and their file hashes still match, all eight children exit0 without timeout, all stdout/stderr hashes match, and released-router control bytes remain exact. Compared run02 input Projects to run01 for all14 cases without tolerance. For each of the13 prior successes, the **entire candidate object** is exactly equal, including complete Project, full metrics/geometry, diagnostic plan, roundtrips, repeat results and lead report. The new source did not silently change those results or their prior limitations.
+
+Independent SCC/condensation and grouped-sharing audits pass across all14 supported cases. Every emitted raw pairwise segment-sharing total is independently reproduced. The folded physical-sharing/raw-multiplicity distinction and six-unit retrace from run01 remain unchanged. All14 recorded same-input checks, nine subsequent candidate calls and both roundtrips are exact. Parent separately owns complete Project conservation against the allowed import/reset transformation; exact prior-candidate equality is not a substitute for that broader check.
+
+## Newly admitted two-container result
+
+`two_containers_reversed_children` previously rejected final projection mismatch. It now returns two308×446 parent boxes, with child SCCs all singleton rank0 and parent condensation ranks0→1; independently reconstructed membership/order agrees. Necessary lead report and warnings are empty, with zero unrelated node penetration or node overlap.
+
+| Metric | Original input | Arrange/reset | Old layered | SCC run02 |
+| --- | ---: | ---: | ---: | ---: |
+| Proper crossings |0|0|0|0|
+| Point contacts |2|2|0|2|
+| Raw shared length |200|148|0|164|
+| Label/node collisions |0|1|0|1|
+| Label/label collisions |0|0|0|0|
+| Label/stroke intersections |0|0|0|0|
+| Route length |1512|872|372|788|
+| Drawing area |485248|288512|272800|339852|
+
+The entire164-unit sharing is vertical at x508; independent interval sweep agrees exactly. The importer fix makes geometry admissible, but it does not solve this fixture's child-order tracing problem. Old layered remains materially better on the displayed quality vector. Relative to reset, SCC shortens paths but worsens sharing and area while retaining the label/node collision. Do not present14 successful executions as14 improvements.
+
+## Decision
+
+Run01's strong sparse SCC compression evidence remains exact, as do workshop label regressions, bipartite sharing regression, relation-ID sensitivity and folded backtracking. The narrow projection-size correction is supported by the unchanged13 outcomes and newly admitted fourteenth geometry; it does not justify changing the quality verdict.
+
+Stop this candidate as predeclared. The newly visible nested result points to cross-boundary child ordering as a concrete next witness: preserve coherent SCC ranks while determining sibling order using external neighbors, rather than returning to arbitrary alias ties or adding global gaps. Any follow-up must preserve the exact sparse improvement and existing semantic/reset/port constraints, and compare against the old layered fixture's zero-sharing witness. No parameter sweep, native readability, production integration or release acceptance is claimed.
+
+- .local\audit-scc-placement-v3-20260925.py: SHA256 8b238f010eeb81720a59a0ad290544f87934acb8070e58a3fd25f9eda9f47a0d.
+
+- .local\scc-placement-independent-audit-run02-20260925.json: SHA256 cb1caa9b87a02ec9cdc793360b1d699e646fbe89605cd09dd578fe77440aed39.
+
+- .local\scc-placement-20260925\run02\receipt.json: SHA256 30e39e35f606d81b280608c8091d8a93b6d3abf474cba98aac530ee438de5129.
diff --git a/harness/experiments/scc-placement-20260925/result-review.md b/harness/experiments/scc-placement-20260925/result-review.md
new file mode 100644
index 00000000..dba0612e
--- /dev/null
+++ b/harness/experiments/scc-placement-20260925/result-review.md
@@ -0,0 +1,68 @@
+# Independent SCC placement result review
+
+Source4dd764fa, primary run `scc-placement-20260925/run01`. Read-only recorded-result audit; no compiler, router, native or engine execution. **The structural hypothesis succeeds strongly on sparse40, but this candidate is not adoptable.** One compound case is rejected, several successful cases regress labels/sharing or area, and no native tracing acceptance exists.
+
+## Admission and independent scope
+
+Verified all bound input hashes against receipt, before/after binding equality, eight child exits0/not timed out, recorded stdout/stderr hashes, and exact released-router-control bytes. All14 candidate cases are accounted for:13 supported, one explicit failure. Parent separately owns full Project conservation; this review does not substitute geometric metrics for that check.
+
+The standalone script reconstructs sibling-quotient directed edges from original projected nodes/edges, computes mutual reachability independently, verifies every reported SCC membership and condensation rank ordering, and measures final component extents. These checks pass for all13 supported cases. It also checks each perimeter walk contains exactly the component membership once. It does not claim that DFS order is an optimal cycle traversal.
+
+Independent grouped collinear sweeps cover all available original/reset/old-layered/candidate scenes. Each sweep splits segments at interval endpoints and retains both distinct-edge physical sharing and raw segment-pair multiplicity. Raw multiplicity agrees with all emitted shared-length totals within0.001. Initial edge-deduplicated comparison exposed a folded route retrace, explained below; both definitions and the initial output are preserved. Candidate repeat-input equality, nine subsequent calls and both roundtrips report exact equality for all13 successes; no independently rerun semantic/history test is claimed.
+
+## Complete outcomes
+
+Sharing columns are reset / old layered / SCC, raw pairwise segment units.
+
+| Case | Sharing | Result |
+| --- | --- | --- |
+| flat_chain_4 |0 /0 /0|Successful, fewer area units than reset, no recorded collision/warning.|
+| chain_7_row_wrap |0 /0 /0|Successful; area523584→278256.|
+| diamond |36 /82 /36|Restores reset sharing; no crossing.|
+| crossed_bipartite |276 /344 /368|Worse sharing than both controls despite smaller area; no crossing.|
+| nested_cross_boundary |0 /0 /0|Label/node1→0, area284096→455366.|
+| authored_detour_and_label |0 /0 /0|Successful; reset semantics audited separately by parent.|
+| fixed_ports |0 /0 /0|Successful, smaller area; anchor conservation separate.|
+| two_containers_reversed_children |control retained /old retained /failed|Explicit “Final Rust projection differs from intended node geometry”; no candidate metrics or success inferred.|
+| long_ordinary_labels |36 /36 /36|Label/node2→0, modest area growth.|
+| workshop_sa_original |1832 /1467 /344|Sharing/contact gains; label/node1→3, label/stroke0→1, large area growth.|
+| workshop_sa_folded |1194 /unsupported /726.5|New supported scope, but crossings7→8, contacts19→28, label/node0→3 and label/stroke0→2; four promoted warnings retained.|
+| mixed_dispatch |716.4 /4228 /516.6|Crossings10→7, contacts25→16, no label collisions, larger area.|
+| mixed reversed IDs |512.4 /4228 /462.6|Crossings9→6, contacts26→15; differs from corresponding unpermuted result.|
+| sparse40 |1990 /40522 /32|Strong structural improvement; residual label/label1 and label/stroke3 remain.|
+
+All successful cases report zero unrelated node penetration and zero unrelated node collision. Necessary lead reports are empty. These emitted facts are not claims of complete glyph or arrowhead clearance.
+
+## Structural causal witness
+
+Sparse independently has four ten-node SCCs; each now occupies720×1024 with a5-row/2-column perimeter. Condensation ranks are0,1,2,3 and every intercomponent arc respects increasing rank. Old members sprawled/interleaved across16 ranks. The old y28 top corridor contributed38880 units; the new result has no horizontal shared interval at all. Its entire32-unit sharing is one vertical group at x1510. Thus this result directly supports the diagnosed rank/SCC-locality cause, without any router cost change or lane allocator.
+
+Sparse full vector versus reset: proper crossings94→15, contacts158→19, sharing1990→32, label/node14→0, label/stroke31→3, route length39660→18784; area3804920→4001536 (about5.2% larger). Label/label remains1. Compared with old native, crossings17→15 and sharing40522→32 with substantially less area. This is compelling experimental evidence for coherent SCC placement, not proof of universally separated lanes.
+
+Mixed's six-node SCC occupies706×564 in3×2, with singleton condensation ranks around it. Its previous4006-unit y28 sharing vanishes; remaining sharing is local, largest216 vertical at x709. However its area rises1139880→1667490, and ID-permuted routing differs (sharing462.6 versus516.6, crossings6 versus7). The output therefore cannot be described as invariant to relation-ID permutation. Route length is7349.6 in both, versus10618.6 reset.
+
+## Folded retrace: definitions matter
+
+Folded SCC's emitted726.5 shared units are correct under the observer's raw segment-pair definition. Deduplicating edge occupancy per interval yields708.5. Promoted edge `a15f7dfd-ac0b-562a-a633-fadc9fb64176` follows:
+
+(747,1052)→(747,1034)→(324,1034)→(324,106)→(330,106)→(312,106).
+
+Its last two horizontal segments retrace x324..330, length6. Other edge overlaps count that span twice in the raw segment-pair sum, explaining the18-unit excess. Independent existing pairwise-segment evaluator also gives726.5. This is not an arithmetic bug; it is both a metric-definition distinction and a real derived backtracking witness relevant to tracing. No silent deduplication should erase it.
+
+## Next distinct action and stopping point
+
+Stop this frozen candidate as planned. Retain coherent SCC condensation as the supported structural direction. First diagnose the rejected two-container final-projection mismatch and align planned container/port-capacity geometry with the authoritative projection; do not weaken the equality check or flatten the hierarchy to gain a successful row. This is a concrete integration-contract failure, not a reason to sweep perimeter dimensions.
+
+After that narrow mismatch is resolved, the next quality experiment should target local label/connection corridor placement or ordering on the actual residual witnesses, not global gaps or router penalty changes. Sparse's huge outside trunk is gone; workshop label interference, folded backtracking and bipartite local sharing are different problems. Virtual long-edge ordering is not justified merely by this successful SCC compression; use it only if a residual crossing witness actually involves rank-spanning order. A derived separation pass remains a candidate for fixed-geometry local sharing, with the previously stated stub/label/pin lifecycle constraints.
+
+No production/native acceptance follows from this record. Header/label legibility, overview/navigation cost, selected workflow tracing, production command/history integration and full Project conservation remain separate checks. No additional candidate run or tuning was performed.
+
+- .local\audit-scc-placement-20260925.py: SHA256 9990be4df625d3f6e566502c4abd1672fc1a8e0077017ef17b98e8c8dfdaa2f5.
+
+- .local\scc-placement-independent-audit-20260925.json: SHA256 10e53afa7e19cf90cd66524451a2bf4723d98abcca8b1b1c4503d466e19c3df2.
+
+- .local\scc-placement-independent-audit-v2-20260925.json: SHA256 519baf9fa49238aaa1e2b61e44b1c0e6b9d420b2ed7dcafe7b489d9e01396682.
+
+- .local\scc-placement-20260925\run01\receipt.json: SHA256 f84bc9793636a9bb087d465d2d9bb22b39a3bc6ccae595fc60438db4b0c03f18.
+
+- .local\elk-reference-20260925\rust-run03\arrange-corpus\stdout.jsonl: SHA256 f924af4038ade0de2e0f44988fa28d2566019d8c4bc2bde70e61fe4813364d40.
diff --git a/harness/experiments/scc-placement-20260925/results.md b/harness/experiments/scc-placement-20260925/results.md
new file mode 100644
index 00000000..ba2ab2d7
--- /dev/null
+++ b/harness/experiments/scc-placement-20260925/results.md
@@ -0,0 +1,155 @@
+# Coherent cyclic-group placement result
+
+Branch-specific issue32 experiment. **SCC condensation and compact cyclic groups
+remove the dominant shared outside corridor, but this is not ready for production
+Arrange.** The corrected transfer supports all 14 frozen cases, preserves the
+declared model/geometry contract and is stable across ten calls. Local label
+conflicts, folded-route backtracking, bipartite sharing and area costs remain.
+No native tracing, command/history integration or release acceptance is claimed.
+
+Independent evidence: [corrected source review](source-review-v2.md),
+[run02 quality review](result-review-run02.md),
+[run02 conservation review](conservation-review-run02.md), and
+[transfer and label-conflict diagnosis](transfer-diagnosis.md).
+
+Tested source: `2426d286483ab0445663221cd6010a3dadb89a97`. Run01 at
+`4dd764fa6cfc6920350383e523ba5a597412ddf4` is retained, including its rejected
+two-container case. Read the [predeclared plan](plan.md), [diagnosis](diagnosis.md)
+and [design alternatives](design.md) for why this structural experiment followed
+the flat lead-clearance repair rejected on readability grounds. Production routing is unchanged.
+
+## What the structural witness establishes
+
+Sparse 40 has four SCCs of ten nodes. Independent graph reconstruction confirms
+four coherent 720×1024 blocks in condensation ranks 0–3, replacing the old
+alias-cycle-break layout's interleaving across 16 ranks. The old prototype's y28
+outside corridor contributed 38880 shared units; the new geometry has no
+horizontal shared interval. Total raw pairwise sharing falls 40522→32 compared
+with that old prototype, crossings 17→15, area 6020910→4001536. The remaining 32
+units are one local vertical group. This improvement required no router penalty
+or gap sweep and does not establish general lane separation.
+
+Against current Arrange plus eligible-route reset, sparse crossings 94→15,
+contacts 158→19, sharing 1990→32, label/node 14→0, label/stroke 31→3 and route
+length 39660→18784. Area grows about 5.2%; label/label remains 1. Against the
+original authored input, area and route length grow, so it is not a universal
+improvement over every control. All controls remain in the raw evidence.
+
+## Complete quality comparison
+
+Each arrow compares the current Arrange-reset control with the SCC candidate.
+Labels are node / other-label / unrelated-stroke collision counts. Area is
+candidate/control. Sharing is raw segment-pair length, not unique physical ink.
+
+|Case|Proper crossings|Shared length|Labels N/L/S|Area ratio|
+|---|---:|---:|---:|---:|
+|flat_chain_4|0→0|0→0|0/0/0→0/0/0|0.72×|
+|chain_7_row_wrap|0→0|0→0|0/0/0→0/0/0|0.53×|
+|diamond|0→0|36→36|0/0/0→0/0/0|0.91×|
+|crossed_bipartite|0→0|276→368|0/0/0→0/0/0|0.57×|
+|nested_cross_boundary|0→0|0→0|1/0/0→0/0/0|1.60×|
+|authored_detour_and_label|0→0|0→0|0/0/0→0/0/0|0.93×|
+|fixed_ports|0→0|0→0|0/0/0→0/0/0|0.94×|
+|two_containers_reversed_children|0→0|148→164|1/0/0→1/0/0|1.18×|
+|long_ordinary_labels|0→0|36→36|2/0/0→0/0/0|1.06×|
+|workshop_sa_original|6→6|1832→344|1/0/0→3/0/1|1.81×|
+|workshop_sa_folded|7→8|1194→726.5|0/0/0→3/0/2|1.35×|
+|mixed_dispatch|10→7|716.4→516.6|0/0/0→0/0/0|1.46×|
+|mixed_dispatch_edge_ids_reversed|9→6|512.4→462.6|0/0/0→0/0/0|1.40×|
+|subsystems_40_sparse|94→15|1990→32|14/1/31→0/1/3|1.05×|
+
+All 14 successful cases report zero unrelated node penetration, zero unrelated
+node collision and no incompatible mandatory leads. Four folded-workshop
+PromotedEndpoints warnings remain; no NoClearPath is reported. Those checks do
+not establish arrowhead clearance, native glyph readability or usability.
+
+Mixed's fixed relation-ID permutation leaves projected node/port geometry and
+the SCC plan exactly equal, while final routes differ: crossings 7 versus 6 and
+sharing 516.6 versus 462.6. The placement is stable under this permutation; the
+whole routed drawing is not. Mixed area grows despite shorter routes.
+
+The folded raw shared total 726.5 includes a promoted route that retraces 6 units.
+Distinct-edge occupancy counts 708.5: the 18-unit difference is raw segment-pair
+multiplicity, independently reconciled rather than silently discarded.
+The remaining sparse label/label pair and three label/stroke pairs have no
+positive shared route interval; one pair has no route point contact at all.
+Thus label association needs its own treatment after structural placement.
+See the independent reviews and failure diagnosis in the evidence archive.
+
+## Correctness repair and preservation
+
+Run01 rejected the two-container fixture because parents intended to retain
+their old 308×446 effective dimensions instead shrank to 280×416 after children
+moved inward. The importer preserved authored 224×94 sizes under an overly broad
+identity shortcut. Source 2426d286 restores intended unchanged effective minima
+only for noncollapsed nodes whose first final position is exact and whose
+dimensions are smaller/equal. It rejects every other mismatch before making
+all qualified writes simultaneously, then validates and requires one exact
+second projection. There is no iteration or change to SCC ordering/gaps/packing.
+
+The original13 successful candidate Projects, metrics and plans are exactly
+unchanged in run02. The new two-container result confirms both intended 308×446
+parent minima and all source-derived planned positions. All 14 report exact
+same-input output, nine subsequent calls equal to first/previous, and exact
+JSON and textual-source roundtrips. Repeated Projects/source strings are not
+serialized, so independent audits distinguish emitted Rust checks from their
+own raw structural comparisons.
+
+Independent audits reconstruct complete expected Projects with only declared
+positions, required sizes and eligible-route resets changed. Semantic records,
+authored anchors, route identities/order, other diagrams and hidden metadata
+remain exact. Three latent folded descendants move (-680,0) with their collapsed
+owner. Current fixtures do not exercise surviving dormant authored-route
+translations or State-specific headers; no such coverage is claimed. Exact
+intended plan nodes are not emitted, so final transfer equality remains a source
+gate supplemented by independent final enclosures and the reconstructed failure
+witness. No history/Undo/Redo test applies to these example-only imports.
+
+## Verification and reproduction
+
+Windows Rust 1.98.1 gnullvm and LLVM-mingw 20260908, locked offline dependencies,
+one build job. Source 2426d286 passes 8 example tests, strict example Clippy and an
+optimized build (gates 24–26). Earlier source 4dd764fa passes 5 example tests,
+Clippy and build (gates 21–23). Gate 20's needless-range-loop Clippy failure and
+earlier packing tests are retained, with their exact source pins. Core code is
+unchanged from the previously verified lead diagnostic; this is not a new
+whole-workspace suite claim.
+
+```
+cargo test --locked --offline -p oa-core --example auto_layout_probe
+cargo clippy --locked --offline -p oa-core --example auto_layout_probe -- -D warnings
+cargo build --release --locked --offline -p oa-core --example auto_layout_probe
+auto_layout_probe --scc-fixtures
+auto_layout_probe --scc-placement PROJECT_JSON DIAGRAM_UUID
+auto_layout_probe --route-corpus MANIFEST
+```
+
+Both runs capture the built executable before further compiler writes, verify
+source/binary/input hashes, and complete eight bounded child processes. The
+five-case released route-control output is byte-identical in both runs, SHA256
+`9a31a676f23dea2f41daec39497f569d68231fa0fd66e5a1a476be97d5d61ac2`.
+Output process success is separate from per-case support. No latency guarantee
+is inferred from these short corpus runs. The planner work counter is weighted,
+not an exact instruction or elapsed-time bound.
+
+## Decision and evidence
+
+Retain coherent SCC blocks as the supported structural direction. Do not adopt
+this complete candidate yet. Next work should target the concrete local label
+association, folded retrace and cross-container ordering witnesses. Preserve
+model/port/fold contracts, fixed inputs and the full quality vector; do not tune
+global gaps, rerun perimeter candidates to select a score, or weaken projection
+equality. Production integration and native trace/overview workflows remain
+required once a candidate satisfies those constraints.
+
+The evidence archive contains both runs, failed and successful gate receipts,
+frozen inputs, controls, executable capture hashes, scripts and independent
+source/result/conservation reviews. Binaries are not embedded. Final claim and
+archive review is [versioned separately](final-review.md) outside the immutable archive.
+Archived supervisor scripts retain machine-local paths and Windows environment
+assumptions; the repository-relative build and probe commands above are the
+portable entry points after obtaining the source and locked dependencies.
+
+Archive `evidence/scc-placement-2426d286.zip`: 6041259 bytes, SHA256 `fbf40882ed807a1b40db8b3b9b9c846b060db02cbcc60611c18f9620c1fd59c9`, 168 individually verified members.
+
+This checkpoint is local-only until confirmed Gitea publication and byte readback. Linux builds remain excluded by the user; the frozen prerelease is unchanged.
diff --git a/harness/experiments/scc-placement-20260925/source-review-v2.md b/harness/experiments/scc-placement-20260925/source-review-v2.md
new file mode 100644
index 00000000..8a323516
--- /dev/null
+++ b/harness/experiments/scc-placement-20260925/source-review-v2.md
@@ -0,0 +1,29 @@
+# Independent review of the conditional placement transfer correction
+
+2026-09-25. Reviewed exact `4dd764fa6cfc6920350383e523ba5a597412ddf4`→`2426d286483ab0445663221cd6010a3dadb89a97` diff. Only the example importer, its three new regression tests, and the experiment plan addendum change. `condensed.rs`, production model/projection/routing and SCC placement policy remain unchanged. No compiler, tests, router, candidate or GUI execution by this reviewer.
+
+**Verdict: no material source blocker or accidental acceptance weakening found.** The correction implements the bounded predicate proposed in the run01 diagnosis and retains exact final-projection rejection. It is a faithful-transfer fix, not a new layout choice. Run01 and its source review/diagnosis remain valid records of the original failure. Gate24 and the unchanged-policy run02 are parent-owned pending evidence; this review does not claim they pass.
+
+At `crates/oa-core/examples/auto_layout_probe.rs:975–1015`, the importer first requires the complete original visible identity set with no duplicate count. An already exact node is untouched. Every mismatching node must have exactly the intended position, be noncollapsed, retain an intended size equal to its original projected size, and have no first-projected dimension larger than intended. Because exact sizes were already skipped, a qualifying finite size has at least one strictly smaller dimension. Any other mismatch rejects before any restoration is applied.
+
+All qualified minima are then written simultaneously to the private clone, followed by model validation and one additional projection. The existing exact comparison of all intended node positions/sizes remains the final gate; there is no retry loop, tolerance, clipping, or substitution of whatever projection happened to return. An invalid nested enclosure or additional port-capacity expansion still fails that comparison. Failure does not mutate the input Project.
+
+The first projection already matches for a true identity transfer or a rigid family translation whose enclosure is unchanged, so those cases retain the old authored sizes. Inward child movement can instead remove a formerly derived minimum: writing the requested unchanged projected size as an explicit authored minimum is exactly the storage change needed to preserve the intended visible footprint. This can write both dimensions of the qualified node's Size, even when only one projected dimension shrank; the new conservation audit must allow exactly this declared intended Size on qualified nodes, not silently ignore every size difference.
+
+Restoring multiple nested minima can make a final parent exceed its intended enclosure; the final exact check refuses rather than iterating. Restoring stored sizes can also alter automatic port side/slot choice. Those choices are derived from the returned Project and must be observed by the final port/lead/full-route checks; they are not fixed by this importer and do not authorize an anchor edit. `condensed::candidate` still performs its final actual-projection lead check after this transfer. A source-correct transfer still need not route successfully or improve readability.
+
+Route reset eligibility remains captured from the original view. Original-to-final positional deltas, hidden descendant translations, route entry/order/attachments and other views are untouched by the correction. Since restoration changes only node sizes and requires exact positions, it does not require recomputing positional route translation. Eligible overrides remain cleared once by the existing policy; retained pins are not repurposed as generated layout constraints.
+
+The three tests are meaningful and suitably bounded:
+
+- `unchanged_effective_container_size_survives_inward_child_movement` at1054 moves the lower child in each parent inward20 units, constructs a full expected Project clone with precisely those positions and requested parent minima, and checks exact output plus all original effective dimensions. It distinguishes this bug from a normal new requested size.
+- `identity_keeps_authored_expanded_and_folded_sizes` at1095 checks complete Project equality for both expanded and folded identity transfers, including hidden placements. The fixture has no authored routes; this is not a new hidden-pin lifecycle test.
+- `inconsistent_smaller_container_plan_still_rejects` at1122 moves a child1000 units beyond its planned enclosure and requires rejection, exercising the larger-derived-size boundary rather than accepting arbitrary reprojection.
+
+These do not exhaust position/ID/automatic-side/nested-restoration cases, but source predicates retain those guards and the fixed corpus rerun provides the next integration evidence. No broader fixture expansion or policy change is required before that run.
+
+The plan addendum accurately preserves run01 and predeclares repeating the same frozen corpus with unchanged SCC ordering, gaps, packing, router and criteria. Do not pool a corrected transfer with a tuned layout or mark the first failure passed retroactively.
+
+Reviewed importer SHA256: `13057d1961ab2b574d202538b11fe7d3173aa7ea288ab380c4e1fcc81b6d6e7d`.
+
+Related unchanged run01 diagnosis: `.local/scc-failure-diagnosis-20260925.md`, SHA256 `7a866902303fb83d14a673e1cede028c5a15517499e8e5f284fced4212f9a536`. No native adoption, whole-layout acceptance or remote publication claim.
diff --git a/harness/experiments/scc-placement-20260925/source-review.md b/harness/experiments/scc-placement-20260925/source-review.md
new file mode 100644
index 00000000..7721e9fb
--- /dev/null
+++ b/harness/experiments/scc-placement-20260925/source-review.md
@@ -0,0 +1,54 @@
+# Independent SCC-placement source review
+
+2026-09-25. Reviewed the initial `condensed.rs` handoff and the formatted candidate at `5300a8c803119dd57d86424867d3107db0ef256d`, plus the parent CLI and plan. No compiler, router, engine or GUI execution; no candidate edits by reviewer. This report is pre-experiment and pending the accepted perimeter correction below.
+
+Reviewed formatted hashes:
+
+- `crates/oa-core/examples/auto_layout_probe/condensed.rs`: `3bb9bcf2ee96d0c0c5beb2b7173c4307c9c9571a38bde3c621f3b5eae0834f86`.
+- `crates/oa-core/examples/auto_layout_probe.rs`: `36b81ec8c2ba58d1845f80e3afbfd16307035995893c5359c9e45c3db916ea96`.
+
+## Finding requiring pre-experiment correction
+
+**P2, bounded experiment contract — compact-grid scoring includes unused slots.** `condensed.rs:59` scores every nominal rows×columns perimeter envelope, then returns only its first n slots. For a two-node component, the nominal2×2 grid includes an unoccupied second row in its aspect ratio, while actual output places both nodes in a single horizontal strip. Consequently the advertised physical aspect≤2 preference does not describe the occupied cell envelope. This can affect the small cycle fixtures independently of the larger diagnosed SCCs.
+
+Parent accepted a pre-execution correction: include valid single-row/single-column grids with unique slots, score the actual first n occupied cell slots, preserve the predeclared aspect/area/tie order, and document the maximum-member-cell approximation for heterogeneous sizes. Add the two-node compactness witness. This is a correction to the chosen rule before results, not permission for a later rotation/packing parameter search. No overlap or model corruption was identified in the old slots; the defect concerns the implementation's selection criterion. Closure requires inspection of the resulting patch and its eventual parent-owned gate result.
+
+## Source findings without a blocker
+
+**Graph identity is explicit and coherent.** `lift` maps an endpoint to the immediate child-subtree representative of the current planning parent. `components` computes mutual reachability and partitions canonical sibling indices; condensation removes internal edges and longest-path ranks are propagated in a real topological order. No arbitrary vertex breaks a still-cyclic component. On flat graphs this is the actual visible directed graph; on compounds it is the documented sibling-subtree quotient, which may differ from leaf semantic SCCs. Diagnostics retain parent, membership, rank, walk and lifted arcs. No semantic reparenting or endpoint rewriting occurs.
+
+**Undirected policy is explicit.** Undirected links create no SCC/rank arcs, but remain in local gaps and deterministic neighbor proximity. Same-rank BFS reads all links; directed inter-component links cannot connect equal ranks, so this does not quietly assign a direction to an undirected edge. Relation-ID permutation does not change the alias/placement-based SCC traversal, although released routing order can still affect final paths.
+
+**Boundary-neighbor influence is incomplete by design.** If either endpoint cannot be lifted into a sibling group, that edge is skipped at that group. It may affect an ancestor's block order but not the child's internal ordering relative to external neighbors. In particular, the two-container reversed-child witness need not improve simply because the parent-level condensation is coherent. Parent acknowledged this limit and chose to preserve failures/no-change results rather than append a new heuristic before the fixed experiment. Report it rather than claiming general cross-boundary ordering.
+
+**Local bounds and container geometry are consistent in source.** Descendant groups are measured before their parents; block cells use maximum member dimensions, slots are disjoint, same-rank blocks are vertically separated, and ranks are horizontally separated. Expanded containers enclose their child blocks with32-unit side/bottom padding and header+32 at top. State projections use the core State header height; ordinary header64 agrees with the current architecture projection. Current core port footer is24, within the32 bottom padding. Original projected minima are retained; no shrink is introduced. Repeated calls must still check that saved container sizes and final reprojection do not ratchet or oscillate.
+
+**Folded and stored metadata are delegated correctly.** A folded node is an opaque visible leaf with original projected compact size; a folded node unexpectedly having visible children errors. Final `import_placement` checks exact collapsed compact size while preserving stored expanded size, moves latent descendants under the nearest visible collapsed ancestor, retains unrelated omitted nodes, and performs original-to-final route reset/translation once. The candidate does not overwrite authored anchors or generated routes during intermediate packing. Other views remain untouched. The external result audit must compare full records; emitted broad conservation booleans alone do not establish hidden-route preservation.
+
+**Final geometry is authoritative.** Accumulated offsets convert each nested position to diagram coordinates once. Import validates complete intended versus actual projected node geometry. The final lead diagnostic is run on that final projection and rejects a blocked endpoint pair; no iterative repair, lead shortening or port rewrite is introduced. An empty report still does not prove full-route success, node/header penetration absence, or label readability. The observer correctly emits final metrics and ten-call outcomes instead of a quality-pass Boolean.
+
+**Association-role sizing was corrected before this review pin.** The initial handoff used only center-label dimensions. At `condensed.rs:231` the formatted candidate now takes maximum center and `association_end_geometry` dimensions, matching the earlier native policy. This sizes gaps conservatively by estimates; it does not independently measure or certify association-end label collisions. Existing main-label metric counts must not be presented as all-label native acceptance.
+
+**Boundedness is adequate for this isolated test.** Stored nodes≤256, visible edges≤1024, finite positive minima,100000-unit final extent and a20-million weighted-work allowance bound candidate scope. Reachability, grid enumeration and parent walks have bounded domains; hierarchy cycles/missing parents error. The work count is not an exact CPU/projection/router-operation bound and original label estimation invokes the bounded existing router before much of this accounting. Parent process timeout remains separate. Failure drops the private candidate.
+
+## Tests and interpretation
+
+Current tests independently verify two directed cycles remain distinct across a one-way bridge and that ten perimeter slots are unique/disjoint. They do not establish full SCC placement, header/child enclosure, folded metadata, actual port feasibility or ID-permutation quality. The new two-node test should target the identified scoring defect rather than restate an implementation loop. The frozen five realistic plus nine small scenes, same-input duplication and ten repeated calls are the appropriate next evidence.
+
+On candidate error, the CLI reports unsupported/error and original metrics; it does not retain the partial planning diagnostics or identify each final lead blocker in the error. That is an acknowledged diagnostic limitation, not evidence the input model was changed. Do not infer which SCC order or port caused a rejected result solely from the generic error text.
+
+No further material source defect was identified in the reviewed pin. Keep production Arrange/router unchanged, preserve every unsupported/error case, and judge the full output vector. Source correctness does not establish the proposed compact-block hypothesis or engineer traceability.
+
+## Perimeter finding closed in source
+
+Independently inspected `ea18adc061f3bf8bb448b34e28be4266ffde1aa3` against5300a8c8 before any SCC diagram experiment output. `perimeter_slots` now handles single rows/columns without duplicate corners; enumeration includes those choices. Every score derives width/height from the maximum x/y of the actual first n occupied slots, with maximum-member cell sizes and the same aspect≤2/area/tie priority. The documentation accurately qualifies this as a cell-envelope heuristic; heterogeneous actual node envelopes can differ.
+
+The added two-node witness distinguishes the defect: cells224×160 with gaps250×56 select2×1 and positions(0,0),(0,216), whose occupied envelope224×376 is compact; the competing horizontal envelope698×160 is not. The capacity/work charge includes generated perimeter slots. No production routing, metadata or import policy changes accompany this correction. The P2 source finding is closed; no remaining material source blocker for the fixed experiment was found. Parent gate19 is in progress at review time, so this closes static correctness only, not test execution or layout quality. A redundant constant assertion in the test is nonessential and can be removed if strict Clippy requires it without changing the meaningful witness.
+
+## Exact follow-up through4dd764fa
+
+Reviewed the complete `ea18adc061f3bf8bb448b34e28be4266ffde1aa3`→`4dd764fa6cfc6920350383e523ba5a597412ddf4` diff: one file, four insertions/five deletions. In `components`, `for start in 0..n` becomes `reach.iter_mut().enumerate()`, and reads/writes of `reach[start][...]` become accesses through that same mutable row. Every row is still visited once in ascending start order; start reachability, DFS stack behavior, adjacency iteration, charge calls and visited tests are unchanged. SCC membership/order and all planning policy are therefore unchanged in source. Removing the constant ratio assertion leaves the meaningful expected2×1 grid and exact two positions asserted.
+
+Read gate20's retained receipt/log: strict Clippy at ea18adc0 exits101 with unchanged inputs because of `clippy::needless_range_loop` in that loop; it is not a passing gate. The4dd764fa change addresses the reported idiom without adding an allow attribute or weakening the diagnostic policy. Current `condensed.rs` SHA256 is `ef8050019ad4b436d28a8bbd83ba3addf0315ba021e2e6fe453b96aeb299e739`.
+
+No new material source finding. Perimeter P2 remains closed through4dd764fa. Parent gate21 and later Clippy/build/diagram outcomes are pending for this review; no runtime, performance, geometric-quality or native acceptance is inferred from this static equivalence check.
diff --git a/harness/experiments/scc-placement-20260925/transfer-diagnosis.md b/harness/experiments/scc-placement-20260925/transfer-diagnosis.md
new file mode 100644
index 00000000..16782c4a
--- /dev/null
+++ b/harness/experiments/scc-placement-20260925/transfer-diagnosis.md
@@ -0,0 +1,59 @@
+# SCC transfer failure and residual sparse label conflicts
+
+2026-09-25. Read-only diagnosis of frozen `scc-placement-20260925/run01` at source `4dd764fa6cfc6920350383e523ba5a597412ddf4`. No source edits, compiler, router, candidate or GUI rerun. The failed candidate does not emit its intermediate plan; the planned/final coordinates below are independently reconstructed from recorded input plus exact source rules, not a captured second Rust execution.
+
+**The two-container refusal is explained by the importer's unchanged-effective-size shortcut, not new port capacity or a failure to find an SCC placement.** Sparse's remaining1 label/label and3 label/stroke relationships are separately identifiable: none of those four edge pairs shares positive collinear route length. The structural trunk improvement therefore leaves genuine label-association and crossing problems; it is not a complete readability result.
+
+## Two-container exact reconstruction
+
+Frozen row `two_containers_reversed_children` reports `Final Rust projection differs from intended node geometry`. Both parents store224×94 but originally project308×446 because their children are farther from the parent origin. Each child stores224×94 and projects224×132 from its single semantic port's core minimum. The recorded input has no authored routes or anchors.
+
+At each parent's planning group, cross-container edges cannot lift their other endpoint into that group. The two children consequently become canonical singleton blocks in one rank, with32-unit vertical gap. Their required content envelope is224×296. Parent padding/header produces288×424, less than the original projected minimum308×446, so the SCC planner intentionally retains308×446 for each parent. At root level both edges lift left→right;114-unit center-label width gives146-unit inter-block gap. There is no association-end label contribution for these FunctionalExchanges.
+
+Source-derived intended plan:
+
+| Placement | Intended position | Intended size |
+| --- | --- | --- |
+| Left group (`...0002`) |(40,40)|308×446|
+| Right group (`...0004`) |(494,40)|308×446|
+| Left A (`...0006`) |(72,136)|224×132|
+| Left B (`...0008`) |(72,300)|224×132|
+| Right A (`...000a`) |(526,136)|224×132|
+| Right B (`...000c`) |(526,300)|224×132|
+
+`auto_layout_probe.rs:916–927` preserves authored node size whenever the intended size equals the original projected size. This protects true identity transfers from baking derived minima into storage, but here both parent intended sizes equal their old projected sizes even though their child positions changed. Their stored size therefore remains224×94.
+
+Core enclosure in `projection.rs:549–576` uses24-unit right/bottom padding and64-unit header. For Left group, the new rightmost child boundary is72+224=296, so right=296+24=320 and final width=320−40=280. Lowest child boundary is300+132=432, so bottom=432+24=456 and final height=456−40=416. Right group has the same relative calculation: final280×416. Parent x/y remain exactly intended; child x/y and224×132 dimensions remain intended. Thus both parent dimensions shrink relative to the proposed308×446 and the importer's exact final-projection guard correctly rejects the mismatch.
+
+This is not a new port-capacity expansion: each child has one port, capacity36 is below its existing132/224 dimensions, and the parents have no ports. The larger horizontal separation keeps the children facing their cross-container peers. The mismatch follows from less enclosure slack, not an enlarged port requirement. Because no intermediate candidate was emitted, the claim is this exact source-derived reconstruction; runtime confirmation belongs to the next parent-owned transfer check.
+
+## Critique of the proposed bounded importer correction
+
+The parent's proposed one-reprojection correction addresses an actual transfer defect without changing the SCC algorithm. Prefer its observed-geometry predicate over “write all intended expanded sizes when children move,” which would normalize authored sizes unnecessarily on ordinary rigid-family translations.
+
+Before changing storage, require the complete final node identity set and exact final positions. For every mismatch, allow correction only when the node is noncollapsed, its intended size equals its original projected size, and its first final dimensions are no greater than intended with at least one strictly smaller. Reject any missing/extra identity, position mismatch, larger dimension, collapsed mismatch, or mismatch outside that original shortcut. If all mismatches are eligible, set their stored sizes to intended simultaneously, then validate and project exactly once more. Accept only exact complete intended geometry; no iterative size chase.
+
+True identity and rigid-subtree translation continue preserving original authored sizes because their first projection already matches. This failed case would write308×446 as explicit parent minima only because that footprint would otherwise be lost after child rearrangement. This is a declared stored-geometry change, so full Project conservation auditing must allow exactly those written minima; it must not mask every node-size difference.
+
+Nested repairs can restore child sizes that force a parent above its intended size. Automatic port sides/slots may also change after minima are written. Neither justifies looping: the exact second projection must reject any remaining geometry mismatch, and actual final port/lead/full-route observations must use the returned Project. The second projection is stateless for that final stored model; a repeat comparison still matters for the whole SCC candidate. Keep fixed anchors, hidden metadata, route reset and original-to-final translation unchanged.
+
+Useful targeted checks before reinterpreting the failed row: complete true-identity equality; rigid-family translation preserving authored sizes; this two-parent contraction preserving the intended footprint; rejection of larger/position/collapsed mismatches; and a nested case that either succeeds exactly in that one pass or refuses without partial model changes. Retain run01, change only the importer boundary, and compare the unchanged frozen SCC algorithm's rerun; do not tune placement in response to this defect.
+
+## Sparse label witnesses
+
+Read complete candidate routes and label rectangles and independently intersected their coordinates. All rectangles below are estimated core bounds, not native glyph observations.
+
+**Label/label:** `flow_10` “Communications Enrich to Aggregate” (`...03345a`) overlaps `flow_48` “Planning Enrich handoff to Delivery Validate” (`...033480`). The first label occupies x1662.800048828125..1902.800048828125,y430..454; the second x1520..1760,y428..452. Intersection is97.199951171875×22=2138.39892578125, exactly the emitted area. Their routes cross properly at(1640,460), but share zero positive collinear length. The label overlap is a distinct nearby association problem, not the intersection point itself.
+
+**Label/stroke,1:** `flow_12` “Communications Decide to Package” (`...03345c`) crosses the label of `flow_11` “Communications Aggregate to Decide” (`...03345b`). Label rectangle is x2154..2394,y432..456. The stroke enters vertically at x2266 from y432 to444, then horizontally to x2394 at y444:12+128=140 units (emitted epsilon-inset139.9998). The two route polylines have no point contact and no positive shared interval. A raw route-intersection-only metric would miss this interference.
+
+**Label/stroke,2:** that same `flow_12` stroke traverses the full212-unit width of `flow_25` “Planning Aggregate to Decide” (`...033469`), rectangle x2526..2738,y428..452, along y444. Emitted inset length211.9998 agrees. These routes also cross properly at(2632,444), but have no positive shared run.
+
+**Label/stroke,3:** `flow_05` “Sensing Decide to Package” (`...033455`) traverses the212-unit width of `flow_32` “Delivery Aggregate to Decide” (`...033470`), rectangle x2526..2738,y860..884, along y876. Emitted inset length211.9998 agrees. Their proper crossing is(2632,876); again no positive shared run.
+
+The candidate's whole sparse drawing reports shared length32,15 proper crossings,19 point contacts, zero label/node collisions, zero unrelated-node penetration and zero warnings. Those gains do not erase the explicit four label conflicts. The witnesses support retaining label association and occupied route/label space as separate evaluation criteria. They do not by themselves require changing the router, enlarging every gap, or adopting a joint engine; no such tuning or native acceptance follows from this diagnosis.
+
+Evidence SHA256:
+
+- `run01/small-scc/stdout.jsonl`: `b35cbe482f8ad23da068da5761bdc61cfb88de3b1fa982f90ce78f5e379c9742`.
+- `run01/subsystems_40_sparse/stdout.jsonl`: `452690f23dda57f62d115b6d88e42d7f0283b4c86081d5149d8738ba6052e53b`.