diff --git a/research/bit-paired-boundary-gate/CLAIM.json b/research/bit-paired-boundary-gate/CLAIM.json
new file mode 100644
index 0000000000..1e2fa74a48
--- /dev/null
+++ b/research/bit-paired-boundary-gate/CLAIM.json
@@ -0,0 +1,9 @@
+{
+  "continuation_of": "https://github.com/CrocSwap/integer-mult-bounds/pull/673",
+  "base_commit": "b3917936aafbd0d680a954a86e25c4ce7e28a9f9",
+  "goal_status": "ACTIVE_UNACHIEVED",
+  "success_gate": "A valid local supplier and chronological physical hosting, at least 100 net paid rank units saved per invocation, complete exact moment below one at c>1/99, and all finite interfaces priced.",
+  "result": "Paired endpoint algebra and global composition are exact. The explicit wrapper is too costly. A three-dimensional common boundary with 296 whole helpers has a verified owner plan and a passing conditional rank-one invoice with 31 repair units per invocation. No matching local scalar word has been constructed; monotone reframing of the retained word is excluded.",
+  "selected_frontier": "unchanged",
+  "coordination": "Existing PR673 open at expected b391793 head, with no comments or review comments. PR770 proof read at pinned 48d027a664288ea1d4e987de63cb79588b8b936b; its Gaussian floor is an external conditional premise, not a freshly replayed dependency. Final metadata refresh through PR802; PR801, PR791 and updated PR717 bodies inspected for overlap. They do not supply the paired local word."
+}
diff --git a/research/bit-paired-boundary-gate/PROOF.md b/research/bit-paired-boundary-gate/PROOF.md
new file mode 100644
index 0000000000..20e5d4dbc3
--- /dev/null
+++ b/research/bit-paired-boundary-gate/PROOF.md
@@ -0,0 +1,239 @@
+# A paired boundary contract and its pre-construction cost gate
+
+This continues PR673 at `b3917936aafbd0d680a954a86e25c4ce7e28a9f9`.
+**The requested construction remains unachieved.** This note verifies a
+different composable endpoint, a concrete but unprofitable realization, and
+an exact owner plan and cost target for a replacement local word. No new
+supplier or kappa is admitted. The selected frontier is unchanged.
+
+## 1. Change both incoming boundaries
+
+Work in an eight-dimensional rational Euclidean address space. Choose
+orthogonal projections P and Q with PQ=QP=0, rank(P)=1 and rank(Q)=k-1.
+Put R=I-P-Q. For a projector U, D_U exchanges the head and tail address
+components on U, fixes its complement, and is an involution. On orthogonal
+subspaces, D_U D_V=D_(U+V). Here these are ADDRESS permutations; addition
+of their actions on Boolean payloads is a different operation.
+
+The proposed local scalar word still computes `(x,y,z) -> (x,y+x,z)` for
+every incoming dirty helper vector z, but with different frame boundaries:
+
+| Role | Incoming frame | Outgoing frame | Monotone climb |
+|---|---|---|---:|
+| source | P | I-Q | 8-k |
+| target | Q | I-P | 8-k |
+| each helper | 0 | I | 8 |
+
+Conjugating the scalar shear by these frames gives the exact payload
+operator
+
+    M = [[D_R, 0], [D_I, D_R]].
+
+Indeed the source diagonal is D_(I-Q)D_P=D_R, the target diagonal is
+D_(I-P)D_Q=D_R, and the off-diagonal is D_(I-P)D_P=D_I.
+The reflected reverse word, with data roles exchanged, has the matching
+upper-triangular operator. Thus separate source and target entrances can
+produce a common boundary of rank k. This does not establish a scalar word
+with those frames, nor a new orthogonality representation of the E8 graph.
+
+The checker constructs rational orthogonal coordinates at each of the 111
+actual PR589 ports. A Householder map sends 2e_0 to its norm-four port q;
+P is the first coordinate, Q the next k-1 coordinates, and R the remaining
+8-k. All inner products and port images are checked exactly for k=2 and 3.
+This supplies geometric candidates for Q, not compatible scalar gates.
+
+## 2. The global endpoint composes exactly
+
+Let a=8-k. Add eight exterior blocks E_1,...,E_8 of dimension a to the
+initial eight-space. A rational involution rho exchanges R with E_s and
+fixes P+Q. It sends the local diagonal D_R to D_Es and the local off-diagonal
+D_I8 to D_(P+Q+E_s). Its incoming/outgoing frame identities are verified
+in the exact orthogonal coordinates above.
+
+Use the retained nine-stage B_4 bank schedule and its chronological idle
+advances, with every old width 7 replaced by a. The full endpoint is D_full
+on all eight banks in dimension
+
+    m_core = k+9(8-k).
+
+The verifier proves this identity in the group algebra F2[C2^10], retaining
+formal sums of permutations. Its ten commuting involutions represent P+Q
+and the nine residual blocks. The result is the single full-address exchange
+on every output bank, with no off-diagonal contribution. The regular action
+is faithful and covers all 8*1024 formal basis columns. Removing any of the
+18 bridge shears changes the endpoint. This check does not replace the
+missing local word by an assertion that such a word exists.
+
+For comparison with the actual m=64, W=28416 invoice, pad the core with
+64-m_core ordinary directions and apply one paid child on those directions
+to each data family after the completed core. The two exchanges commute.
+This retains the productive denominator and the desired D_64 endpoint.
+Padding is charged; it is not extra productive volume or free helper space.
+
+## 3. A concrete wrapper exists, but is too expensive
+
+The old local word has operator `[[D_(I-P),0],[D_I,D_(I-P)]]`.
+Apply D_Q to the target before it and D_Q to the source after it. This
+exactly produces M. Each of these native children has rank k-1. They
+are real frame descents: target Q -> 0 and source I -> I-Q. They cannot
+be subtracted from the old invoice as if they were absorbed climbs.
+
+For k=3 the wrapper adds 222 rank-two children per invocation. A simple
+physical plan allocates 439 owned helper rows, initializes them to zero,
+and reuses them after each completed local invocation. The inherited exact
+local replay restores all helper scalars; applying their final ADDRESS
+permutation to zero still gives zero. The nine existing center rows remain
+typed. Stock is 28416+439+9=28864 full rows, with productive W still 28416.
+No helper work in this plan advances an idle data owner.
+
+The complete recursive histogram for this explicit owned-row plan includes:
+the actual PR589 local profile 288 times; 288*222 rank-two wrappers; every
+full idle advance of the new five-coordinate schedule; and 28416 rank-16
+padding children. The retained fallback shape is charged per child. Its
+rank mass is 3018720 and its moment at c=1/99+10^-9 exceeds **1.7015**.
+It increases the paid mass by 4202 2/3 per invocation. It fails even if new
+chart preparation and routing have zero recursive cost, so we do not build
+its supplier/controller.
+
+The scalar/source-access bill still includes 288*24305 aligned XOR scans,
+18*111*32 bridge XOR scans, and 288*9 inherited center copy/clear episodes.
+Owned helper initialization costs 439 full-row zero scans. Each added
+wrapper retains its native child and the inherited source/route interface.
+New descriptor, chart and tape head-return constants have not been emitted;
+their omission favors a candidate that already fails. This is not a finite
+compiler admission or a claim that the new cover's fallback proof is done.
+
+## 4. A target that does not depend on perfect consolidation
+
+The meaningful next target uses k=3 directly, without those wrappers:
+source P -> I-Q, target Q -> I-P, both with rank-five monotone paths. Keep
+v=111, nine stages, 32 replicas, and at most nine rank-seven COPY episodes.
+Require no more than 296 width-eight helper paths, each with arbitrary
+incoming dirt restored in scalar coordinates.
+
+The per-replica idle widths are
+
+    10,5,20,5,30,5,30,20,10.
+
+Each has 222 physical copies and the same untouched-stage windows as the
+pinned chronology. There are exactly
+
+    222 * (1+0+2+0+3+0+3+2+1) = 2664 = 9*296
+
+whole width-eight slots. An integral flow supplies all 296 helpers at every
+stage. The checker expands it into 2664 reservations per replica, 85248
+globally, including family, window, coordinate offset, stage and helper ID.
+It checks disjoint absolute coordinates and chronological membership.
+Each replica translates the family by 888. All unused coordinates are
+returned at their original idle boundaries; their per-replica histogram is
+
+    {2:444, 4:444, 5:666, 6:444}.
+
+No new helper storage is needed for this plan; physical stock would be
+W+9=28425. The rank-16 padding is performed after the core, separately on
+every productive family. It supplies no unproved extra hosting slots.
+297 whole width-eight helpers per stage cannot fit this particular plan:
+the total slot capacity is already exhausted. Partial-width entrances,
+new banking, or different chronological schedules are outside that fence.
+
+If the missing local word had these properties, its data, helper and COPY
+rank mass per invocation would be
+
+    222*5 + 296*8 + 63 = 3541.
+
+Charge **every one of these units as its own rank-one child**, including
+all helper restoration. This dominates any partition into proper children
+of the same rank mass at 0<c<1, including the per-child fallback. Retain the
+literal owner remainder and padding. The complete conditional profile is
+
+    {1:1019808, 2:14208, 4:14208, 5:21312, 6:14208, 16:28416}.
+
+Two exact rational interval engines give the following strict results at
+**c=1/99+10^-9**, which is strictly larger than the necessary rate:
+
+| Conditional local bill | Net rank saving per invocation | Moment, approximately |
+|---|---:|---:|
+| one child per monotone role/copy | 197 1/3 | 0.9835051889234464 |
+| every local unit at rank one | 197 1/3 | 0.9947928245644905 |
+| above plus 31 rank-one repair children per invocation | 166 1/3 | 0.9999126541717095 |
+| above plus 32 repair children per invocation | 165 1/3 | 1.0000778099654908 |
+
+Thus this target pays consolidation pessimistically and leaves a precise
+31-unit repair margin at the existing per-role child volume. Any actual
+repair must also account for its source reads, storage, routing and companion
+operations; this allowance does not provide those mechanisms. It clears
+both the 100-net-unit gate and the bit-rate
+gate **only under the missing local-word hypothesis**. It is not an achieved
+improvement. Source access, all dirty columns, COPY rank, actual frame paths,
+finite cover routing, stock constants and analytic interfaces of that word
+must still be verified. The unchanged complex supplier also prevents a
+claim of kappa=0.01 from this bit-only conditional table.
+
+The boundary accounting explains the change. For general k with the charged
+padding and complete hosted remainder,
+
+    deficit = 32*(8*111*k - 9*C).
+
+With C=63, moving from k=1 to k=2 would save only 98 2/3 units per invocation,
+slightly below the requested 100. k=3 saves 197 1/3, before excess motions or
+other repairs. Neither helper deletion nor increasing the denominator is
+responsible for this conditional credit.
+
+## 5. The old scalar order cannot simply be re-framed
+
+Start every old source at its actual line and every other role at zero.
+Ignore the supplied frame table. At each scalar gate assign the smallest
+possible monotone frame: the rational span of every operand's current frame.
+Grant each copied arrival frame zero, which only makes this test easier.
+Any monotone assignment for the same ordered scalar word must contain these
+spans. Nonzero target/helper entrances could only enlarge them.
+
+On the actual PR589 word, after B the source ranks are `{4:3, 7:108}`.
+After C, all **111** sources have forced rank eight. They cannot finish in
+I-Q of dimension six (or seven for k=2) along a monotone path. Omitting C
+changes the closure and provides a nontrivial control. This is a topology
+obstruction for monotone re-framing of this word, not a lower bound for
+other scalar words or carefully paid descents. The next construction must
+change the source/read/restoration topology or pay for enough resets within
+the cost gate; a frame optimizer on the unchanged stream cannot realize it.
+
+## 6. Gaussian E8 is a distinct, conditionally closed shortcut
+
+Gaussian E8 has 60 complex lines in complex dimension four, or rational
+rank-two ports in dimension eight. PR770's weighted-clique certificate
+reports a copy lower bound of **40 complex rank units** in its stated
+whole-line scalar-copy model. That is 80 rational rank units, not 40.
+The floor is an external premise here, not independently re-proved.
+
+Under the B_K accounting and slot-domination hypotheses of the inherited
+format analysis, put k=2, h=8 and C/v=80/60=4/3. Let s=2K+1. The deficit
+per port is D=(4K-4)/3. The checker uses exact logarithm intervals to prove
+D/Cost < 0.0078 for K=1,...,42. For K>=43, the pre-stretch idle slots alone
+give
+
+    Cost >= 24 sum_(p=1)^(K-1) p log(K/p)
+         >= 24 sum p(1-p/K) = 4(K^2-1),
+    D/Cost <= 1/(3(K+1)) <= 1/132 < 0.0078.
+
+The inequality exp(t)-1>=t then bounds every saving in that format below
+0.0078<1/99. Helpers, fallback and remaining costs cannot improve this
+favorable bound. This excludes the shortcut only with the stated COPY
+floor and format hypotheses; vector-valued interacting delivery or changed
+geometry remains outside it. The two-sided boundary target above does not
+assume that its paired planes retain the old E8 orthogonality graph.
+
+## Attribution and scope
+
+The native D_U calculus, compressed B_K recipe and existing scalar word are
+inherited from the PR370/386/436/443/510/545/589 lineages, with their existing
+icekylinx, Zhihao Chen, eumemic, chafreaky, DreamingOfClouds, OpenAI and Claude
+notices. The owner windows build on DaysSky's hosting work, independently
+checked in this contribution's prior gate. The format slot bounds are
+DreamingOfClouds' PR595/717 work. Gaussian context comes from GamingPuzzled's
+PR620 and chinmayarvind23's PR770 (which credits thakrarsagar's PR738 and
+Mister-Meeseeks' PR703). No priority claim is made for the elementary
+endpoint identities, flow allocation or rank/moment inequalities.
+
+Prepared for @androolloyd with substantial OpenAI Codex assistance,
+Apache-2.0. Finite algebra and exact prices are not a formal proof of the
+multiplication theorem. The success goal remains active and unachieved.
diff --git a/research/bit-paired-boundary-gate/README.md b/research/bit-paired-boundary-gate/README.md
new file mode 100644
index 0000000000..050e706ce4
--- /dev/null
+++ b/research/bit-paired-boundary-gate/README.md
@@ -0,0 +1,38 @@
+# Paired boundary preflight: an exact endpoint and a missing local word
+
+**No supplier or new kappa.** The 100-net-unit goal is still open.
+
+This follow-up changes the data boundary rather than withdrawing helpers
+from fixed obligations. It verifies a composable paired endpoint, rejects
+an explicit expensive wrapper, and gives a chronological 296-helper owner
+plan for a proposed rank-three common boundary. A hypothetical matching
+word passes even when all 3541 local rank units are charged separately; it
+can afford 31 additional rank-one repairs per invocation. The retained
+scalar word cannot realize it by monotone re-framing.
+
+Read [PROOF.md](PROOF.md) for the operator, full conditional invoice,
+concrete wrapper costs, source access, storage, and missing construction.
+Exact values and flow allocation are in [evidence/PRICE.json](evidence/PRICE.json).
+
+From the repository root, Python 3.11+ with the standard library:
+
+```sh
+sh research/bit-paired-boundary-gate/replay.sh /tmp/paired-boundary-new-output
+```
+
+Expected final line: `PASS_PAIRED_BOUNDARY_GATE_REPLAY`.
+The output directory must not exist. There is no solver, network access,
+package installation or historical Git dependency in replay. The checker
+supports `python3 -I -O -B`; admission checks do not rely on assertions.
+Input hashes bind the reused local replay and both interval engines.
+
+The exact checks cover 111 rational port charts, the full eight-bank
+operator in a faithful 1024-state permutation algebra, all 18 omitted
+bridge controls, all 661 inherited local scalar columns, 85248 global
+reservations, owner collision/timing controls, two price engines, the
+31/32 repair fence and the unchanged-word frame obstruction. The Gaussian
+appendix prices an external COPY-floor premise; it does not re-prove it.
+
+Nothing in `upstream/` or the selected frontier is changed. This is part of
+[PR673](https://github.com/CrocSwap/integer-mult-bounds/pull/673), not a new
+contribution branch or a claimed frontier result.
diff --git a/research/bit-paired-boundary-gate/SOURCES.json b/research/bit-paired-boundary-gate/SOURCES.json
new file mode 100644
index 0000000000..ef4017c909
--- /dev/null
+++ b/research/bit-paired-boundary-gate/SOURCES.json
@@ -0,0 +1,25 @@
+{
+  "base_commit": "b3917936aafbd0d680a954a86e25c4ce7e28a9f9",
+  "files": {
+    "research/bit-role-sharing-budget/verify.py": "6bed74cccf0bdf6aaa4984f8ae130f2e3380acdf1525385a4a0be6da796d24e4",
+    "research/bit-sharing-hosting-gate/verify.py": "e050feb3f43dbb1b64e568f10ebc5f2561611b238c27220dbaf2384d318e4d49",
+    "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f",
+    "research/complex-k492-owner-repair/vendor/multicold/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482",
+    "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4"
+  },
+  "external_context": {
+    "770": "48d027a664288ea1d4e987de63cb79588b8b936b",
+    "777": "eca5c317d8176401a1f71a5ea1e81384c2eab1e0"
+  },
+  "reviewed_external_proof": {
+    "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/48d027a664288ea1d4e987de63cb79588b8b936b/research/gaussian-e8-copy-bound/PROOF.md",
+    "sha256": "0f4ba837c2337cc06d7d3315e6e6a8598cc3919baf4f8a90c2a03713c2556a2c",
+    "scope": "Read proof; did not rerun its exhaustive finite pairing certificate. The 80-rational-rank floor is an external premise in this package."
+  },
+  "late_overlap_metadata": {
+    "801": "63450b78e26b4b63641fa72c371010273d4d6866",
+    "791": "f80382efd4cd3e37c67b2a966398b55bb56af53c",
+    "717": "4150829a2cb66b823f4282da98985959ee448a90"
+  },
+  "late_overlap_scope": "PR bodies read at these heads; not mathematical dependencies. PR801 treats Witting/Hurwitz coordinate-total labels through 13 stages; PR791 arbitrary idempotent path penalties; updated PR717 fixed-word/decoder/format limits."
+}
diff --git a/research/bit-paired-boundary-gate/VALIDATION.json b/research/bit-paired-boundary-gate/VALIDATION.json
new file mode 100644
index 0000000000..5fb13a86b1
--- /dev/null
+++ b/research/bit-paired-boundary-gate/VALIDATION.json
@@ -0,0 +1,37 @@
+{
+  "status": "PASS_FOCUSED_PAIRED_BOUNDARY_GATE",
+  "python": "3.14.7",
+  "platform": "Darwin-25.1.0-arm64-arm-64bit-Mach-O",
+  "checked_at_utc": "2026-10-13T05:57:07.419687+00:00",
+  "checks": [
+    "Normal isolated exact verifier",
+    "Optimized isolated byte-identical receipt",
+    "Final relocated minimal-input replay in a path with spaces",
+    "Altered expected receipt rejected",
+    "Altered input bytes rejected under optimized Python",
+    "18 omitted bridge controls",
+    "Owner timing and absolute-coordinate collision controls",
+    "296/297 whole-helper capacity fence",
+    "31/32 rank-one repair fence at c strictly greater than 1/99",
+    "Two exact rational price engines on all five invoices",
+    "Actual 661-column inherited local-word replay",
+    "Independent least monotone frame closure on actual scalar stream",
+    "Selected-record and source-inventory integrity check"
+  ],
+  "not_repeated": [
+    "Unchanged aggregate cold replay and 47 outer inequalities last passed at b391793",
+    "PR770 exhaustive Gaussian pairing-rank proof certificate",
+    "Root-wide suite, remote CI and proof-assistant validation"
+  ],
+  "not_achieved": [
+    "No new local word for the paired endpoint",
+    "No full supplier/controller/compiler admission",
+    "No new kappa"
+  ],
+  "verified_file_sha256": {
+    "research/bit-paired-boundary-gate/verify.py": "c4b7ad22a1df72607b3b36faa00c7dcd8f42167e8000f3591564850c3eed114f",
+    "research/bit-paired-boundary-gate/SOURCES.json": "0796137d6d8b89b44a8cd41f60de548d8f4d6cf75aa194387cfc05d9cd8e1eb3",
+    "research/bit-paired-boundary-gate/evidence/PRICE.json": "b051c21240a55422acae9ba5d2aae3fd4178a19f43ba162b1f946d875d7f8610"
+  },
+  "metadata_note": "After the final replay, only external-overlap metadata was appended to SOURCES/CLAIM; the pinned input file set and executable evidence are unchanged."
+}
diff --git a/research/bit-paired-boundary-gate/evidence/PRICE.json b/research/bit-paired-boundary-gate/evidence/PRICE.json
new file mode 100644
index 0000000000..e137b28df4
--- /dev/null
+++ b/research/bit-paired-boundary-gate/evidence/PRICE.json
@@ -0,0 +1,577 @@
+{
+  "concrete_nonrecursive_bill": {
+    "bridge_aligned_xor_scans": 63936,
+    "extra_wrapper_child_rank": 2,
+    "extra_wrapper_children": 63936,
+    "inherited_center_copy_clear_episodes": 2592,
+    "local_aligned_xor_scans": 6999840,
+    "scope": "These scans and source reads remain charged. New chart/descriptor/head-return constants are not generated; their favorable omission already fails the recursive cost gate."
+  },
+  "concrete_owned_stock": {
+    "centers": 9,
+    "helper_final_state": "zero, reusable after every completed invocation",
+    "helper_initialization_scans": 439,
+    "physical": 28864,
+    "private_helpers": 439,
+    "productive": 28416
+  },
+  "conditional_hosting": {
+    "allocation": [
+      [
+        0,
+        0,
+        222
+      ],
+      [
+        2,
+        0,
+        74
+      ],
+      [
+        2,
+        1,
+        296
+      ],
+      [
+        2,
+        2,
+        74
+      ],
+      [
+        4,
+        2,
+        222
+      ],
+      [
+        4,
+        3,
+        296
+      ],
+      [
+        4,
+        4,
+        148
+      ],
+      [
+        6,
+        4,
+        148
+      ],
+      [
+        6,
+        5,
+        296
+      ],
+      [
+        6,
+        6,
+        222
+      ],
+      [
+        7,
+        6,
+        74
+      ],
+      [
+        7,
+        7,
+        296
+      ],
+      [
+        7,
+        8,
+        74
+      ],
+      [
+        8,
+        8,
+        222
+      ]
+    ],
+    "global_slots": 85248,
+    "helpers_per_stage": 296,
+    "owner_slots_sha256": "dcedd792881308bfedff5dd141841539059eee2e0b8384c843275cfa34460fcd",
+    "remainder": {
+      "2": 444,
+      "4": 444,
+      "5": 666,
+      "6": 444
+    },
+    "slots_per_replica": 2664,
+    "total_slot_capacity": 2664,
+    "translated_global_slots_sha256": "fa3c79bd7a48ce61aa10de8ddb4a9c55470d3d90dfd898a3022bb3c32eaec32e",
+    "windows": {
+      "0": [
+        1,
+        10,
+        [
+          0,
+          1
+        ]
+      ],
+      "1": [
+        1,
+        5,
+        [
+          2
+        ]
+      ],
+      "2": [
+        2,
+        20,
+        [
+          0,
+          1,
+          2,
+          3
+        ]
+      ],
+      "3": [
+        2,
+        5,
+        [
+          4
+        ]
+      ],
+      "4": [
+        3,
+        30,
+        [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5
+        ]
+      ],
+      "5": [
+        3,
+        5,
+        [
+          6
+        ]
+      ],
+      "6": [
+        0,
+        30,
+        [
+          3,
+          4,
+          5,
+          6,
+          7,
+          8
+        ]
+      ],
+      "7": [
+        1,
+        20,
+        [
+          5,
+          6,
+          7,
+          8
+        ]
+      ],
+      "8": [
+        2,
+        10,
+        [
+          7,
+          8
+        ]
+      ],
+      "9": [
+        3,
+        0,
+        []
+      ]
+    }
+  },
+  "controls": [
+    "297 width-eight helpers at three-dimensional boundary",
+    "helper outside chronological window",
+    "overlapping physical coordinates",
+    "dropping concrete wrapper rank charges"
+  ],
+  "gaussian_conditional_ceiling": {
+    "copy_floor_reproved": false,
+    "finite_stage_linear_bounds": [
+      [
+        3,
+        "0"
+      ],
+      [
+        5,
+        "26959946667150639794667015087019630673637144422540572481103610249216/3506057856900847672442425434191902404103934436034799743160319462489257"
+      ],
+      [
+        7,
+        "53919893334301279589334030174039261347274288845081144962207220498432/6970703634773106945429775689129952439619457394435089485440833512198163"
+      ],
+      [
+        9,
+        "13479973333575319897333507543509815336818572211270286240551805124608/1865417752076314617440124601753852921737754693943461318668067130170485"
+      ],
+      [
+        11,
+        "107839786668602559178668060348078522694548577690162289924414440996864/16100573237065435217928365995007870231665334515620211603391448686117625"
+      ],
+      [
+        13,
+        "16849966666969149871666884429387269171023215264087857800689756405760/2706691191269009974243736667510817600824930357354385894159775486199979"
+      ],
+      [
+        15,
+        "53919893334301279589334030174039261347274288845081144962207220498432/9274730569551931470889338813961324480344162093743548896622182713626009"
+      ],
+      [
+        17,
+        "188719626670054478562669105609137414715460010957784007367725271744512/34593314290525075703576319005206963537802073381057291853547089069141499"
+      ],
+      [
+        19,
+        "107839786668602559178668060348078522694548577690162289924414440996864/20973274112364850533684476429464556570223004942097998748758521024528039"
+      ],
+      [
+        21,
+        "40439920000725959692000522630529446010455716633810858721655415373824/8312129977927780230848544783673257675230320699877273634076601161274479"
+      ],
+      [
+        23,
+        "53919893334301279589334030174039261347274288845081144962207220498432/11672629200241525255594563500218408608591403996843073120655405715730587"
+      ],
+      [
+        25,
+        "296559413338657037741337165957215937410008588647946297292139712741376/67410412314343777645069465389906391323893706121070097229947436648009321"
+      ],
+      [
+        27,
+        "107839786668602559178668060348078522694548577690162289924414440996864/25669520562671652033287734581567381643254942498063900532752677342214519"
+      ],
+      [
+        29,
+        "350479306672958317330671196131255198757282877493027442254346933239808/87152510570729890682975639678233135263975052465787210095018143741358519"
+      ],
+      [
+        31,
+        "53919893334301279589334030174039261347274288845081144962207220498432/13976843883956088398490912915231824484351079317816168617312147626880237"
+      ],
+      [
+        33,
+        "134799733335753198973335075435098153368185722112702862405518051246080/36353661345353099261092800761083243678942971051688894636974276550758571"
+      ],
+      [
+        35,
+        "107839786668602559178668060348078522694548577690162289924414440996864/30204611887724362769182974868660966689294232435197914344871181834804007"
+      ],
+      [
+        37,
+        "458319093341560876509339256479333721451831455183189732178761374236672/133107393921103317509417947433621591492156652573990209535900590121691489"
+      ],
+      [
+        39,
+        "53919893334301279589334030174039261347274288845081144962207220498432/16213915970876657351552691560073244367308212835390449116319461006503999"
+      ],
+      [
+        41,
+        "256119493337931078049336643326686491399552872014135438570484297367552/79634845243175413241468101581429885312642431599379513789907928687317021"
+      ],
+      [
+        43,
+        "269599466671506397946670150870196306736371444225405724811036102492160/86569329698836817409925252212268484472433477544153542792237351058913001"
+      ],
+      [
+        45,
+        "188719626670054478562669105609137414715460010957784007367725271744512/62510091393614485486050786210028886220170243287126640904301957661374971"
+      ],
+      [
+        47,
+        "593118826677314075482674331914431874820017177295892594584279425482752/202442829833333048687622871356522029276936339338675118248173178124018903"
+      ],
+      [
+        49,
+        "620078773344464715277341347001451505493654321718433167065383035731968/217874770202549729971536690598253209624561866954011130801797042753314617"
+      ],
+      [
+        51,
+        "107839786668602559178668060348078522694548577690162289924414440996864/38970778217262400522785621523460455435065223442931657600860503877992541"
+      ],
+      [
+        53,
+        "673998666678765994866675377175490766840928610563514312027590256230400/250291215638553792742825255133663992750972901686880079583954367273200617"
+      ],
+      [
+        55,
+        "87619826668239579332667799032813799689320719373256860563586733309952/33409149867256116567520604467089792304706031265982655961308055021792111"
+      ],
+      [
+        57,
+        "242639520004355758152003135783176676062734299802865152329932492242944/94923166291340142363171439900684507456079923627118917126458805115454229"
+      ],
+      [
+        59,
+        "754878506680217914250676422436549658861840043831136029470901086978048/302779075391022978773369736731980019242874940419118351765523964166853179"
+      ],
+      [
+        61,
+        "781838453347368554045343437523569289535477188253676601952004697227264/321300960375589085460711945676517451111747563445781551481740242204512251"
+      ],
+      [
+        63,
+        "269599466671506397946670150870196306736371444225405724811036102492160/113444750146664463362614121327979655961252094364683220802703212106164937"
+      ],
+      [
+        65,
+        "835758346681669833634677467697608550882751477098757746914211917725696/359878100640060177923031868047810062544513865802840325882027016860445935"
+      ],
+      [
+        67,
+        "862718293348820473429344482784628181556388621521298319395315527974912/379931718980604181416809109318669876866432375067951619656993649948572311"
+      ],
+      [
+        69,
+        "9267481666833032429416786436162998044062768395248321790379366023168/4171816266550011247788613123206080878215438929407604090675753887756247"
+      ],
+      [
+        71,
+        "916638186683121753018678512958667442903662910366379464357522748473344/421565328456973916807008639919085332959011776549275992853892874697802375"
+      ],
+      [
+        73,
+        "5897488333439202455083409550285544209858125342430750230241414742016/2769649747957626122109182653443885190729693498709566880716426024516887"
+      ],
+      [
+        75,
+        "107839786668602559178668060348078522694548577690162289924414440996864/51692181341326581039587335659927213852951482382963450721696594031836235"
+      ],
+      [
+        77,
+        "498759013342286836201339779109863167462287171817000590900416789610496/243910878123683813359215383795827706585230070015116384522969398651738667"
+      ],
+      [
+        79,
+        "1024477973351724312197346573306745965598211488056541754281937189470208/510919773882236899794263549086899606499812001067971994551426228769092179"
+      ],
+      [
+        81,
+        "350479306672958317330671196131255198757282877493027442254346933239808/178174385117018098999336874823634890598559385420542251822950966907673889"
+      ],
+      [
+        83,
+        "1078397866686025591786680603480785226945485776901622899244144409968640/558631397563597126219578585276002584394050048798454982125665073204718309"
+      ],
+      [
+        85,
+        "2158901979205422327307319567515243862537349455711256780713375039488/1139148480506365140558196126399377398458067215586466799979493502113531"
+      ]
+    ],
+    "rational_copy_floor": 80,
+    "real_ports": 60,
+    "supplier_saving_upper": "39/5000",
+    "tail": "1/(3*(K+1)) for K>=43"
+  },
+  "geometry": {
+    "ports": 111,
+    "ranks_checked": [
+      2,
+      3
+    ],
+    "rational_charts_sha256": "6a09ee271b6b27f4f83e87153ffad04e36a39f318c13b7dfad2195e6f896fcd3"
+  },
+  "goal_status": "ACTIVE_UNACHIEVED",
+  "inherited_local_replay": {
+    "columns": 661,
+    "copy_ranks": [
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7
+    ],
+    "independent_retained_inputs": 9,
+    "paid_histogram": {
+      "1": 1323,
+      "2": 1342,
+      "3": 79,
+      "4": 44,
+      "5": 102,
+      "6": 11,
+      "7": 19
+    },
+    "rank_mass": 5129,
+    "response_rank": 9,
+    "role_climb_mass": {
+      "helper": 3512,
+      "source": 777,
+      "target": 777
+    }
+  },
+  "missing": [
+    "A legal local scalar word with P->Q-perp and Q->P-perp endpoints, rank(Q)=2.",
+    "At most 296 width-eight helper paths and COPY rank at most 63, with every dirty input restored.",
+    "Source access, route, controller, finite stock and all-size interfaces for that new word."
+  ],
+  "operator": {
+    "final_operator": "D_full on all eight data banks",
+    "formal_basis_columns": 8192,
+    "global_bank_rows": 8,
+    "independent_address_states": 1024,
+    "local_common_rank": [
+      2,
+      3
+    ],
+    "omitted_bridge_controls": 18
+  },
+  "prices": {
+    "all_local_units_at_rank_one_oracle": {
+      "moment_display": "0.9947928245644905468726184290194026646604465228038908943172274287384407",
+      "moment_interval": [
+        "13409780747561404016270035653571823692169963049524036824841732980263/13479973333575319897333507543509815336818572211270286240551805124608",
+        "1676222593445175502033754456696477961521245381190504603105216622533/1684996666696914987166688442938726917102321526408785780068975640576"
+      ],
+      "net_credit_per_invocation": "592/3",
+      "net_global_credit": 56832,
+      "passes_100_units": true,
+      "passes_rate": true,
+      "profile": {
+        "1": 1019808,
+        "2": 14208,
+        "4": 14208,
+        "5": 21312,
+        "6": 14208,
+        "16": 28416
+      },
+      "rank_mass": 1751520,
+      "strict_rate": "1000000099/99000000000",
+      "supplier_admitted": false
+    },
+    "concrete_wrapped_word_owned_helpers": {
+      "moment_display": "1.701514988510804745325291801412177523359024682506668829811947866450690",
+      "moment_interval": [
+        "22936376671804364777856250347010713023560699484333569047275204373171/13479973333575319897333507543509815336818572211270286240551805124608",
+        "5734094167951091194464062586752678255890174871083392261818801093293/3369993333393829974333376885877453834204643052817571560137951281152"
+      ],
+      "net_credit_per_invocation": "-12608/3",
+      "net_global_credit": -1210368,
+      "passes_100_units": false,
+      "passes_rate": false,
+      "profile": {
+        "1": 381024,
+        "2": 450432,
+        "3": 22752,
+        "4": 12672,
+        "5": 50688,
+        "6": 3168,
+        "7": 5472,
+        "10": 14208,
+        "16": 28416,
+        "20": 14208,
+        "30": 14208
+      },
+      "rank_mass": 3018720,
+      "strict_rate": "1000000099/99000000000",
+      "supplier_admitted": false
+    },
+    "one_child_per_role_oracle": {
+      "moment_display": "0.9835051889234464195737771520814940490100922009662906495552839886940207",
+      "moment_interval": [
+        "26515247440242029637254508741448889876257468531931157484145570317703/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26515247440242029637254508741448889876257468531931157484145570317705/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "net_credit_per_invocation": "592/3",
+      "net_global_credit": 56832,
+      "passes_100_units": true,
+      "passes_rate": true,
+      "profile": {
+        "2": 14208,
+        "4": 14208,
+        "5": 85248,
+        "6": 14208,
+        "7": 2592,
+        "8": 85248,
+        "16": 28416
+      },
+      "rank_mass": 1751520,
+      "strict_rate": "1000000099/99000000000",
+      "supplier_admitted": false
+    },
+    "oracle_plus_31_repairs_per_invocation": {
+      "moment_display": "0.9999126541717095260446965291788377141081105143547722086123644660209849",
+      "moment_interval": [
+        "26957591828278330519290242274527057498783995749048107239194167526983/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26957591828278330519290242274527057498783995749048107239194167526985/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "net_credit_per_invocation": "499/3",
+      "net_global_credit": 47904,
+      "passes_100_units": true,
+      "passes_rate": true,
+      "profile": {
+        "1": 1028736,
+        "2": 14208,
+        "4": 14208,
+        "5": 21312,
+        "6": 14208,
+        "16": 28416
+      },
+      "rank_mass": 1760448,
+      "strict_rate": "1000000099/99000000000",
+      "supplier_admitted": false
+    },
+    "oracle_plus_32_repairs_per_invocation": {
+      "moment_display": "1.000077809965490783437344209829142070541906126985445799396078563997833",
+      "moment_interval": [
+        "26962044419670444147895086499281361050862836705499721225952577254933/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26962044419670444147895086499281361050862836705499721225952577254935/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "net_credit_per_invocation": "496/3",
+      "net_global_credit": 47616,
+      "passes_100_units": true,
+      "passes_rate": false,
+      "profile": {
+        "1": 1029024,
+        "2": 14208,
+        "4": 14208,
+        "5": 21312,
+        "6": 14208,
+        "16": 28416
+      },
+      "rank_mass": 1760736,
+      "strict_rate": "1000000099/99000000000",
+      "supplier_admitted": false
+    }
+  },
+  "retained_word_monotone_obstruction": {
+    "copy_arrivals": "granted frame zero",
+    "scope": "Retained scalar order and monotone frames only; new source topology or paid descents remain outside.",
+    "source_ranks_after_phase": {
+      "A": {
+        "1": 10,
+        "2": 93,
+        "4": 8
+      },
+      "B": {
+        "4": 3,
+        "7": 108
+      },
+      "C": {
+        "8": 111
+      },
+      "D": {
+        "1": 111
+      }
+    }
+  },
+  "status": "PASS_PAIRED_BOUNDARY_PREFLIGHT_NOT_A_SUPPLIER",
+  "target_owned_stock": {
+    "centers": 9,
+    "helpers": "all borrowed from 85248 exclusive reservations",
+    "physical": 28425,
+    "productive": 28416
+  }
+}
diff --git a/research/bit-paired-boundary-gate/replay.sh b/research/bit-paired-boundary-gate/replay.sh
new file mode 100644
index 0000000000..5d02d32c7d
--- /dev/null
+++ b/research/bit-paired-boundary-gate/replay.sh
@@ -0,0 +1,12 @@
+#!/bin/sh
+set -eu
+if [ "$#" -ne 1 ] || [ -e "$1" ]; then
+    echo "usage: sh research/bit-paired-boundary-gate/replay.sh NEW_OUTPUT_DIRECTORY" >&2
+    exit 2
+fi
+here=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+mkdir -p -- "$1"
+out=$(CDPATH= cd -- "$1" && pwd)
+python3 -I -B "$here/verify.py" --out "$out/PRICE.json"
+cmp "$out/PRICE.json" "$here/evidence/PRICE.json"
+echo PASS_PAIRED_BOUNDARY_GATE_REPLAY
diff --git a/research/bit-paired-boundary-gate/verify.py b/research/bit-paired-boundary-gate/verify.py
new file mode 100644
index 0000000000..5626a1a965
--- /dev/null
+++ b/research/bit-paired-boundary-gate/verify.py
@@ -0,0 +1,419 @@
+#!/usr/bin/env python3
+"""Paired endpoint algebra, chronological owners and conditional cost gate.
+
+No local paired-boundary supplier is supplied or admitted.
+Prepared for androolloyd with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+import argparse
+from collections import Counter, deque
+from fractions import Fraction as Q
+import gzip
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+V, T, S, W = 111, 32, 9, 28416
+RATE = Q(1, 99) + Q(1, 10**9)
+
+
+def need(ok, why):
+    if not ok:
+        raise ValueError(why)
+
+
+def module(name, path):
+    spec = importlib.util.spec_from_file_location(name, ROOT / path)
+    obj = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(obj)
+    return obj
+
+
+def digest(obj):
+    return hashlib.sha256(json.dumps(obj, sort_keys=True, separators=(',', ':')).encode()).hexdigest()
+
+
+def geometry(lines):
+    """Rational Householder coordinates for P of rank 1 and Q of rank 1/2.
+
+    All projection and rho identities then follow by disjoint coordinate
+    blocks, independently of whether a scalar supplier realizes the endpoints.
+    """
+    receipts = []
+    for line in lines:
+        need(sum(x*x for x in line) == 4, 'port norm')
+        d = [Q(2*int(i == 0)-line[i]) for i in range(8)]
+        norm = sum(x*x for x in d)
+        g = [[Q(int(i == j)) - (2*d[i]*d[j]/norm if norm else 0)
+              for j in range(8)] for i in range(8)]
+        need(all(sum(g[i][a]*g[i][b] for i in range(8)) == int(a == b)
+                 for a in range(8) for b in range(8)), 'rational isometry')
+        need([2*g[i][0] for i in range(8)] == line, 'source port')
+        # In the G chart P={0}, Q={1,...,k-1}; rho swaps the complement
+        # {k,...,7} with a new exterior block and fixes P+Q.
+        for k in (2, 3):
+            a = 8-k
+            perm = list(range(8+a))
+            for j in range(a):
+                perm[k+j], perm[8+j] = perm[8+j], perm[k+j]
+            move = lambda z: {perm[i] for i in z}
+            p, q, r, e = {0}, set(range(1, k)), set(range(k, 8)), set(range(8, 8+a))
+            need(move(p|e) == p|r and move(q|e) == q|r, 'incoming rho identity')
+            need(move(p|r|e) == p|r|e and move(q|r|e) == q|r|e, 'outgoing rho identity')
+            need(move(r) == e and move(p|q|r) == p|q|e, 'macro rho identity')
+        receipts.append([[str(x) for x in row] for row in g])
+    return dict(ports=len(lines), ranks_checked=[2, 3], rational_charts_sha256=digest(receipts))
+
+
+def monomial(row, mask):
+    out = {}
+    for i, poly in row.items():
+        val = 0
+        while poly:
+            b = poly & -poly
+            val ^= 1 << ((b.bit_length()-1) ^ mask)
+            poly ^= b
+        out[i] = val
+    return out
+
+
+def add(a, b):
+    return {i: a.get(i, 0)^b.get(i, 0) for i in a.keys()|b.keys()
+            if a.get(i, 0)^b.get(i, 0)}
+
+
+def global_operator(skip=-1):
+    """Exact group algebra F2[C2^10]: common block plus nine residual blocks.
+
+    An entry is a formal sum of ADDRESS permutations, not a sum of address
+    coordinate matrices. Its regular action is faithful on all 1024 states.
+    """
+    rows = [{i: 1} for i in range(8)]
+    controls = 0
+
+    def local(stage, pair, reverse=False):
+        e = 1 << (stage+1)
+        x, y = 2*pair, 2*pair+1
+        before_x, before_y = rows[x], rows[y]
+        if reverse:
+            rows[x] = add(monomial(before_x, e), monomial(before_y, 1|e))
+            rows[y] = monomial(before_y, e)
+        else:
+            rows[x] = monomial(before_x, e)
+            rows[y] = add(monomial(before_y, e), monomial(before_x, 1|e))
+
+    def idle(pair, first, last):
+        mask = sum(1 << (j+1) for j in range(first+1, last+1))
+        for i in (2*pair, 2*pair+1):
+            rows[i] = monomial(rows[i], mask)
+
+    def bridge(dst, src):
+        nonlocal controls
+        for x, y in ((2*dst, 2*src), (2*src+1, 2*dst+1)):
+            if controls != skip:
+                rows[x] = add(rows[x], rows[y])
+            controls += 1
+
+    local(0, 0)
+    for pair in range(4):
+        local(2*pair+1, pair, True)
+        if pair < 3:
+            idle(pair+1, -1, 2*pair+1)
+            bridge(pair, pair+1)
+        local(2*pair+2, pair)
+        if pair < 3:
+            idle(pair+1, 2*pair+1, 2*pair+2)
+            bridge(pair, pair+1)
+        else:
+            for j in range(4):
+                idle(j, 2*j+2, 8)
+    for j in reversed(range(3)):
+        bridge(j+1, j)
+    for j in range(4):
+        rows[2*j], rows[2*j+1] = rows[2*j+1], rows[2*j]
+    want = [{i: 1 << 1023} for i in range(8)]
+    return rows == want, controls
+
+
+def local_operator():
+    # Independent commuting blocks P=1,Q=2,R=4. A full scalar shear
+    # conjugated by incoming (P,Q), outgoing (P+R,Q+R) has these entries.
+    diagonal = [(1|4)^1, (2|4)^2]
+    off_diagonal = (2|4)^1
+    need(diagonal == [4, 4] and off_diagonal == 7, 'paired local endpoint')
+    # Existing macro diagonal Q+R. Source-only post D_Q and target-only
+    # pre D_Q keep the off-diagonal F while changing both diagonals to R.
+    need(2^(2|4) == 4 and (2|4)^2 == 4, 'paid wrapper endpoint')
+    need((2|4)^1 == 7, 'paid wrapper off-diagonal')
+    need(2^7 != 7, 'omitting the role distinction must change F')
+    good, controls = global_operator()
+    need(good and controls == 18, 'full nine-stage operator')
+    need(all(not global_operator(i)[0] for i in range(controls)), 'omitted bridge detected')
+    return dict(local_common_rank=[2, 3], global_bank_rows=8,
+                independent_address_states=1024, formal_basis_columns=8192,
+                omitted_bridge_controls=controls, final_operator='D_full on all eight data banks')
+
+
+def check_slots(slots, windows, a):
+    occupied = set()
+    identities = set()
+    for i, family, off, width, stage, helper in slots:
+        pair, rank, stages = windows[i]
+        need(stage in stages and family//(2*V) == pair and off+width <= rank,
+             'chronological owner contract')
+        need(off >= 0 and width == 8 and 0 <= family < 8*V, 'owner coordinate domain')
+        identity = (stage, helper)
+        need(identity not in identities, 'duplicate helper')
+        identities.add(identity)
+        # The first residual block starts after the common (8-a)-plane.
+        first = 0 if i in (0, 2, 4) else (i+1 if i < 6 else 2*pair+3)
+        start = 8-a+first*a
+        for coordinate in range(start+off, start+off+width):
+            key = (family, coordinate)
+            need(key not in occupied, 'overlapping absolute owner coordinates')
+            occupied.add(key)
+
+
+def flow_owners(win, a, helpers):
+    """Integral augmenting paths, then literal family/coordinate allocation."""
+    windows = {i: (p, rank*a//7, sorted(stages)) for i, (p, rank, stages) in win.items()}
+    source, sink = 0, 20
+    cap, adjacent = {}, {i: [] for i in range(21)}
+
+    def edge(u, v, c):
+        cap[u, v], cap[v, u] = c, 0
+        adjacent[u].append(v)
+        adjacent[v].append(u)
+
+    for s in range(9):
+        edge(source, 1+s, helpers)
+    for i, (_, rank, stages) in windows.items():
+        edge(10+i, sink, 2*V*(rank//8))
+        for s in stages:
+            edge(1+s, 10+i, 9*helpers)
+    total = 0
+    while True:
+        parent, queue = {source: None}, deque([source])
+        while queue and sink not in parent:
+            u = queue.popleft()
+            for v in adjacent[u]:
+                if v not in parent and cap[u, v] > 0:
+                    parent[v] = u
+                    queue.append(v)
+        if sink not in parent:
+            break
+        path, v = [], sink
+        while v != source:
+            u = parent[v]
+            path.append((u, v))
+            v = u
+        push = min(cap[e] for e in path)
+        for u, v in path:
+            cap[u, v] -= push
+            cap[v, u] += push
+        total += push
+    need(total == 9*helpers, 'unhosted helper demand')
+    slots, allocation, next_helper, rem = [], [], Counter(), Counter()
+    for i, (pair, rank, stages) in sorted(windows.items()):
+        demands = []
+        for stage in stages:
+            count = cap[10+i, 1+stage]
+            if count:
+                allocation.append([i, stage, count])
+                demands.extend([stage]*count)
+        used = Counter()
+        for pos, stage in enumerate(demands):
+            copy, block = divmod(pos, rank//8)
+            need(copy < 2*V, 'owner overflow')
+            side, port = divmod(copy, V)
+            family = (2*pair+side)*V+port
+            offset = 8*block
+            slots.append([i, family, offset, 8, stage, next_helper[stage]])
+            used[copy] += 8
+            next_helper[stage] += 1
+        for copy in range(2*V):
+            if rank-used[copy]:
+                rem[rank-used[copy]] += 1
+    need(next_helper == Counter({s: helpers for s in range(9)}), 'helper identity coverage')
+    check_slots(slots, windows, a)
+    global_hash = hashlib.sha256()
+    for replica in range(T):
+        for i, family, offset, width, stage, helper in slots:
+            translated = replica*8*V+family
+            need(replica*8*V <= translated < (replica+1)*8*V <= W, 'replica owner range')
+            global_hash.update(json.dumps([replica, i, translated, offset, width, stage, helper],
+                                           separators=(',', ':')).encode()+b'\n')
+    return dict(helpers_per_stage=helpers, windows=windows, allocation=allocation,
+                slots_per_replica=len(slots), global_slots=len(slots)*T,
+                owner_slots_sha256=digest(slots), remainder=dict(sorted(rem.items())),
+                translated_global_slots_sha256=global_hash.hexdigest(),
+                total_slot_capacity=sum(2*V*(r//8) for _, r, _ in windows.values())), rem, slots
+
+
+def mass(h):
+    return sum(r*n for r, n in h.items())
+
+
+def monotone_closure(word, budget):
+    """Smallest span constraints for the retained scalar order, with COPY
+    arrivals granted frame zero. This permits more freedom than the word.
+    It only excludes monotone re-framing, not paid descents or new topology.
+    """
+    v = word['v']
+    frames = [1 << i for i in range(v)] + [0]*(v+word['R'])
+    cache, result = {}, {}
+    for section in ('D', 'A', 'B', 'C'):
+        for _, dst, srcs in word[section]:
+            roles = [dst, *srcs]
+            joined = 0
+            for r in roles:
+                joined |= frames[r]
+            for r in roles:
+                frames[r] = joined
+        dims = Counter()
+        for mask in frames[:v]:
+            if mask not in cache:
+                cache[mask] = budget.rational_rank(word['lines'][i] for i in range(v) if mask >> i & 1)
+            dims[cache[mask]] += 1
+        result[section] = dict(sorted(dims.items()))
+    need(result['B'] == {4: 3, 7: 108}, 'pre-cleanup least-frame ranks')
+    need(result['C'] == {8: 111}, 'fixed scalar cleanup forces full sources')
+    need(any(r < 8 for r in result['B']), 'omitting cleanup changes closure control')
+    return dict(source_ranks_after_phase=result, copy_arrivals='granted frame zero',
+                scope='Retained scalar order and monotone frames only; new source topology or paid descents remain outside.')
+
+
+def main(out):
+    pins = json.loads((HERE/'SOURCES.json').read_text())
+    for path, sha in pins['files'].items():
+        need(hashlib.sha256((ROOT/path).read_bytes()).hexdigest() == sha, 'source hash: '+path)
+    budget = module('paired_budget', 'research/bit-role-sharing-budget/verify.py')
+    hosting = module('paired_hosting', 'research/bit-sharing-hosting-gate/verify.py')
+    old = module('paired_mercator', 'research/complex-k492-owner-repair/vendor/multicold/engines/moment.py')
+    wp = ROOT/'research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz'
+    word = json.loads(gzip.decompress(wp.read_bytes()))
+    expected = json.loads((ROOT/'research/e8-bit-p111-tuned/tune/EXPECTED.json').read_text())
+    local, columns = budget.extract_word(word, expected['word'])
+    scalar_adds = sum(len(srcs) for section in ('D', 'A', 'B', 'C')
+                      for _, _, srcs in word[section]) + sum(map(len, word['scatter']))
+    need(scalar_adds == 24305, 'source access and scalar scan invoice')
+    win = hosting.windows(hosting.schedule())
+    controls = []
+
+    def reject(name, fn):
+        try:
+            fn()
+        except ValueError:
+            controls.append(name)
+        else:
+            raise ValueError('negative control accepted: '+name)
+
+    def price(h):
+        h = Counter({r: n for r, n in h.items() if n})
+        lo, hi = budget.moment(h, RATE)
+        lo2, hi2 = old.moment(h, 64, W, RATE, True)
+        need(max(lo, lo2) <= min(hi, hi2), 'price engine disagreement')
+        need((hi < 1 and hi2 < 1) or (lo > 1 and lo2 > 1), 'strict sign unresolved')
+        return dict(profile=dict(sorted(h.items())), rank_mass=mass(h),
+                    net_global_credit=1808352-mass(h),
+                    net_credit_per_invocation=str(Q(1808352-mass(h), 288)),
+                    moment_interval=[str(lo), str(hi)], moment_display=old.decimal(hi),
+                    strict_rate=str(RATE), passes_rate=hi < 1,
+                    passes_100_units=1808352-mass(h) >= 28800,
+                    supplier_admitted=False)
+
+    owners, rem, slots = flow_owners(win, 5, 296)
+    need(owners['total_slot_capacity'] == 9*296, 'sharp slot capacity')
+    reject('297 width-eight helpers at three-dimensional boundary', lambda: flow_owners(win, 5, 297))
+    corrupt = [x[:] for x in slots]
+    corrupt[0][4] = next(s for s in range(9) if s not in owners['windows'][corrupt[0][0]][2])
+    reject('helper outside chronological window', lambda: check_slots(corrupt, owners['windows'], 5))
+    corrupt = [x[:] for x in slots]
+    corrupt[1][1:4] = corrupt[0][1:4]
+    reject('overlapping physical coordinates', lambda: check_slots(corrupt, owners['windows'], 5))
+    common = Counter({16: W})
+    common.update({r: n*T for r, n in rem.items()})
+    ideal = common.copy()
+    ideal.update({5: 288*222, 7: 288*9, 8: 288*296})
+    unit = common.copy()
+    unit[1] += 288*(222*5+9*7+296*8)
+    repaired = unit.copy()
+    repaired[1] += 31*288
+    failed_repair = unit.copy()
+    failed_repair[1] += 32*288
+    prices = {name: price(h) for name, h in [('one_child_per_role_oracle', ideal),
+              ('all_local_units_at_rank_one_oracle', unit),
+              ('oracle_plus_31_repairs_per_invocation', repaired),
+              ('oracle_plus_32_repairs_per_invocation', failed_repair)]}
+    need(prices['oracle_plus_31_repairs_per_invocation']['passes_rate'], '31 repair margin')
+    need(prices['oracle_plus_31_repairs_per_invocation']['passes_100_units'], 'net goal margin')
+    need(not prices['oracle_plus_32_repairs_per_invocation']['passes_rate'], '32 repair fence')
+    need(mass(ideal) == mass(unit) == 1751520, 'boundary deficit and padding accounting')
+
+    # A concrete realization from the old word uses clean owned helpers and
+    # pays the two rank-(k-1) endpoint wrappers. No productive owner is freed.
+    wrapped = Counter({r: 288*n for r, n in local.items()})
+    wrapped[2] += 288*222
+    wrapped[16] += W
+    for _, rank, _ in win.values():
+        if rank:
+            wrapped[rank*5//7] += 2*V*T
+    prices['concrete_wrapped_word_owned_helpers'] = price(wrapped)
+    need(not prices['concrete_wrapped_word_owned_helpers']['passes_rate'], 'wrapper cannot pass')
+    reject('dropping concrete wrapper rank charges',
+           lambda: need(mass(wrapped)-288*222*2 == mass(wrapped), 'unpaid boundary change'))
+
+    # Gaussian rank-two alternative: assuming C>=80 rational rank, the
+    # cost/deficit ceiling is below 0.0078 for every odd B_K stage count.
+    # This is conditional on that external copy floor and the stated format.
+    gaussian = []
+    for K in range(1, 43):
+        s, a, m = 2*K+1, 6, 2+(2*K+1)*6
+        D = Q(4*K-4, 3)
+        slots = [(12*s, 6), (Q(4*s, 3), 8)]
+        ranks = ([12*(K-1)] if K > 1 else [])
+        for p in range(1, K):
+            ranks.extend([12*p, 6])
+            if K-p-1:
+                ranks.append(12*(K-p-1))
+        slots += [(2*r, max(r, 8)) for r in ranks]
+        cost_lo = sum(z*budget.log_interval(Q(m, cap))[0] for z, cap in slots)
+        bound = D/cost_lo
+        need(bound < Q(78, 10000), 'Gaussian finite stage ceiling')
+        gaussian.append([s, str(bound)])
+    need(Q(1, 3*44) < Q(78, 10000), 'Gaussian analytic tail starts at K=43')
+
+    result = dict(status='PASS_PAIRED_BOUNDARY_PREFLIGHT_NOT_A_SUPPLIER',
+        goal_status='ACTIVE_UNACHIEVED', geometry=geometry(word['lines']),
+        operator=local_operator(), inherited_local_replay=columns,
+        retained_word_monotone_obstruction=monotone_closure(word, budget),
+        conditional_hosting=owners, prices=prices,
+        concrete_owned_stock=dict(productive=W, private_helpers=439, centers=9,
+                                  physical=W+439+9, helper_initialization_scans=439,
+                                  helper_final_state='zero, reusable after every completed invocation'),
+        concrete_nonrecursive_bill=dict(local_aligned_xor_scans=scalar_adds*288,
+             bridge_aligned_xor_scans=18*V*T, inherited_center_copy_clear_episodes=9*288,
+             extra_wrapper_children=222*288, extra_wrapper_child_rank=2,
+             scope='These scans and source reads remain charged. New chart/descriptor/head-return constants are not generated; their favorable omission already fails the recursive cost gate.'),
+        target_owned_stock=dict(productive=W, centers=9, physical=W+9,
+                               helpers='all borrowed from 85248 exclusive reservations'),
+        gaussian_conditional_ceiling=dict(rational_copy_floor=80, real_ports=60,
+             finite_stage_linear_bounds=gaussian, tail='1/(3*(K+1)) for K>=43',
+             supplier_saving_upper='39/5000', copy_floor_reproved=False),
+        controls=controls,
+        missing=['A legal local scalar word with P->Q-perp and Q->P-perp endpoints, rank(Q)=2.',
+                 'At most 296 width-eight helper paths and COPY rank at most 63, with every dirty input restored.',
+                 'Source access, route, controller, finite stock and all-size interfaces for that new word.'])
+    text = json.dumps(result, indent=2, sort_keys=True)+'\n'
+    need(not out.exists(), 'output already exists')
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(text)
+    print(result['status'])
+
+
+if __name__ == '__main__':
+    ap = argparse.ArgumentParser()
+    ap.add_argument('--out', type=Path, required=True)
+    main(ap.parse_args().out)
diff --git a/research/bit-role-sharing-budget/CLAIM.json b/research/bit-role-sharing-budget/CLAIM.json
new file mode 100644
index 0000000000..823e45feca
--- /dev/null
+++ b/research/bit-role-sharing-budget/CLAIM.json
@@ -0,0 +1,27 @@
+{
+  "continuation_of": "https://github.com/CrocSwap/integer-mult-bounds/pull/673",
+  "base_commit": "bfff94e78f0e75ebd2593e3cc7710ae5290e8be3",
+  "authorization": "User explicitly requested bit-first work sharing across roles, with the full cost priced before construction. This specifies the continuation track; no new random assignment.",
+  "candidates": [
+    "Pool identical child calls on invertible XOR encodings of independent roles, charging full batch volume.",
+    "Share retained-total response and consolidate all intra-stage frame work, preserving the paid rank mass and idle profile.",
+    "Fuse work across multiple compressed stages; determine the necessary rank, coverage and repair budget before seeking an operator."
+  ],
+  "selected_scope": "Budget-first comparison of these linked sharing classes on the pinned PR589 bit invoice, exact extraction of the local word profile and a direct-sum query obstruction. Do not build a supplier unless its whole invoice is profitable.",
+  "domain": "m=64, W=28416, 32 replicas, 9 stages; unchanged boundary/idle remainder; target saving 1/99, corresponding to necessary rate for kappa=0.01. Rank caps 1..63, pool sizes 1,2,4,8,16,32.",
+  "stopping_rule": "Reject a sharing class when even its optimistic full moment exceeds one; label any passing arithmetic relaxation as an unconstructed target.",
+  "coordination": "Continued PR673; final queue refresh through PR716, with no reviews or comments on the unchanged parent head. No pinned coordination issue exists. PR705 is a complex graded-path obstruction; PR708 shares scalar decoder operands; PR714 changes clean checkpoint ownership; PR715 changes mixed-port labels. None is a dependency of this screen.",
+  "result": {
+    "status": "COMPLETED_BUDGET_FIRST_SCREEN_NO_NEW_KAPPA",
+    "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/673",
+    "rejected": [
+      "Identical-call pooling as a way to reduce volume-weighted recursive cost",
+      "Rank-mass-preserving local rank-eight consolidation for kappa=0.01, even with free retained-total copies"
+    ],
+    "remaining_arithmetic_targets": [
+      "At fixed boundaries/mass, cap >=56; rank57 integer invoice permits only 431 extra rank1 children and needs over 98.48 percent of local mass fused.",
+      "With ideal rank8 consolidation and fixed boundaries/volume, at least 100 net paid rank units removed per local invocation; 99 fails."
+    ],
+    "scope": "Passing relaxed invoices do not supply an operator or hosting. Fixed-port stage counts do not apply to arbitrary cross-port fusion. No replacement supplier was built."
+  }
+}
diff --git a/research/bit-role-sharing-budget/PROOF.md b/research/bit-role-sharing-budget/PROOF.md
new file mode 100644
index 0000000000..99638c3e54
--- /dev/null
+++ b/research/bit-role-sharing-budget/PROOF.md
@@ -0,0 +1,227 @@
+# Bit role sharing: a budget gate before supplier construction
+
+This continues PR673 at `bfff94e78f0e75ebd2593e3cc7710ae5290e8be3`.
+The user selected a bit-first sharing investigation. All comparisons below
+use PR589's actual punctured/tuned local word and its frozen nine-stage
+hosting invoice. No new supplier, all-size theorem or kappa is asserted.
+
+## 1. The complete retained invoice
+
+The ambient rank is m=64, the live volume denominator is W=28416, and there
+are 9 stages times 32 replicas, or 288 local invocations. Replaying every
+Boolean column and every nested frame of the actual local word gives
+
+    Hlocal = {1:1323, 2:1342, 3:79, 4:44, 5:102, 6:11, 7:19}.
+
+Its rank mass 5129 is the sum of source growth 777, target growth 777,
+helper growth 3512, and nine rank-7 COPY charges 63. The first three
+quantities equal 7v, 7v and 8R for v=111 and R=439. Cleanup is executed,
+not discarded; all 661 independent source/target/dirty columns have the
+required restored endpoint. The COPY response matrix has Boolean rank 9,
+and its nine input totals are independent in the full dirty-input domain.
+Thus a linear response encoder of these same totals needs at least nine
+independent encoded scalars. This does not restrict a different producer.
+
+The unchanged hosting remainder is
+
+    Hidle = {2:13920, 4:14208, 6:14208, 7:21312, 42:288}.
+
+The full invoice is 288 Hlocal + Hidle. Its rank mass is 1808352, its
+deficit from Wm is 10272, and the local part's rank mass is 1477152.
+These figures are recomputed and compared with the pinned global receipt.
+This is an independent local replay and invoice check, not a fresh physical
+hosting or all-size audit of PR589.
+
+For saving c, the charged moment, including the retained bad-class fallback,
+is
+
+    Phi(H,c) = sum_r H[r] r/(mW) (m/r)^c
+               + 32m sum_r H[r]/(10^16 W) m^c.
+
+Each fallback has at most 32m² width-1 children on a bad fraction below
+10^-16. The moment at c=1/99 is approximately 1.027739494928555. The outer
+assembly requires BOTH supplier savings strictly above kappa/(1-kappa),
+so 1/99 is a necessary threshold for kappa=0.01. Even equality of a supplier
+root to 1/99 would be insufficient. The complex endpoint is unchanged here.
+
+The inherited live denominator is used exactly. The receipt separately
+records physical storage 28425, including nine typed center slots whose
+copy work is charged. Those slots do not become free arbitrary-data roles
+for a new sharing scheme. A new private array requires an actual ownership,
+hosting and endpoint contract; increasing W by a fictitious free role is
+not permitted in any comparison below.
+
+## 2. Pooling equal work across arbitrary roles
+
+Suppose B independent roles need the same nonidentity address permutation P.
+Batching their calls changes B dispatches of volume V/W into one dispatch
+of volume BV/W. Since the retained child bound is linear in data volume,
+
+    B C(V/W, re/m) = C(BV/W, re/m)
+
+at the level of the charged leading coefficient. This also holds for the
+fallback: each bad child acts on the whole batch. Remainders in a partial
+batch must retain their own volume. Encoding, decoding, moving and restoring
+data adds nonnegative work. Even granting all that work free leaves exactly
+the original moment. For fixed B, linear XOR/routing passes may affect
+constants but do not reduce the paid recursive coefficient. No fixed-tape
+implementation of a new pooling adapter is needed to reject this budget.
+
+Could an XOR encoding reduce the queried volume instead? In the following
+explicit model it cannot. Permit arbitrary invertible row charts S tensor I
+over F2, interleaved with calls applying the fixed P to one role. Any number
+of arbitrary dirty private roles may be included and must be restored.
+Require P on B active roles and identity on the private roles.
+
+P fixes the nonzero constant-address vector. Restricted to this invariant
+sector, every query is identity, so the product of all role charts must be
+identity. Move these charts to the end by conjugation and cancel their
+product. Each remaining query Q satisfies
+
+    rank(Q-I) = rank(P-I).
+
+Conjugation preserves this rank. The product inequality
+rank(AB-I) <= rank(A-I)+rank(B-I) therefore bounds the final displacement
+rank by q rank(P-I), where q is the number of one-role queries. The required
+endpoint has displacement rank B rank(P-I), so q>=B. If a query applies P
+to b roles at once, it contributes b rank(P-I), giving sum b>=B: the same
+volume floor. B direct calls attain the query count while preserving dirt.
+
+This is a fixed-P, address-independent invertible-XOR-chart result. It does
+not cover address-dependent charts, a different native ADDRESS primitive,
+changed endpoint obligations, or a circuit that jointly eliminates distinct
+operator types. In particular it does not assert an unrestricted direct-sum
+lower bound for algorithms. PR677 treats a different DATA-shear endpoint;
+its two/four/one-query conclusions are not used here.
+
+The finite oracle enumerates all 108 choices of GL(2,2) before/after charts
+and zero or one query, rejecting each as an all-role implementation. Direct
+programs with 1..8 active roles and 0..3 dirty private roles check 384 basis
+columns. The arbitrary-size result rests on the rank argument, not those
+finite examples.
+
+## 3. Perfect sharing confined to local stage widths still misses 0.01
+
+For 0<c<1, the cost per rank unit at child width r is (m/r)^c/(mW), decreasing
+with r. With a preserved rank mass S and a maximum child rank J, the most
+optimistic fractional histogram places S/J calls at rank J. It also
+minimizes the fallback call count. This is a relaxation: fractions of calls,
+merging different roles without paying added volume, and eliminating scalar
+work are all granted. Failure of this stronger budget rejects any actual
+rank-mass-preserving profile in this class under the retained charge.
+
+Keep Hidle exactly, and set J=8 for all local work. This grants the full
+eight-dimensional local frame even though no current local child exceeds 7.
+The moment at 1/99 is about 1.016042715946274. Its strict root bracket gives
+a bit-only outer ceiling below 0.002644610326897. This does not claim that
+the hypothetical consolidation can be implemented.
+
+Now erase ALL nine COPY charges in every invocation as a further gift:
+remove 288*63=18144 rank units, while keeping W and Hidle. Consolidate every
+remaining local rank unit at rank 8 again. The target moment is still about
+1.005854169251071; the bit-only outer ceiling is below 0.007315906873875.
+Thus even completely free retained-total copying plus perfect width-eight
+sharing does not reach 0.01 with these boundary costs. Real elimination of
+COPY obligations is not established or inferred from this relaxation.
+
+This conclusion is about the retained rank mass/boundaries and the stated
+rank cap. Sharing that changes the total rank mass or boundary obligations
+requires a different invoice and is not excluded.
+
+An exact alternative target quantifies that escape. With ideal rank-8
+consolidation and Hidle/W fixed, removing 99 net rank units per local
+invocation gives moment 1.0000321425680974 and fails. Removing 100 gives
+0.9998704196046815 and passes as an arithmetic relaxation. This is 28800
+net units globally, compared with only 18144 from erasing every COPY charge.
+The requirement is a reduction of the complete paid invoice AFTER hosting.
+Reducing helper count alone need not deliver it: the retained rank-mass
+identity fixes the deficit independently of R, and unoccupied owner
+directions return as paid idle work. Scalar shortening alone is insufficient.
+
+## 4. A concrete cross-stage target and its very small repair allowance
+
+Retain Hidle and the original local rank mass. Evaluate the fractional lower
+bound for every cap J=1..63 at c=1/99. Cap 55 still fails; cap 56 is the first
+that passes. If ALL rank mass, including Hidle, may be repacked freely, cap
+36 still fails and cap 37 is the first passing relaxation. These thresholds
+are necessary conditions for the respective preserved-mass classes, not
+existence claims for operators or charts.
+
+There is a useful but restricted stage-fusion ansatz. For a fixed port q,
+the positive-stage active spaces are the common line P_q plus disjoint
+seven-dimensional exterior blocks. Stage zero is the original eight-space.
+A union of s such active spaces has dimension at most 1+7s. Under this
+fixed-port restriction, seven stages give cap 50 and still fail with the
+fixed remainder; at least eight are needed. If the whole remainder is also
+redesigned, five give cap 36 and at least six are necessary.
+
+This is NOT an unrestricted stage-count lower bound for role sharing. The
+port lines collectively span eight dimensions: seven positive stages with
+different ports can span 8+7*7=57, while the fixed-port calculation gives
+only 50. The checker explicitly records this countercontrol. Changed helper
+hosting/charts also need their own support calculation. The rank-cap
+threshold 56 is unaffected, but it cannot be converted to a universal
+eight-stage requirement. No span calculation supplies an admissible operator.
+
+For an explicit arithmetic target, pack the local mass into as many rank-J
+calls as possible plus one remainder call, and retain Hidle. This produces
+integer hypothetical invoices with the same total rank mass and W. All
+fallback children are charged. The following are whole-program allowances,
+across all 288 local invocations, at the threshold c=1/99:
+
+| J | Target moment | Additional rank-1 child allowance | Local mass needing fusion from ideal rank-8 calls |
+|---|---:|---:|---:|
+| 56 | 0.9998980605101204 | 177 | more than 99.3681% |
+| 57 | 0.9997526042747312 | 431 | more than 98.4812% |
+| 63 | 0.9989309632236760 | 1864 | more than 93.7523% |
+
+The allowances include the additional fallback charge and have exact integer
+fences: that many extra rank-1 children still have a strict passing interval,
+and one more fails. Higher-rank repair children generally consume more of the
+budget. Extra volume, new private rows, changed existing boundaries or a
+different fallback rule require repricing the entire invoice. Routing and
+scalar constants are not silently converted into negative recursive work.
+
+The coverage column linearly interpolates between the rank-8 relaxation and
+the fully fused fractional cap-J relaxation, including their fallback counts.
+It is an optimistic minimum on the *rank mass* needing the larger children,
+not a percentage of original instructions. The integer invoice/allowance and
+fractional coverage screen are distinct diagnostics.
+
+This makes the next possible construction specific: a joint high-rank
+operator at fixed live volume, accomplishing almost all the retained local
+work with rank-57 children, while leaving fewer than 432 new rank-1 repair
+calls in the full program. The fixed-port version would span at least eight
+stages; cross-port fusion is a different, potentially wider class. One extra
+rank-1 repair per local invocation (288
+total) fits this generous invoice; two per invocation (576) do not. No such
+operator, legal chronological frame path, common-label realization, or
+hosting plan is supplied. Consequently we stop before implementing a supplier.
+Passing this arithmetic target is a gate for further research, not admission.
+
+## 5. Independent arithmetic and controls
+
+The checker reads and hashes the pinned inputs, reconstructs the local word
+profile, and adds the literal frozen remainder from fastc.py. Its interval
+engine is independent of the inherited Mercator implementation: after binary
+argument reduction it uses 96 positive terms of
+
+    log x = 2 sum_(j>=0) z^(2j+1)/(2j+1), z=(x-1)/(x+1),
+
+and a geometric upper bound on the remaining tail. A degree-28 exponential
+polynomial and a geometric remainder bound enclose exp on [0,0.1). Outward
+224-bit dyadic rounding preserves inclusion. The original bit root is checked
+at both adjacent 10^-24 endpoints, providing an external arithmetic control.
+
+Meaningful false-gain controls omit the pool volume, omit Hidle, check only
+the zero-saving deficit, or allow a rank-m recursive call. All are rejected
+as admissions. The full harness supports isolated optimized Python; checks
+do not depend on assertions. Exact endpoints are in evidence/PRICE.json.
+
+Credit: PR589 and eumemic's punctured/tuned word; DreamingOfClouds' geometry
+and nine-stage chain; chafreaky's whole-residual hosting; their preserved
+OpenAI/Claude and construction notices. PR679 (Greer Guthrie) independently
+emphasizes the volume charge for a different complex selector construction.
+PR677 (commdata2338) audits fixed-native-query DATA shear contracts. Elementary
+matrix-rank and concave-moment arguments carry no priority claim. Prepared
+for @androolloyd with substantial OpenAI Codex assistance. Apache-2.0.
diff --git a/research/bit-role-sharing-budget/README.md b/research/bit-role-sharing-budget/README.md
new file mode 100644
index 0000000000..99cf2d8659
--- /dev/null
+++ b/research/bit-role-sharing-budget/README.md
@@ -0,0 +1,107 @@
+# Bit role sharing: cost first, no new κ
+
+This is the budget gate requested before building a shared-role bit supplier.
+It extracts the paid profile from the actual pinned PR589 word, checks every
+local Boolean column, and prices complete hypothetical profiles with the
+retained boundaries, live volume and bad-class charge.
+
+**Decision:** do not build identical-role pooling or a sharing scheme confined
+to one stage for κ=0.01. Pooling saves dispatches but not volume-weighted
+recursive work. Even perfect rank-8 consolidation plus free retained-total
+copies fails the target. Sharing that changes rank mass or stage boundaries
+remains open.
+
+| Screen | Result at necessary bit saving 1/99 |
+|---|---|
+| Existing complete profile | Moment 1.02773949493: fails |
+| Pool identical calls across arbitrary roles | Same moment after batch volume is charged |
+| Perfect local consolidation into rank 8 | Moment 1.01604271595: fails |
+| Same, with all retained-total copies free | Moment 1.00585416925: fails |
+| Preserve boundaries and rank mass; increase child rank cap | Cap 55 fails; cap 56 first permits an optimistic passing invoice |
+| Repack all boundaries as well, preserving total rank mass | Cap 36 fails; cap 37 first permits a passing relaxation |
+
+The hypothetical rank-57 invoice leaves room for only **431 extra rank-1
+children across the whole program**, including their fallback charge. It
+requires fusing more than **98.48% of the local rank mass**, even when the
+unfused work is granted ideal rank-8 calls. Fusion restricted to one port's
+active spaces would need at least eight stages; cross-port fusion can have a
+larger span and is not subject to that stage-count argument. This is a precise design requirement,
+not a construction or a proposed κ certificate. The complex endpoint would
+also need to improve for κ=0.01.
+
+An alternative arithmetic target is **100 net rank units removed per local
+invocation**, plus ideal rank-8 consolidation, with the boundary remainder
+and live denominator fixed. Removing 99 fails the target; removing 100
+passes. This is an invoice reduction after hosting, not a helper-count or
+scalar-gate reduction. No mechanism achieving it is supplied.
+
+The [hosting follow-up](../bit-sharing-hosting-gate/README.md) tests a
+running decoder cache and reconstructs every physical helper reservation.
+Thirteen free helper eliminations give 104 gross units but zero net units
+after owner restoration. With the rank-7 data boundaries preserved, the
+corresponding favorable consolidation screen first passes at 102 units.
+This refines the implementation requirements; it does not invalidate the
+rank-8 relaxation above or supply a replacement operator.
+
+[PROOF.md](PROOF.md) states the fixed-query direct-sum obstruction, complete
+cost ledger, relaxation domains, thresholds and repair allowance. Unlike the
+earlier three-shear adapter obstruction, its role-query argument allows
+arbitrary invertible XOR mixing and any restored dirty private roles. Its
+scope is a fixed address permutation; distinct native primitives and
+address-dependent charts are outside it.
+
+## Reproduce
+
+From the repository root, standard-library Python only:
+
+```sh
+sh research/bit-role-sharing-budget/replay.sh /tmp/bit-role-sharing-budget
+```
+
+Use a new output directory. Expected:
+
+```text
+PASS_BIT_ROLE_SHARING_COST_SCREEN_NO_NEW_KAPPA
+PASS_BIT_ROLE_SHARING_REPLAY
+```
+
+The verifier also supports `python3 -I -O -B`. Its positive-atanh rational
+interval engine is separate from the inherited Mercator engine and reproduces
+the pinned adjacent 10^-24 bit root bracket. The finite coverage is 661 local
+Boolean columns, all local frame transitions, all caps 1..63, pool sizes
+1/2/4/8/16/32, 108 small coded-query programs and 384 positive-control basis
+columns. Four incomplete-cost controls are rejected. No random or open-ended
+search is involved.
+
+[evidence/PRICE.json](evidence/PRICE.json) contains the exact intervals and
+conditional integer profiles. [SOURCES.json](SOURCES.json) binds every input.
+The frozen global remainder is repriced, not freshly rehosted. The physical
+supplier, all-size compiler, new storage/layout and new tape program are not
+built because neither pooling nor stage-confined sharing passes the target
+budget. The rank-57 arithmetic target has no supplied operator.
+
+## Provenance and overlap
+
+Base: `bfff94e78f0e75ebd2593e3cc7710ae5290e8be3`; original main base:
+`66849e1475c930fd7732b1a0067ffee7e1e95f60`. PR589 pin:
+`a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46`. The selected result, producer,
+profiles and upstream source are unchanged. This continues
+[PR673](https://github.com/CrocSwap/integer-mult-bounds/pull/673).
+
+The queue review through #700 found separate scalar-word optimizations
+(#694/#696), a complex RAM direct-source construction (#697), the different
+fixed-native-query DATA shear (#677), and complex selector volume pricing
+(#679). Those are context, not consumed dependencies. Existing closed local
+word searches are not rerun: the new object is a sharing-class cost screen
+with arbitrary role mixing and explicit cross-stage target budgets.
+
+The final refresh through #716 also checked #705's complex graded-path
+determinant obstruction, #708's scalar decoder sharing, #714's clean root
+checkpoint and #715's mixed-port label extension. They change different
+objects or contracts and are not dependencies of this cost screen. No pinned
+sprint coordination issue was present; the completed claim is local.
+
+Credit eumemic, DreamingOfClouds, chafreaky and their retained source lineage;
+Greer Guthrie's related volume-accounting note and commdata2338's query-model
+audit. Prepared for **@androolloyd with substantial OpenAI Codex assistance**,
+under Apache-2.0. Finite verification is not a formal proof of multiplication.
diff --git a/research/bit-role-sharing-budget/SOURCES.json b/research/bit-role-sharing-budget/SOURCES.json
new file mode 100644
index 0000000000..b0edcd673c
--- /dev/null
+++ b/research/bit-role-sharing-budget/SOURCES.json
@@ -0,0 +1,15 @@
+{
+  "base_commit": "bfff94e78f0e75ebd2593e3cc7710ae5290e8be3",
+  "pr589": "a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46",
+  "files": {
+    "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f",
+    "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4",
+    "research/e8-bit-p111-tuned/tune/fastc.py": "ae51f1fbb22b8c8dac8aab787c798361f6aa5d4e1fefb29e43d0197899d4eab5",
+    "research/e8-bit-p111-tuned/tune/README.md": "46c7917fb252949f38b7bcd88cf568efc282e3ea065b61d11e457e41673d0b2d",
+    "research/e8-bit-p111/README.md": "481431e35bd831ec3d0bb8edc01abdfa49d5caeabebab67ac839a35053e9ef85",
+    "research/e8-bit-p111-tuned/code/adapt9p.py": "14365d0eb8f4a7352edd28816196148fd28d5bbcb36044ebeeb15ca051bca9de",
+    "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8",
+    "certificates/selected-result.json": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53",
+    "research/e8-bit-carrier-skeleton/code/nine/geometry.py": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca"
+  }
+}
diff --git a/research/bit-role-sharing-budget/VALIDATION.json b/research/bit-role-sharing-budget/VALIDATION.json
new file mode 100644
index 0000000000..a4f4de3e87
--- /dev/null
+++ b/research/bit-role-sharing-budget/VALIDATION.json
@@ -0,0 +1,31 @@
+{
+  "status": "PASS_BUDGET_FIRST_SHARING_SCREEN",
+  "verified_at_utc": "2026-10-13T04:48:01.771479+00:00",
+  "python": "3.14.7",
+  "platform": "Darwin",
+  "base_commit": "bfff94e78f0e75ebd2593e3cc7710ae5290e8be3",
+  "checks": {
+    "combined_replay": "PASS_DIRTY_ECHO_ALIAS_REPAIR_AND_FINE_GRID",
+    "standalone_relocated_minimal_replay": "PASS_BIT_ROLE_SHARING_REPLAY",
+    "normal_vs_isolated_optimized_evidence": "byte-identical",
+    "independent_Mercator_crosscheck": "133 complete hypothetical invoices have intersecting exact enclosures",
+    "damaged_scatter": "rejected by local Boolean endpoint or response-rank check",
+    "corrupt_source_pin_under_optimized_Python": "rejected before evidence output",
+    "corrupt_expected_evidence": "replay rejects",
+    "selected_record_integrity": "pass",
+    "unchanged_upstream_and_inherited_bit_supplier": "pass against base",
+    "syntax_local_links_staged_whitespace": "pass"
+  },
+  "external_crosscheck_engine": {
+    "path": "research/complex-k492-owner-repair/vendor/multicold/engines/moment.py",
+    "sha256": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482"
+  },
+  "price_sha256": "70b2f931660e381ded545b1edbe14d2ca37ebc02b501fddf59243db95a5781fd",
+  "combined_log_sha256": "48205bcc443b22ac0c696354162ef24d307d9e7c99ed3d8209af4ca18d28a86d",
+  "not_claimed": [
+    "A constructed sharing supplier or a new kappa",
+    "Fresh native bit hosting or all-size compilation",
+    "Remote CI or root-wide make verify",
+    "An unrestricted eight-stage or direct-sum impossibility theorem"
+  ]
+}
diff --git a/research/bit-role-sharing-budget/evidence/PRICE.json b/research/bit-role-sharing-budget/evidence/PRICE.json
new file mode 100644
index 0000000000..85d5af54d1
--- /dev/null
+++ b/research/bit-role-sharing-budget/evidence/PRICE.json
@@ -0,0 +1,1017 @@
+{
+  "status": "PASS_BIT_ROLE_SHARING_COST_SCREEN_NO_NEW_KAPPA",
+  "source_hashes": {
+    "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f",
+    "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4",
+    "research/e8-bit-p111-tuned/tune/fastc.py": "ae51f1fbb22b8c8dac8aab787c798361f6aa5d4e1fefb29e43d0197899d4eab5",
+    "research/e8-bit-p111-tuned/tune/README.md": "46c7917fb252949f38b7bcd88cf568efc282e3ea065b61d11e457e41673d0b2d",
+    "research/e8-bit-p111/README.md": "481431e35bd831ec3d0bb8edc01abdfa49d5caeabebab67ac839a35053e9ef85",
+    "research/e8-bit-p111-tuned/code/adapt9p.py": "14365d0eb8f4a7352edd28816196148fd28d5bbcb36044ebeeb15ca051bca9de",
+    "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8",
+    "certificates/selected-result.json": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53",
+    "research/e8-bit-carrier-skeleton/code/nine/geometry.py": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca"
+  },
+  "local_word": {
+    "columns": 661,
+    "copy_ranks": [
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7
+    ],
+    "response_rank": 9,
+    "independent_retained_inputs": 9,
+    "role_climb_mass": {
+      "helper": 3512,
+      "source": 777,
+      "target": 777
+    },
+    "paid_histogram": {
+      "1": 1323,
+      "2": 1342,
+      "3": 79,
+      "4": 44,
+      "5": 102,
+      "6": 11,
+      "7": 19
+    },
+    "rank_mass": 5129
+  },
+  "baseline": {
+    "m": 64,
+    "live": 28416,
+    "profile": {
+      "1": 381024,
+      "2": 400416,
+      "3": 22752,
+      "4": 26880,
+      "5": 29376,
+      "6": 17376,
+      "7": 26784,
+      "42": 288
+    },
+    "rank_mass": 1808352,
+    "deficit": 10272,
+    "target_saving": "1/99",
+    "target_moment": [
+      "27707801970998165129328266358789862708758851972799718827248429472749/26959946667150639794667015087019630673637144422540572481103610249216",
+      "27707801970998165129328266358789862708758851972799718827248429472751/26959946667150639794667015087019630673637144422540572481103610249216"
+    ],
+    "idle_remainder": {
+      "2": 13920,
+      "4": 14208,
+      "6": 14208,
+      "7": 21312,
+      "42": 288
+    }
+  },
+  "role_pooling": [
+    {
+      "batch_size": 1,
+      "optimistic_dispatches": 904896,
+      "volume_weighted_invoice": {
+        "1": 381024,
+        "2": 400416,
+        "3": 22752,
+        "4": 26880,
+        "6": 17376,
+        "5": 29376,
+        "7": 26784,
+        "42": 288
+      },
+      "moment": [
+        "27707801970998165129328266358789862708758851972799718827248429472749/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27707801970998165129328266358789862708758851972799718827248429472751/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "batch_size": 2,
+      "optimistic_dispatches": 452448,
+      "volume_weighted_invoice": {
+        "1": 381024,
+        "2": 400416,
+        "3": 22752,
+        "4": 26880,
+        "6": 17376,
+        "5": 29376,
+        "7": 26784,
+        "42": 288
+      },
+      "moment": [
+        "27707801970998165129328266358789862708758851972799718827248429472749/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27707801970998165129328266358789862708758851972799718827248429472751/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "batch_size": 4,
+      "optimistic_dispatches": 226224,
+      "volume_weighted_invoice": {
+        "1": 381024,
+        "2": 400416,
+        "3": 22752,
+        "4": 26880,
+        "6": 17376,
+        "5": 29376,
+        "7": 26784,
+        "42": 288
+      },
+      "moment": [
+        "27707801970998165129328266358789862708758851972799718827248429472749/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27707801970998165129328266358789862708758851972799718827248429472751/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "batch_size": 8,
+      "optimistic_dispatches": 113112,
+      "volume_weighted_invoice": {
+        "1": 381024,
+        "2": 400416,
+        "3": 22752,
+        "4": 26880,
+        "6": 17376,
+        "5": 29376,
+        "7": 26784,
+        "42": 288
+      },
+      "moment": [
+        "27707801970998165129328266358789862708758851972799718827248429472749/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27707801970998165129328266358789862708758851972799718827248429472751/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "batch_size": 16,
+      "optimistic_dispatches": 56556,
+      "volume_weighted_invoice": {
+        "1": 381024,
+        "2": 400416,
+        "3": 22752,
+        "4": 26880,
+        "6": 17376,
+        "5": 29376,
+        "7": 26784,
+        "42": 288
+      },
+      "moment": [
+        "27707801970998165129328266358789862708758851972799718827248429472749/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27707801970998165129328266358789862708758851972799718827248429472751/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "batch_size": 32,
+      "optimistic_dispatches": 28278,
+      "volume_weighted_invoice": {
+        "1": 381024,
+        "2": 400416,
+        "3": 22752,
+        "4": 26880,
+        "6": 17376,
+        "5": 29376,
+        "7": 26784,
+        "42": 288
+      },
+      "moment": [
+        "27707801970998165129328266358789862708758851972799718827248429472749/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27707801970998165129328266358789862708758851972799718827248429472751/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    }
+  ],
+  "perfect_stage_fusion": {
+    "moment": [
+      "27392457433458425047329761990756784295993534871097284859676357994041/26959946667150639794667015087019630673637144422540572481103610249216",
+      "27392457433458425047329761990756784295993534871097284859676357994043/26959946667150639794667015087019630673637144422540572481103610249216"
+    ],
+    "root": {
+      "saving": [
+        "125219348060875964777/47223664828696452136960",
+        "313048370152189911943/118059162071741130342400"
+      ],
+      "kappa_ceiling_upper": "313048370152189911943/118372210441893320254343",
+      "kappa_ceiling_display": "0.00264461032689644"
+    }
+  },
+  "perfect_stage_fusion_and_free_copies": {
+    "moment": [
+      "27117774757939976671617400363038244478778758145754792667404733172295/26959946667150639794667015087019630673637144422540572481103610249216",
+      "27117774757939976671617400363038244478778758145754792667404733172297/26959946667150639794667015087019630673637144422540572481103610249216"
+    ],
+    "root": {
+      "saving": [
+        "870075224641220360369/118059162071741130342400",
+        "1740150449282440720739/236118324143482260684800"
+      ],
+      "kappa_ceiling_upper": "1740150449282440720739/237858474592764701405539",
+      "kappa_ceiling_display": "0.00731590687387421"
+    }
+  },
+  "alternative_net_mass_target": {
+    "removed_per_invocation": 100,
+    "global_removed": 28800,
+    "profile": {
+      "2": 13920,
+      "4": 14208,
+      "6": 14208,
+      "7": 21312,
+      "8": "181044",
+      "42": 288
+    },
+    "moment": [
+      "13478226593301872542940784465443043086715198605911743864543238662301/13479973333575319897333507543509815336818572211270286240551805124608",
+      "6739113296650936271470392232721521543357599302955871932271619331151/6739986666787659948666753771754907668409286105635143120275902562304"
+    ],
+    "one_less_removed_moment": [
+      "26960813229072291885496050861484793154656028588416225700392376131297/26959946667150639794667015087019630673637144422540572481103610249216",
+      "26960813229072291885496050861484793154656028588416225700392376131299/26959946667150639794667015087019630673637144422540572481103610249216"
+    ],
+    "scope": "Also grants perfect rank-eight consolidation. Net invoice reduction after hosting, with unchanged W and remainder; not a helper-deletion construction."
+  },
+  "rank_caps": [
+    {
+      "rank_cap": 1,
+      "fixed_boundary_moment": [
+        "3483392595931857367779328920785025374234520852740798763224805039555/3369993333393829974333376885877453834204643052817571560137951281152",
+        "13933570383727429471117315683140101496938083410963195052899220158221/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13978910617404081993497925463335395594914456863520470179872282258335/13479973333575319897333507543509815336818572211270286240551805124608",
+        "436840956793877562296810170729231112341076776985014693121008820573/421249166674228746791672110734681729275580381602196445017243910144"
+      ]
+    },
+    {
+      "rank_cap": 2,
+      "fixed_boundary_moment": [
+        "6926950969009964711925470559632744413244106834199413713024378522591/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13853901938019929423850941119265488826488213668398827426048757045183/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "6940689645746553299655419556919336230119079463778010062738436129483/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13881379291493106599310839113838672460238158927556020125476872258967/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 3,
+      "fixed_boundary_moment": [
+        "13807556810261588736472947029149369927916565438235157818934735850305/13479973333575319897333507543509815336818572211270286240551805124608",
+        "6903778405130794368236473514574684963958282719117578909467367925153/6739986666787659948666753771754907668409286105635143120275902562304"
+      ],
+      "freely_repacked_boundary_moment": [
+        "6912321439742008439444225864987272420006837385673342343585683245623/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13824642879484016878888451729974544840013674771346684687171366491247/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 4,
+      "fixed_boundary_moment": [
+        "13774789341753371815384378025786555998394714844466969719222660648773/13479973333575319897333507543509815336818572211270286240551805124608",
+        "6887394670876685907692189012893277999197357422233484859611330324387/6739986666787659948666753771754907668409286105635143120275902562304"
+      ],
+      "freely_repacked_boundary_moment": [
+        "27569056889885134928564532716289464543171159299655563533792091457665/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27569056889885134928564532716289464543171159299655563533792091457667/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 5,
+      "fixed_boundary_moment": [
+        "27498876820312386249818611378116596330423642675301018171956885864667/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27498876820312386249818611378116596330423642675301018171956885864669/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13753493447964855435135653138741977166388584459868616955794380093909/13479973333575319897333507543509815336818572211270286240551805124608",
+        "6876746723982427717567826569370988583194292229934308477897190046955/6739986666787659948666753771754907668409286105635143120275902562304"
+      ]
+    },
+    {
+      "rank_cap": 6,
+      "fixed_boundary_moment": [
+        "13728767565510125996413592670739573433722396164489934970930247760007/13479973333575319897333507543509815336818572211270286240551805124608",
+        "1716095945688765749551699083842446679215299520561241871366280970001/1684996666696914987166688442938726917102321526408785780068975640576"
+      ],
+      "freely_repacked_boundary_moment": [
+        "6864093942394139990932558286857509095085294310040055712408048158961/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13728187884788279981865116573715018190170588620080111424816096317923/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 7,
+      "fixed_boundary_moment": [
+        "27422640580811998958487555910951852426334183383640671434239733622769/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27422640580811998958487555910951852426334183383640671434239733622771/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "3426707166148385534493903115102548615691079754752314183232909730855/3369993333393829974333376885877453834204643052817571560137951281152",
+        "13706828664593542137975612460410194462764319019009256732931638923421/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 8,
+      "fixed_boundary_moment": [
+        "27392457433458425047329761990756784295993534871097284859676357994041/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27392457433458425047329761990756784295993534871097284859676357994043/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "27376706660005354779332042229281135115739413625801721829738607234093/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27376706660005354779332042229281135115739413625801721829738607234095/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 9,
+      "fixed_boundary_moment": [
+        "13682933890928761998538841451556831425461434410334208002686463843911/13479973333575319897333507543509815336818572211270286240551805124608",
+        "1710366736366095249817355181444603928182679301291776000335807980489/1684996666696914987166688442938726917102321526408785780068975640576"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13672077601556385939623829206733455103824209432257181100463840671759/13479973333575319897333507543509815336818572211270286240551805124608",
+        "854504850097274121226489325420840943989013089516073818778990041985/842498333348457493583344221469363458551160763204392890034487820288"
+      ]
+    },
+    {
+      "rank_cap": 10,
+      "fixed_boundary_moment": [
+        "6835527329715688562233249345610229416363627871475509752638820345493/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13671054659431377124466498691220458832727255742951019505277640690987/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "27315069730477919227931518740176957581492089033163595745388589677613/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27315069730477919227931518740176957581492089033163595745388589677615/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 11,
+      "fixed_boundary_moment": [
+        "27320638945998828741320325972691008086188994855174612972453931049143/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27320638945998828741320325972691008086188994855174612972453931049145/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "27288785372666925220854122799092987558445066431421051761524604741011/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27288785372666925220854122799092987558445066431421051761524604741013/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 12,
+      "fixed_boundary_moment": [
+        "1706316004495075273432155544259965649170378186374328575869168456055/1684996666696914987166688442938726917102321526408785780068975640576",
+        "13650528035960602187457244354079725193363025490994628606953347648441/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "426012683119502022997594997966691491982894208017607372529189426631/421249166674228746791672110734681729275580381602196445017243910144",
+        "13632405859824064735923039934934127743452614656563435920934061652193/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 13,
+      "fixed_boundary_moment": [
+        "13641528383350113620590765481961081222425004749641307182891120729095/13479973333575319897333507543509815336818572211270286240551805124608",
+        "1705191047918764202573845685245135152803125593705163397861390091137/1684996666696914987166688442938726917102321526408785780068975640576"
+      ],
+      "freely_repacked_boundary_moment": [
+        "6810694173941935106180020568165741441084873107677554846635219281295/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13621388347883870212360041136331482882169746215355109693270438562591/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 14,
+      "fixed_boundary_moment": [
+        "27266404982157616272725897451481617631917125791127990648153788822529/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27266404982157616272725897451481617631917125791127990648153788822531/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13611195663623482780995942596205319801607689595789611319027013518789/13479973333575319897333507543509815336818572211270286240551805124608",
+        "6805597831811741390497971298102659900803844797894805659513506759395/6739986666787659948666753771754907668409286105635143120275902562304"
+      ]
+    },
+    {
+      "rank_cap": 15,
+      "fixed_boundary_moment": [
+        "1703182108858285248502416829326959275859142393971097063411577038155/1684996666696914987166688442938726917102321526408785780068975640576",
+        "13625456870866281988019334634615674206873139151768776507292616305241/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "27203426714529300642729045310104256210566763209013350557497005307131/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27203426714529300642729045310104256210566763209013350557497005307133/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 16,
+      "fixed_boundary_moment": [
+        "27236432423632903442800426271681190807116727766966583844465997377173/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27236432423632903442800426271681190807116727766966583844465997377175/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13592849232060149591377885125161560781046010984587673970581347454703/13479973333575319897333507543509815336818572211270286240551805124608",
+        "849553077003759349461117820322597548815375686536729623161334215919/842498333348457493583344221469363458551160763204392890034487820288"
+      ]
+    },
+    {
+      "rank_cap": 17,
+      "fixed_boundary_moment": [
+        "6805709478148100963983298236093749133280783812451430166632023667997/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13611418956296201927966596472187498266561567624902860333264047335995/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "3396131982054243458822747795665619434723245595258512860595422380203/3369993333393829974333376885877453834204643052817571560137951281152",
+        "13584527928216973835290991182662477738892982381034051442381689520813/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 18,
+      "fixed_boundary_moment": [
+        "27210028288920505036954942578135470042969461901900412039813362553723/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27210028288920505036954942578135470042969461901900412039813362553725/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "27153374119831129833895604114278360267866893802524832682552070215227/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27153374119831129833895604114278360267866893802524832682552070215229/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 19,
+      "fixed_boundary_moment": [
+        "6799479557272222445062043929331287679831995821043816730026658807903/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13598959114544444890124087858662575359663991642087633460053317615807/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "6784637199986895726320372605922485610291696923009050527499075223161/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13569274399973791452640745211844971220583393846018101054998150446323/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 20,
+      "fixed_boundary_moment": [
+        "6796608897379113245621503233308857576016019246848685426887474646265/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13593217794758226491243006466617715152032038493697370853774949292531/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "27124491577511371040756510871867100856561198369071702634534466343277/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27124491577511371040756510871867100856561198369071702634534466343279/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 21,
+      "fixed_boundary_moment": [
+        "6793879706546716169366476705350894418917493171557427417550077003713/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13587759413093432338732953410701788837834986343114854835100154007427/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13555563554699681916632764475103739290272548793912412424450107105121/13479973333575319897333507543509815336818572211270286240551805124608",
+        "6777781777349840958316382237551869645136274396956206212225053552561/6739986666787659948666753771754907668409286105635143120275902562304"
+      ]
+    },
+    {
+      "rank_cap": 22,
+      "fixed_boundary_moment": [
+        "212227461063763718768398432047178654037265740318269745558792506553/210624583337114373395836055367340864637790190801098222508621955072",
+        "27165115016161756002354999302038867716770014760738527431525440838787/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "27098390606543513302748588354752026478394028019846830449087484438643/26959946667150639794667015087019630673637144422540572481103610249216",
+        "13549195303271756651374294177376013239197014009923415224543742219323/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 23,
+      "fixed_boundary_moment": [
+        "27155178320035837452572549796035986002091028645034611663151585951347/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27155178320035837452572549796035986002091028645034611663151585951349/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "6771556487911241818859110412523447529792046007666675095717989512945/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13543112975822483637718220825046895059584092015333350191435979025891/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 24,
+      "fixed_boundary_moment": [
+        "27145668772451123189740808568226175388559342710445979675472148175977/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27145668772451123189740808568226175388559342710445979675472148175979/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "27074584218503142191341978173896129592288586451551469294815964721395/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27074584218503142191341978173896129592288586451551469294815964721397/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 25,
+      "fixed_boundary_moment": [
+        "6784137830030376208260320420337930507530535137545256851631874068615/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13568275660060752416520640840675861015061070275090513703263748137231/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "27063422494350739449732243464852516288013446587191236248081032124471/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27063422494350739449732243464852516288013446587191236248081032124473/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 26,
+      "fixed_boundary_moment": [
+        "27127795048984212851424503769781992123509776399032009333800350142845/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27127795048984212851424503769781992123509776399032009333800350142847/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "845396966678774409516383116984805895140390019013447834846911332655/842498333348457493583344221469363458551160763204392890034487820288",
+        "13526351466860390552262129871756894322246240304215165357550581322481/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 27,
+      "fixed_boundary_moment": [
+        "6779843139388240426833655797448060198600849430486314417978628433343/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13559686278776480853667311594896120397201698860972628835957256866687/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13521195995647987946126395794767651916761842593801077456889520022511/13479973333575319897333507543509815336818572211270286240551805124608",
+        "845074749727999246632899737172978244797615162112567341055595001407/842498333348457493583344221469363458551160763204392890034487820288"
+      ]
+    },
+    {
+      "rank_cap": 28,
+      "fixed_boundary_moment": [
+        "1694453715281174813203975852141888885684698296497490155782140538701/1684996666696914987166688442938726917102321526408785780068975640576",
+        "13555629722249398505631806817135111085477586371979921246257124309609/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13516229897298689824988759900916730203305866318038704488332855501963/13479973333575319897333507543509815336818572211270286240551805124608",
+        "3379057474324672456247189975229182550826466579509676122083213875491/3369993333393829974333376885877453834204643052817571560137951281152"
+      ]
+    },
+    {
+      "rank_cap": 29,
+      "fixed_boundary_moment": [
+        "27103433886355211562989793906725133355693243093193053818340984767277/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27103433886355211562989793906725133355693243093193053818340984767279/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "6755719906751139949065284899315081192946086976665839566981112693157/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13511439813502279898130569798630162385892173953331679133962225386315/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 30,
+      "fixed_boundary_moment": [
+        "27095876286975798921939833964576005694423717601573871460012041026681/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27095876286975798921939833964576005694423717601573871460012041026683/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13506813749308155120088778174848297247940199829537874685926795697563/13479973333575319897333507543509815336818572211270286240551805124608",
+        "3376703437327038780022194543712074311985049957384468671481698924391/3369993333393829974333376885877453834204643052817571560137951281152"
+      ]
+    },
+    {
+      "rank_cap": 31,
+      "fixed_boundary_moment": [
+        "27088568984597972279693240816335318752138518989807676666049821792471/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27088568984597972279693240816335318752138518989807676666049821792473/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13502340893816794865978195373346710846048138795878298051954405897251/13479973333575319897333507543509815336818572211270286240551805124608",
+        "3375585223454198716494548843336677711512034698969574512988601474313/3369993333393829974333376885877453834204643052817571560137951281152"
+      ]
+    },
+    {
+      "rank_cap": 32,
+      "fixed_boundary_moment": [
+        "3385187000689542723314161123942234658576862287750815731022199938843/3369993333393829974333376885877453834204643052817571560137951281152",
+        "13540748002758170893256644495768938634307449151003262924088799755373/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13498011469401357366789570153235272449182783531820642954916027684445/13479973333575319897333507543509815336818572211270286240551805124608",
+        "6749005734700678683394785076617636224591391765910321477458013842223/6739986666787659948666753771754907668409286105635143120275902562304"
+      ]
+    },
+    {
+      "rank_cap": 33,
+      "fixed_boundary_moment": [
+        "27074642855742522025123567640466609634297054785152924956145748271673/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27074642855742522025123567640466609634297054785152924956145748271675/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "26987633208362119240936118204038006494021301233591810378331179188323/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26987633208362119240936118204038006494021301233591810378331179188325/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 34,
+      "fixed_boundary_moment": [
+        "27067996343833530845978090083959308750991187203922826939827605970599/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27067996343833530845978090083959308750991187203922826939827605970601/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "26979496447146179366914973033964046219839678589305636573600897357861/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26979496447146179366914973033964046219839678589305636573600897357863/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 35,
+      "fixed_boundary_moment": [
+        "13530772214728461992740887301696466805056369331416459995038047615609/13479973333575319897333507543509815336818572211270286240551805124608",
+        "6765386107364230996370443650848233402528184665708229997519023807805/6739986666787659948666753771754907668409286105635143120275902562304"
+      ],
+      "freely_repacked_boundary_moment": [
+        "1685724869699771391789950913783453445505726422000451894235100246343/1684996666696914987166688442938726917102321526408785780068975640576",
+        "13485798957598171134319607310267627564045811376003615153880801970745/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 36,
+      "fixed_boundary_moment": [
+        "1690954755833368739689835619955445270606015756887237141433670971379/1684996666696914987166688442938726917102321526408785780068975640576",
+        "13527638046666949917518684959643562164848126055097897131469367771033/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "842622628829484127359195961549674321750382713681008553128130392911/842498333348457493583344221469363458551160763204392890034487820288",
+        "13481962061271746037747135384794789148006123418896136850050086286577/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 37,
+      "fixed_boundary_moment": [
+        "27049181225039088087928228744507139661315159930795612916196019208845/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27049181225039088087928228744507139661315159930795612916196019208847/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "26956462691850740474773214533199731594361851479154383531217833743695/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26956462691850740474773214533199731594361851479154383531217833743697/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 38,
+      "fixed_boundary_moment": [
+        "3380406315724280647404040167382952790178400063552850843447757766893/3369993333393829974333376885877453834204643052817571560137951281152",
+        "13521625262897122589616160669531811160713600254211403373791031067573/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "26949202239411986600001991565997578079611120885845970598340657595173/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26949202239411986600001991565997578079611120885845970598340657595175/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 39,
+      "fixed_boundary_moment": [
+        "6759368855978630922074620832656994448220097567012621424769261949321/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13518737711957261844149241665313988896440195134025242849538523898643/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "3367766533954993859179095483696484840504484732019062666585256574825/3369993333393829974333376885877453834204643052817571560137951281152",
+        "13471066135819975436716381934785939362017938928076250666341026299301/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 40,
+      "fixed_boundary_moment": [
+        "13515924000490821010153899313353097927793986684613240072869622984295/13479973333575319897333507543509815336818572211270286240551805124608",
+        "1689490500061352626269237414169137240974248335576655009108702873037/1684996666696914987166688442938726917102321526408785780068975640576"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13467621547343121859672756544268794812957782395836444576517663296535/13479973333575319897333507543509815336818572211270286240551805124608",
+        "1683452693417890232459094568033599351619722799479555572064707912067/1684996666696914987166688442938726917102321526408785780068975640576"
+      ]
+    },
+    {
+      "rank_cap": 41,
+      "fixed_boundary_moment": [
+        "27026360927151699379416829467778213748089621911954870123327108234089/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27026360927151699379416829467778213748089621911954870123327108234091/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "26928525735244206315922936494872391799247179375371770156988180397917/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26928525735244206315922936494872391799247179375371770156988180397919/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 42,
+      "fixed_boundary_moment": [
+        "13510503702137211034125956100709495426472444590541750538440597844713/13479973333575319897333507543509815336818572211270286240551805124608",
+        "6755251851068605517062978050354747713236222295270875269220298922357/6739986666787659948666753771754907668409286105635143120275902562304"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13460985935457312337450207230135595338245760011614396850512623551665/13479973333575319897333507543509815336818572211270286240551805124608",
+        "6730492967728656168725103615067797669122880005807198425256311775833/6739986666787659948666753771754907668409286105635143120275902562304"
+      ]
+    },
+    {
+      "rank_cap": 43,
+      "fixed_boundary_moment": [
+        "27015781115718944109508947512286749303779365687548505970263383963765/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27015781115718944109508947512286749303779365687548505970263383963767/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "26915573768781685290430327643530823219441350006479674131040213017655/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26915573768781685290430327643530823219441350006479674131040213017657/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 44,
+      "fixed_boundary_moment": [
+        "3376334522747416052013626967624273836123859813260479306440201454013/3369993333393829974333376885877453834204643052817571560137951281152",
+        "13505338090989664208054507870497095344495439253041917225760805816053/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13454662115532288644546595719606513623538484419069757862344088915681/13479973333575319897333507543509815336818572211270286240551805124608",
+        "6727331057766144322273297859803256811769242209534878931172044457841/6739986666787659948666753771754907668409286105635143120275902562304"
+      ]
+    },
+    {
+      "rank_cap": 45,
+      "fixed_boundary_moment": [
+        "27005687121279069349562509831820102274571559914985460990203846992671/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27005687121279069349562509831820102274571559914985460990203846992673/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13451608273444461906503555107040311522335627972052143613600255403203/13479973333575319897333507543509815336818572211270286240551805124608",
+        "3362902068361115476625888776760077880583906993013035903400063850801/3369993333393829974333376885877453834204643052817571560137951281152"
+      ]
+    },
+    {
+      "rank_cap": 46,
+      "fixed_boundary_moment": [
+        "27000808814514135982671574218610770455400874993429297209619622923737/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27000808814514135982671574218610770455400874993429297209619622923739/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "6724311112342380270335605555306985820995620058240384909827601725347/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13448622224684760540671211110613971641991240116480769819655203450695/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 47,
+      "fixed_boundary_moment": [
+        "26996036473973702199956976882854634170451109282259271531901855245229/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26996036473973702199956976882854634170451109282259271531901855245231/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "3361425259664722409449705763829824073170855971301012516563492243709/3369993333393829974333376885877453834204643052817571560137951281152",
+        "13445701038658889637798823055319296292683423885204050066253968974837/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 48,
+      "fixed_boundary_moment": [
+        "26991365615360498617841672583821425894098091182342780476171693483153/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26991365615360498617841672583821425894098091182342780476171693483155/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "26885683940988610764756937260252647027320327854366835297466080725247/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26885683940988610764756937260252647027320327854366835297466080725249/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 49,
+      "fixed_boundary_moment": [
+        "26986792032701833721153760957244400605504390668187481185303327878913/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26986792032701833721153760957244400605504390668187481185303327878915/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "26880084891366119658049314506640414274916380588158778318062207137993/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26880084891366119658049314506640414274916380588158778318062207137995/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 50,
+      "fixed_boundary_moment": [
+        "26982311775800257680362110537164556388969604825555435139427211519955/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26982311775800257680362110537164556388969604825555435139427211519957/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13437300046279180324235149260760123121507525417311343036779579429993/13479973333575319897333507543509815336818572211270286240551805124608",
+        "6718650023139590162117574630380061560753762708655671518389789714997/6739986666787659948666753771754907668409286105635143120275902562304"
+      ]
+    },
+    {
+      "rank_cap": 51,
+      "fixed_boundary_moment": [
+        "26977921129921578391296407617444005437357770119038595671462416488145/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26977921129921578391296407617444005437357770119038595671462416488147/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "26869224996931098559165648758813024674449889960725389325781629516111/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26869224996931098559165648758813024674449889960725389325781629516113/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 52,
+      "fixed_boundary_moment": [
+        "3371702074682386697355631424731202305868207936962952701166026980861/3369993333393829974333376885877453834204643052817571560137951281152",
+        "13486808298729546789422525698924809223472831747851810804664107923445/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "26863955322660881725985288902538281856591122659512618388729446668295/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26863955322660881725985288902538281856591122659512618388729446668297/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 53,
+      "fixed_boundary_moment": [
+        "13484697440673888411436289579037080283078183442475122567054914709481/13479973333575319897333507543509815336818572211270286240551805124608",
+        "6742348720336944205718144789518540141539091721237561283527457354741/6739986666787659948666753771754907668409286105635143120275902562304"
+      ],
+      "freely_repacked_boundary_moment": [
+        "1678674189589402228283137473040172884687315688995415393204049078533/1684996666696914987166688442938726917102321526408785780068975640576",
+        "13429393516715217826265099784321383077498525511963323145632392628265/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 54,
+      "fixed_boundary_moment": [
+        "6741313217507951753659419121688234431914353560273323883001711265363/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13482626435015903507318838243376468863828707120546647766003422530727/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "freely_repacked_boundary_moment": [
+        "6713429080006420844020298289839285894231085545473873185625484733863/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13426858160012841688040596579678571788462171090947746371250969467727/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 55,
+      "fixed_boundary_moment": [
+        "26961187623814123594805972109695929889409813783173178881947188859751/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26961187623814123594805972109695929889409813783173178881947188859753/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "26848739583624662866601124572197667613509118302917053973594826186285/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26848739583624662866601124572197667613509118302917053973594826186287/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 56,
+      "fixed_boundary_moment": [
+        "26957196362438331729275395855627928321194088514846320524560161075575/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26957196362438331729275395855627928321194088514846320524560161075577/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "26843853420595106008799118664751190357352647458732155625762276477405/26959946667150639794667015087019630673637144422540572481103610249216",
+        "13421926710297553004399559332375595178676323729366077812881138238703/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    {
+      "rank_cap": 57,
+      "fixed_boundary_moment": [
+        "26953276453771854692461091579304580399110129981872218609292768422341/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26953276453771854692461091579304580399110129981872218609292768422343/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13419527304320090602941476221531931540270671981603903322145716278315/13479973333575319897333507543509815336818572211270286240551805124608",
+        "3354881826080022650735369055382982885067667995400975830536429069579/3369993333393829974333376885877453834204643052817571560137951281152"
+      ]
+    },
+    {
+      "rank_cap": 58,
+      "fixed_boundary_moment": [
+        "13474712701737608046928318509755497884884152739455194571584193012615/13479973333575319897333507543509815336818572211270286240551805124608",
+        "1684339087717201005866039813719437235610519092431899321448024126577/1684996666696914987166688442938726917102321526408785780068975640576"
+      ],
+      "freely_repacked_boundary_moment": [
+        "26834340094151471172613821973002658579149783024604311378587592222947/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26834340094151471172613821973002658579149783024604311378587592222949/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 59,
+      "fixed_boundary_moment": [
+        "13472820422778065417207730397429221487062082729771109900366325753679/13479973333575319897333507543509815336818572211270286240551805124608",
+        "842051276423629088575483149839326342941380170610694368772895359605/842498333348457493583344221469363458551160763204392890034487820288"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13414853490322573532882155135985304820492267688787558759955330812417/13479973333575319897333507543509815336818572211270286240551805124608",
+        "6707426745161286766441077567992652410246133844393779379977665406209/6739986666787659948666753771754907668409286105635143120275902562304"
+      ]
+    },
+    {
+      "rank_cap": 60,
+      "fixed_boundary_moment": [
+        "26941920533719022368632896775473625814915730304998422997843207530699/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26941920533719022368632896775473625814915730304998422997843207530701/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13412576259085957812795518415599531088510422852037656232626142010561/13479973333575319897333507543509815336818572211270286240551805124608",
+        "6706288129542978906397759207799765544255211426018828116313071005281/6739986666787659948666753771754907668409286105635143120275902562304"
+      ]
+    },
+    {
+      "rank_cap": 61,
+      "fixed_boundary_moment": [
+        "26938262333430941662227123398718089875851100187571589276065772555055/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26938262333430941662227123398718089875851100187571589276065772555057/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "26820674093603996195775897226471432978076253676911520509892464521791/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26820674093603996195775897226471432978076253676911520509892464521793/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    {
+      "rank_cap": 62,
+      "fixed_boundary_moment": [
+        "26934664214633871816933279752633046404019858033894316326870263616719/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26934664214633871816933279752633046404019858033894316326870263616721/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13408134610856706466127367188614154005159362022415635781559743605815/13479973333575319897333507543509815336818572211270286240551805124608",
+        "1676016826357088308265920898576769250644920252801954472694967950727/1684996666696914987166688442938726917102321526408785780068975640576"
+      ]
+    },
+    {
+      "rank_cap": 63,
+      "fixed_boundary_moment": [
+        "26931124245041256219349018330274930729026047280574478018001732888375/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26931124245041256219349018330274930729026047280574478018001732888377/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "freely_repacked_boundary_moment": [
+        "13405967768482751178816821519771630284815616875204165247207481523219/13479973333575319897333507543509815336818572211270286240551805124608",
+        "3351491942120687794704205379942907571203904218801041311801870380805/3369993333393829974333376885877453834204643052817571560137951281152"
+      ]
+    }
+  ],
+  "necessary_rank_cap_with_fixed_boundaries": 56,
+  "necessary_rank_cap_with_free_boundary_repacking": 37,
+  "conditional_invoices": [
+    {
+      "rank_cap": 56,
+      "profile": {
+        "2": 13920,
+        "4": 14208,
+        "6": 14208,
+        "7": 21312,
+        "40": 1,
+        "42": 288,
+        "56": 26377
+      },
+      "moment": [
+        "13478599191970104743105059883831639772416740455036599910462815680615/13479973333575319897333507543509815336818572211270286240551805124608",
+        "1684824898996263092888132485478954971552092556879574988807851960077/1684996666696914987166688442938726917102321526408785780068975640576"
+      ],
+      "additional_rank_one_child_budget": 177,
+      "required_fused_local_rank_mass_fraction": [
+        "432510766307785252662746903737153622356390448556712378572747744825/435261071020093318054366135128855974799446356250964335116196918468",
+        "432510766307785252662746903737153622356390448556712378572747744827/435261071020093318054366135128855974799446356250964335116196918464"
+      ],
+      "required_fused_percent_display": "99.3681252711",
+      "status": "ARITHMETIC_TARGET_ONLY_NO_OPERATOR_OR_HOSTING"
+    },
+    {
+      "rank_cap": 57,
+      "profile": {
+        "2": 13920,
+        "4": 14208,
+        "6": 14208,
+        "7": 21312,
+        "42": 288,
+        "54": 1,
+        "57": 25914
+      },
+      "moment": [
+        "26953276891591712119066747284056022506148364065669957730353990666321/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26953276891591712119066747284056022506148364065669957730353990666323/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "additional_rank_one_child_budget": 431,
+      "required_fused_local_rank_mass_fraction": [
+        "144170255435928417554248967912384540785463482852237459524249248275/146393659895523451622890137150734632294468296408355416794529857234",
+        "432510766307785252662746903737153622356390448556712378572747744827/439180979686570354868670411452203896883404889225066250383589571698"
+      ],
+      "required_fused_percent_display": "98.4812153332",
+      "status": "ARITHMETIC_TARGET_ONLY_NO_OPERATOR_OR_HOSTING"
+    },
+    {
+      "rank_cap": 63,
+      "profile": {
+        "2": 13920,
+        "4": 14208,
+        "6": 14208,
+        "7": 21312,
+        "42": 288,
+        "54": 1,
+        "63": 23446
+      },
+      "moment": [
+        "3366390686584465511730240583919488675557780266215919161449960127291/3369993333393829974333376885877453834204643052817571560137951281152",
+        "13465562746337862046920962335677954702231121064863676645799840509165/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "additional_rank_one_child_budget": 1864,
+      "required_fused_local_rank_mass_fraction": [
+        "432510766307785252662746903737153622356390448556712378572747744825/461333188417168827980743660481853566967487590522806841674625105668",
+        "432510766307785252662746903737153622356390448556712378572747744827/461333188417168827980743660481853566967487590522806841674625105664"
+      ],
+      "required_fused_percent_display": "93.7523631872",
+      "status": "ARITHMETIC_TARGET_ONLY_NO_OPERATOR_OR_HOSTING"
+    }
+  ],
+  "query_controls": {
+    "zero_or_one_query_chart_programs_rejected": 108,
+    "matching_query_basis_columns": 384,
+    "scope": "Two-address involution tests; the arbitrary-size lower bound is proved separately."
+  },
+  "geometry_scope": {
+    "fixed_port_seven_positive_stage_span": 50,
+    "all_ports_seven_positive_stage_span": 57,
+    "universal_stage_count_claim_rejected": true
+  },
+  "rejected_cost_mutations": [
+    "omit pooled volume",
+    "omit idle boundary",
+    "test saving zero only",
+    "allow rank m recursion"
+  ],
+  "scope": "Fixed m, live volume, retained rank mass and stated boundary rules. Relaxed costs can reject a class but cannot admit an unconstructed supplier. Complex endpoint unchanged."
+}
diff --git a/research/bit-role-sharing-budget/replay.sh b/research/bit-role-sharing-budget/replay.sh
new file mode 100644
index 0000000000..6625d92c99
--- /dev/null
+++ b/research/bit-role-sharing-budget/replay.sh
@@ -0,0 +1,12 @@
+#!/bin/sh
+set -eu
+if [ "$#" -ne 1 ] || [ -e "$1" ]; then
+    echo "usage: sh research/bit-role-sharing-budget/replay.sh NEW_OUTPUT_DIRECTORY" >&2
+    exit 2
+fi
+here=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+mkdir -p -- "$1"
+out=$(CDPATH= cd -- "$1" && pwd)
+python3 -I -B "$here/verify.py" --out "$out/PRICE.json"
+cmp "$out/PRICE.json" "$here/evidence/PRICE.json"
+echo PASS_BIT_ROLE_SHARING_REPLAY
diff --git a/research/bit-role-sharing-budget/verify.py b/research/bit-role-sharing-budget/verify.py
new file mode 100644
index 0000000000..2caddf5287
--- /dev/null
+++ b/research/bit-role-sharing-budget/verify.py
@@ -0,0 +1,374 @@
+#!/usr/bin/env python3
+"""Price role sharing before construction. No new supplier or kappa is admitted.
+
+Prepared for androolloyd with substantial OpenAI Codex assistance. Apache-2.0.
+The interval engine uses positive atanh sums, independently of the inherited
+Mercator engine. All admission and corruption checks also run under -O.
+"""
+import argparse
+import ast
+from collections import Counter
+from fractions import Fraction as Q
+from functools import lru_cache
+import gzip
+import hashlib
+import json
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+DYAD = 1 << 224
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def down(x):
+    return Q(x.numerator * DYAD // x.denominator, DYAD)
+
+
+def up(x):
+    return -down(-x)
+
+
+@lru_cache(None)
+def log_interval(x):
+    need(x >= 1, 'log domain')
+    k = 0
+    while x >= 2:
+        x /= 2
+        k += 1
+
+    def atanh(y):
+        z = (y - 1) / (y + 1)
+        term = z
+        total = Q(0)
+        for i in range(96):
+            total += 2 * term / (2*i + 1)
+            term *= z*z
+        tail = 2 * term / (193 * (1-z*z))
+        return total, total + tail
+
+    lo, hi = atanh(x)
+    a, b = atanh(Q(2))
+    return down(lo+k*a), up(hi+k*b)
+
+
+def exp_interval(lo, hi):
+    need(0 <= lo <= hi < Q(1, 10), 'exponential domain')
+
+    def polynomial(x):
+        total = term = Q(1)
+        for k in range(1, 29):
+            term *= x/k
+            total += term
+        return total, term
+
+    lower, _ = polynomial(lo)
+    upper, last = polynomial(hi)
+    return down(lower), up(upper + last*hi/29/(1-hi/30))
+
+
+@lru_cache(None)
+def rate_factor(rank, c):
+    lo, hi = log_interval(Q(64, rank))
+    return exp_interval(c*lo, c*hi)
+
+
+def moment(profile, c, bad=True):
+    lo = hi = Q(0)
+    for rank, count in profile.items():
+        need(0 < rank < 64 and count > 0, 'proper positive child')
+        a, b = rate_factor(rank, c)
+        weight = Q(rank*count, 64*28416)
+        lo += weight*a
+        hi += weight*b
+    a, b = rate_factor(1, c)
+    fallback = Q(32*64*sum(profile.values()), 10**16*28416) if bad else Q(0)
+    return down(lo+fallback*a), up(hi+fallback*b)
+
+
+def rational_rank(vectors):
+    pivots = {}
+    for vector in vectors:
+        row = list(map(Q, vector))
+        for j, old in sorted(pivots.items()):
+            coefficient = row[j]
+            row = [x-coefficient*y for x, y in zip(row, old)]
+        j = next((j for j, x in enumerate(row) if x), None)
+        if j is not None:
+            coefficient = row[j]
+            pivots[j] = [x/coefficient for x in row]
+    return len(pivots)
+
+
+def binary_rank(rows):
+    basis = {}
+    for value in rows:
+        while value:
+            i = value.bit_length()-1
+            if i not in basis:
+                basis[i] = value
+                break
+            value ^= basis[i]
+    return len(basis)
+
+
+def extract_word(word, expected):
+    """Read the actual word, not only its advertised local histogram."""
+    v, helpers = word['v'], word['R']
+    need((v, helpers, word['h']) == (111, 439, 8), 'pinned dimensions')
+    dims = [rational_rank(word['lines'][i] for i in frame) for frame in word['frames']]
+    masks = [sum(1 << i for i in frame) for frame in word['frames']]
+    current = word['start'][:]
+    rows = [1 << i for i in range(2*v+helpers)]
+    histogram = Counter()
+    role_mass = Counter()
+
+    def climb(role, frame):
+        old = current[role]
+        need(masks[old] & ~masks[frame] == 0, 'nested frame')
+        delta = dims[frame] - dims[old]
+        need(delta >= 0, 'nonnegative climb')
+        if delta:
+            histogram[delta] += 1
+            role_mass['source' if role < v else 'target' if role < 2*v else 'helper'] += delta
+        current[role] = frame
+
+    def gates(section):
+        for frame, target, sources in word[section]:
+            need(len({target, *sources}) == len(sources)+1, 'distinct scalar operands')
+            for role in [target, *sources]:
+                climb(role, frame)
+            for source in sources:
+                rows[target] ^= rows[source]
+
+    gates('D')
+    gates('A')
+    copies = [dims[current[role]] for role in word['ret']]
+    response_rows = [sum(1 << k for k in sources) for sources in word['scatter']]
+    need(binary_rank(response_rows) == 9, 'retained-total response rank')
+    snapshots = [rows[role] for role in word['ret']]
+    need(binary_rank(snapshots) == 9, 'independent retained total inputs')
+    for target, sources in enumerate(word['scatter']):
+        for k in sources:
+            rows[v+target] ^= snapshots[k]
+    gates('B')
+    gates('C')
+    for role, frame in enumerate(word['final']):
+        climb(role, frame)
+    want = [(1 << i) ^ ((1 << (i-v)) if v <= i < 2*v else 0) for i in range(len(rows))]
+    need(rows == want, 'full local Boolean endpoint')
+    histogram.update(copies)
+    need(dict(histogram) == {int(r): n for r, n in expected['local_histogram'].items()}, 'local paid profile')
+    need(copies == [7]*9 and dict(role_mass) == dict(source=777, target=777, helper=3512), 'complete local rank mass')
+    return histogram, dict(columns=len(rows), copy_ranks=copies, response_rank=9,
+                           independent_retained_inputs=9, role_climb_mass=dict(role_mass),
+                           paid_histogram=dict(sorted(histogram.items())), rank_mass=5129)
+
+
+def pinned_inputs():
+    pins = json.loads((HERE/'SOURCES.json').read_text())
+    for name, digest in pins['files'].items():
+        need(hashlib.sha256((ROOT/name).read_bytes()).hexdigest() == digest, 'source hash mismatch: '+name)
+    directory = ROOT/'research/e8-bit-p111-tuned/tune'
+    expected = json.loads((directory/'EXPECTED.json').read_text())
+    word = json.loads(gzip.decompress((directory/'bitE8mut-p111-tuned.json.gz').read_bytes()))
+    # Read literal frozen-hosting constants without importing a dependency tree.
+    constants = {}
+    for node in ast.parse((directory/'fastc.py').read_text()).body:
+        if isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name) and target.id in ('REM', 'W', 'm', 'T'):
+                    constants[target.id] = ast.literal_eval(node.value)
+    need((constants['W'], constants['m'], constants['T']) == (28416, 64, 288), 'global constants')
+    return pins, word, expected, constants
+
+
+def combine(remainder, mass, cap, integral=False):
+    result = Counter(remainder)
+    if integral:
+        count, tail = divmod(mass, cap)
+        result[cap] += count
+        if tail:
+            result[tail] += 1
+    else:
+        result[cap] += Q(mass, cap)
+    return dict(sorted((r, n) for r, n in result.items() if n))
+
+
+def bracket_root(profile):
+    lo, hi = Q(0), Q(1, 50)
+    need(moment(profile, lo)[1] < 1 < moment(profile, hi)[0], 'root bracket initial')
+    for _ in range(72):
+        mid = (lo+hi)/2
+        lower, upper = moment(profile, mid)
+        if upper < 1:
+            lo = mid
+        else:
+            need(lower > 1, 'root interval ambiguity')
+            hi = mid
+    return dict(saving=[lo, hi], kappa_ceiling_upper=hi/(1+hi),
+                kappa_ceiling_display=format(float(hi/(1+hi)), '.15g'))
+
+
+def query_controls():
+    """Exact operator checks on a two-address swap, including private dirt."""
+    def mix(rows, matrix):
+        return [tuple(sum_xor(rows[j][a] for j in range(len(rows)) if mask >> j & 1)
+                      for a in range(2)) for mask in matrix]
+
+    def flatten(rows):
+        return [value for row in rows for value in row]
+
+    gl2 = [pair for a in range(1, 4) for b in range(1, 4)
+           if binary_rank(pair := (a, b)) == 2]
+    inputs = [(1, 2), (4, 8)]
+    target = [(2, 1), (8, 4)]
+    failures = 0
+    # Complete GL(2,2) before/after charts with at most one queried row.
+    for before in gl2:
+        for after in gl2:
+            for row in (None, 0, 1):
+                values = mix(inputs, before)
+                if row is not None:
+                    values[row] = values[row][::-1]
+                values = mix(values, after)
+                need(values != target, 'sub-two-query all-role counterexample')
+                failures += 1
+    bases = 0
+    for active in range(1, 9):
+        for private in range(4):
+            values = [(1 << (2*j), 1 << (2*j+1)) for j in range(active+private)]
+            goal = [row[::-1] if j < active else row for j, row in enumerate(values)]
+            difference = [x ^ y for x, y in zip(flatten(values), flatten(goal))]
+            need(binary_rank(difference) == active, 'direct-sum displacement rank')
+            actual = values[:]
+            for j in range(active):
+                actual[j] = actual[j][::-1]
+            need(actual == goal, 'matching query count and restored dirt')
+            bases += 2*(active+private)
+    return dict(zero_or_one_query_chart_programs_rejected=failures, matching_query_basis_columns=bases,
+                scope='Two-address involution tests; the arbitrary-size lower bound is proved separately.')
+
+
+def sum_xor(values):
+    result = 0
+    for value in values:
+        result ^= value
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--out', type=Path, required=True)
+    args = parser.parse_args()
+    pins, word, expected, constants = pinned_inputs()
+    local, word_receipt = extract_word(word, expected['word'])
+    remainder = constants['REM']
+    baseline = Counter({r: 288*n for r, n in local.items()})
+    baseline.update(remainder)
+    need(dict(baseline) == {int(r): n for r, n in expected['nine']['profile'].items()}, 'full frozen-hosting invoice')
+    mass = 288*sum(r*n for r, n in local.items())
+    need(mass == 1477152 and sum(r*n for r, n in baseline.items()) == 1808352, 'global rank masses')
+    current = Q(expected['nine']['bit_lower'])
+    need(moment(baseline, current)[1] < 1 < moment(baseline, current+Q(1, 10**24))[0], 'independent current root enclosure')
+    target = Q(1, 99)
+    base_interval = moment(baseline, target)
+    pooling = []
+    for batch in (1, 2, 4, 8, 16, 32):
+        bill = {}
+        calls = 0
+        for rank, count in baseline.items():
+            full, tail = divmod(count, batch)
+            bill[rank] = batch*full + tail
+            calls += full + bool(tail)
+        need(bill == dict(baseline), 'full batch-volume accounting')
+        pooling.append(dict(batch_size=batch, optimistic_dispatches=calls, volume_weighted_invoice=bill,
+                            moment=moment(bill, target)))
+    need(base_interval[0] > 1 and base_interval[1]/2 < 1, 'omitted volume mutation')
+    stage = combine(remainder, mass, 8)
+    free_copy = combine(remainder, mass-288*63, 8)
+    need(moment(stage, target)[0] > 1 and moment(free_copy, target)[0] > 1, 'intra-stage rejection')
+    mass_cut_99 = moment(combine(remainder, mass-288*99, 8), target)
+    mass_cut_100 = moment(combine(remainder, mass-288*100, 8), target)
+    need(mass_cut_99[0] > 1 > mass_cut_100[1], 'net rank-mass reduction threshold')
+    caps = []
+    first_local = first_global = None
+    total_mass = sum(r*n for r, n in baseline.items())
+    for cap in range(1, 64):
+        relaxed = moment(combine(remainder, mass, cap), target)
+        global_relaxed = moment({cap: Q(total_mass, cap)}, target)
+        if first_local is None and relaxed[1] < 1:
+            first_local = cap
+        if first_global is None and global_relaxed[1] < 1:
+            first_global = cap
+        caps.append(dict(rank_cap=cap, fixed_boundary_moment=relaxed, freely_repacked_boundary_moment=global_relaxed))
+    need((first_local, first_global) == (56, 37), 'rank threshold')
+    # These exclusions do not depend on a loose positive fallback estimate.
+    need(moment(combine(remainder, mass, 55), target, False)[0] > 1, 'cap-55 rejection without fallback')
+    need(moment(free_copy, target, False)[0] > 1, 'free-copy rejection without fallback')
+    # A fixed-port stage-span argument must not be applied across all ports.
+    base_span = rational_rank(word['lines'])
+    need(base_span == 8 and base_span+7*7 == 57 > 1+7*7, 'cross-port span control')
+    # A conditional invoice: it is not a supplied operator or hosting plan.
+    conditional = []
+    unit = moment({1: 1}, target)
+    for cap in (56, 57, 63):
+        profile = combine(remainder, mass, cap, integral=True)
+        lo, hi = moment(profile, target)
+        allowance = (1-hi)//unit[1]
+        need(hi+allowance*unit[1] < 1 < lo+(allowance+1)*unit[0], 'repair allowance integer fence')
+        # Rank-mass fraction needing fusion from ideal rank-eight calls.
+        unfused = moment(stage, target)
+        all_fused = moment(combine(remainder, mass, cap), target)
+        fraction_lo = (unfused[0]-1)/(unfused[1]-all_fused[0])
+        fraction_hi = (unfused[1]-1)/(unfused[0]-all_fused[1])
+        need(0 < fraction_lo <= fraction_hi < 1, 'fusion coverage interval')
+        conditional.append(dict(rank_cap=cap, profile=profile, moment=[lo, hi],
+                                additional_rank_one_child_budget=int(allowance),
+                                required_fused_local_rank_mass_fraction=[fraction_lo, fraction_hi],
+                                required_fused_percent_display=format(float(100*fraction_hi), '.12g'),
+                                status='ARITHMETIC_TARGET_ONLY_NO_OPERATOR_OR_HOSTING'))
+    # Meaningful arithmetic controls, not accepted alternative assumptions.
+    need(moment({8: Q(mass, 8)}, target)[1] < 1, 'omitted idle boundary control')
+    need(moment(baseline, Q(0))[1] < 1 < base_interval[0], 'zero-saving-only admission control')
+    malformed = dict(baseline)
+    malformed[64] = 1
+    try:
+        moment(malformed, target)
+    except ValueError as error:
+        need(str(error) == 'proper positive child', 'proper-child rejection')
+    else:
+        raise ValueError('full-width recursive call accepted')
+    controls = query_controls()
+    result = dict(status='PASS_BIT_ROLE_SHARING_COST_SCREEN_NO_NEW_KAPPA',
+                  source_hashes=pins['files'], local_word=word_receipt,
+                  baseline=dict(m=64, live=28416, profile=dict(sorted(baseline.items())),
+                                rank_mass=total_mass, deficit=64*28416-total_mass,
+                                target_saving=target, target_moment=base_interval, idle_remainder=remainder),
+                  role_pooling=pooling,
+                  perfect_stage_fusion=dict(moment=moment(stage, target), root=bracket_root(stage)),
+                  perfect_stage_fusion_and_free_copies=dict(moment=moment(free_copy, target), root=bracket_root(free_copy)),
+                  alternative_net_mass_target=dict(removed_per_invocation=100, global_removed=28800,
+                                                   profile=combine(remainder, mass-288*100, 8),
+                                                   moment=mass_cut_100, one_less_removed_moment=mass_cut_99,
+                                                   scope='Also grants perfect rank-eight consolidation. Net invoice reduction after hosting, with unchanged W and remainder; not a helper-deletion construction.'),
+                  rank_caps=caps, necessary_rank_cap_with_fixed_boundaries=first_local,
+                  necessary_rank_cap_with_free_boundary_repacking=first_global,
+                  conditional_invoices=conditional, query_controls=controls,
+                  geometry_scope=dict(fixed_port_seven_positive_stage_span=50,
+                                      all_ports_seven_positive_stage_span=57,
+                                      universal_stage_count_claim_rejected=True),
+                  rejected_cost_mutations=['omit pooled volume', 'omit idle boundary', 'test saving zero only', 'allow rank m recursion'],
+                  scope='Fixed m, live volume, retained rank mass and stated boundary rules. Relaxed costs can reject a class but cannot admit an unconstructed supplier. Complex endpoint unchanged.')
+    args.out.write_text(json.dumps(result, indent=2, default=str)+'\n')
+    print(result['status'])
+    print('fixed-boundary cap >=', first_local, '; free-boundary cap >=', first_global)
+    print('conditional rank-one repair budgets:', [(x['rank_cap'], x['additional_rank_one_child_budget']) for x in conditional])
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/bit-sharing-hosting-gate/CLAIM.json b/research/bit-sharing-hosting-gate/CLAIM.json
new file mode 100644
index 0000000000..66721efdb4
--- /dev/null
+++ b/research/bit-sharing-hosting-gate/CLAIM.json
@@ -0,0 +1,14 @@
+{
+  "continuation_of": "https://github.com/CrocSwap/integer-mult-bounds/pull/673",
+  "base_commit": "156f259b99723468cfdd2b5d47d0ba894f09bea7",
+  "authorization": "User requested a concrete sharing mechanism and hosting plan for the 100-net-rank-units route, with consolidation, restoration and boundary costs priced before building; explicitly requested a success goal.",
+  "goal_status": "ACTIVE_UNACHIEVED",
+  "success_gate": "Actual operator and chronological physical hosting, at least 28800 net global rank units removed (100 per invocation), exact full moment below one at a saving strictly greater than 1/99, all recursive calls, volumes, restoration and finite interfaces priced.",
+  "candidates": [
+    "Running source-only decoder accumulators across the nine-stage scalar source-bank dependence.",
+    "Grant thirteen helper paths free and restore all vacated coordinates at their explicit physical owners."
+  ],
+  "selected_scope": "Pre-construction operator and cost gate; no supplier built for a candidate that already fails a favorable paid invoice.",
+  "result": "A scalar sharing identity is verified, but its best-case COPY credit is only 7 per invocation and chart realization is missing. Thirteen free helpers have 104 gross and zero net credit. Current cover/data boundary conservation limits COPY-only net credit to 63; 100 requires changed obligations.",
+  "coordination": "Final queue refreshed through PR762; existing PR673 remains open at its expected parent head with no comments or reviews. No pinned coordination issue exists. PR521/677/717 source proofs were read; new PR757/761 fixed-factor COPY floors and PR760 R420 ghost-return screen were checked by their PR descriptions and are context, not dependencies."
+}
diff --git a/research/bit-sharing-hosting-gate/PROOF.md b/research/bit-sharing-hosting-gate/PROOF.md
new file mode 100644
index 0000000000..8ddb0398e3
--- /dev/null
+++ b/research/bit-sharing-hosting-gate/PROOF.md
@@ -0,0 +1,254 @@
+# A concrete sharing attempt and its complete cost gate
+
+This investigation starts at PR673 commit
+`156f259b99723468cfdd2b5d47d0ba894f09bea7`. The selected frontier is unchanged.
+Its purpose is to price a construction before implementing a supplier.
+
+## 1. Success means an operator and a paid invoice
+
+The requested goal is at least 100 **net** paid rank units removed per local
+invocation, not 100 removed from the local word while added at another
+boundary. There are 288 invocations. Thus the requested net global credit
+is at least 28,800 against the pinned rank mass 1,808,352.
+
+Admission also requires a strict rational moment below one at some c>1/99,
+using actual child widths and volumes, plus:
+
+- The exact all-role BIT operator, including arbitrary incoming dirt.
+- Legal common labels at every source read and every scalar operation.
+- Chronological owners, exclusive access, and restored or explicitly owned
+  disposable workspace; all live storage counted.
+- Consolidation, chart transport, remaining idle work, source access,
+  initialization, cleanup, fallback, and finite compiler costs.
+
+The retained W=28416 denominator is productive volume. Extra work rows do
+not enlarge it to make a hypothetical moment smaller. The nine existing
+private center slots are already typed and have their own lifetimes.
+This investigation supplies pre-construction gates, not the admission above.
+
+## 2. Concrete mechanism: a running decoder cache
+
+Ignore ADDRESS labels for one moment and follow the literal nine-stage
+scalar bank schedule. There are eight initial data banks, each with 111
+port coordinates. Encode an initial bank by a distinct bit. The source bank
+read by each successive local shear has mask
+
+    1, 3, 6, 14, 26, 58, 106, 234, 170.
+
+The XOR of all nine masks is zero. The first eight are independent.
+Therefore, for any fixed linear port functional L, the ninth value L(x)
+equals the XOR of its eight earlier values. This is an actual scalar
+sharing identity. It follows from the bridge/shear schedule; it is not
+assumed from the similarity of the local words.
+
+The nine retained decoder source functionals have binary rank nine. The
+checker extracts them from the actual PR589 A word. It also runs inverse
+C and B and verifies that the reflected word has the same retained scalar
+forms at its copy boundary. Applying those nine functionals to the bank
+masks checks the running-sum identity on all 888 source coordinates.
+
+Maintain nine initially zero accumulators per replica. After each of the
+first eight stages, XOR its nine **source-only** retained totals into them.
+At stage nine the accumulators contain the required nine source totals.
+Running sums need nine rows, not 72 rows holding all earlier values.
+
+Two obligations prevent calling this a supplier:
+
+1. The actual retained total also contains helper dirt. Its dirty part has
+   rank nine; with independent private stage inputs the XOR of the nine raw
+   snapshots has rank nine, rather than vanishing. Raw snapshots cannot be
+   reused as clean source totals. One proposed local interface extracts the
+   nine initial dirty forms into nine owned temporary rows, cancels them
+   from the copied totals, and clears the temporaries after their last use.
+   At the last stage the original dirty response must be supplied or the
+   target preconditioner rebuilt. These are real operations, not free
+   erasure of borrowed inputs.
+2. The scalar relation is at aligned port indices. The physical supplier
+   uses port-dependent cover routes and stage frames. A proof that the
+   accumulators can be updated/read in these common ADDRESS charts is still
+   required. No commutation of L with those routes is asserted here.
+
+The pricing gate can reject this candidate without solving either issue:
+grant extraction and alignment at zero recursive cost. The most it then
+saves is the final stage's nine rank-7 copies per replica:
+
+    32 * 9 * 7 = 2016 global units = 7 per local invocation.
+
+This is already far below 100. Removing other producer computations would
+be a different proposal, with different retained values and obligations.
+
+### Storage and nonrecursive bill
+
+Every cache is live from stage zero through stage eight. Reconstructing the
+actual untouched windows shows none contains all nine stages. The plan
+therefore allocates 9*32=288 owned full rows, rather than clearing a borrowed
+data row. Nine further dirty-form temporary rows can be reused sequentially
+between local calls. Keeping the original nine center slots gives a proposed
+physical stock of 28425+288+9=28722 rows, before the inherited evaluator and
+recursive workspace. Productive W stays 28416.
+
+Let U=V/W be a full role's volume including all spectators, and X(U), P(U),
+Z(U) be charged aligned XOR, copy, and clear scans. Each dirty form can be
+initialized by copying its first nonzero operand and XORing the others.
+The sum d of the nine dirty-form support sizes is 471 (recomputed in the
+receipt). A conservative temporary extraction bill over all local calls is
+
+    288 * [9 P(U) + (d-9) X(U) + 9 Z(U)].
+
+The running sums require 2304 X(U); cancelling dirt in those sums requires
+another 2304 X(U). The existing raw center is left unchanged for the decoder:
+XOR the raw center and then the dirty temporary into the accumulator. Cache
+initialization and terminal clearing cost 576 Z(U). At the last stage,
+copying the dirty temporary into the center replaces its old source-copy
+scan; adding the cached source part requires another 288 X(U). This proposed
+aligned interface adds 2592 P(U)+137952 X(U)+3168 Z(U), before new routing,
+descriptor work and head returns. The ordinary decoder/scatter and existing
+center-copy/clear scans are inherited; no saving in their scalar cost is
+claimed. The extra 297U persistent/temporary stock is about 1.05% of
+productive V and is not a child-volume discount.
+
+Chart transport could require additional recursive children; its exact bill
+is unresolved. The receipt's best-case invoice grants those costs zero and
+only subtracts the 288 last-stage rank-7 copies. Since this favorable invoice
+already fails and its mass credit is only 7, we do not implement the cache.
+This is an upper bound on benefit and a lower bound on cost, not a complete
+physical realization of the candidate.
+
+## 3. Concrete hosting plan for vacated helper slots
+
+A larger proposal is to share enough producer work to eliminate thirteen
+complete helper paths per local invocation. Each starts at rank zero and
+ends at rank eight, so the apparent local credit is 13*8=104. To avoid
+presuming a scalar construction, grant a hypothetical replacement producer
+for free; this is strictly more favorable than paying for one.
+
+The checker independently expands the existing frozen selection into all
+3951 (stage, helper) reservations per replica, or 126432 globally. A
+reservation has idle-child index i, owner copy c, offset o, width eight,
+stage s and helper h. The physical family is
+
+    replica*888 + (2*pair(i)+side)*111 + port,
+    with (side, port) = divmod(c,111).
+
+The owner's pending idle-coordinate interval is [o,o+8). Window membership
+proves that no local call or bridge touches this owner before its boundary.
+Offsets are disjoint. Existing reservations are left in place.
+
+For each removed helper, return its eight coordinates to its **original
+owner's idle child**. Join those coordinates with that child's remaining
+pending subspace and execute one child of the resulting rank. This uses a
+fixed coordinate chart for a subspace of the original commuting pending
+projector; there is no new family or volume denominator. Any actual chart
+adapter has the retained fixed-routing cost. The largest original window is
+42<64, so these completed idle children remain proper recursive calls.
+
+This is a specific boundary plan with every reservation identified, rather
+than a nominal +104 charge placed in an unspecified bucket. For helpers
+0..12, the receipt lists all 117 reservations in one replica; other replicas
+translate the family index by 888. The precise boundary histogram is
+regenerated, including consolidation of returned holes with the old tail.
+
+Every deleted role profile has mass eight. Every vacated reservation adds
+eight to its idle child. Consequently
+
+    local credit = 288*104 = 29952,
+    owner boundary debit = 29952,
+    net credit = 0.
+
+The best-case target moment becomes 1.027203943736788 from 1.027739494928555.
+There is a small benefit from less fragmentation, but no net rank reduction
+and no target admission. The checker repeats the conservation check for all
+439 possible single-helper withdrawals, and then grants **all** helpers free.
+Even that latter profile, with actual data paths retained, fails at
+1.009534083299681. No deleted helper producer is claimed to exist.
+
+Source access, scalar cleanup and a replacement producer's own child work
+cannot turn zero net rank credit into positive credit unless they change a
+separate boundary obligation. They add nonnegative costs to these favorable
+invoices. The inherited fallback is charged separately for every resulting
+child, using the new child count, including completed idle children.
+
+## 4. What the 100-unit arithmetic relaxation omitted
+
+The previous rank-8 screen is valid as a lower bound, but it is not a plan
+for consolidation. The 222 data roles each have total local growth seven.
+Under role-preserving consolidation at the same endpoints their children
+have rank at most seven. Grant all their mass at rank seven and every other
+local unit at rank eight, including fractional calls. Keep the old remainder.
+With s units removed from the non-data mass the relaxed profile is
+
+    H = Hidle + 288*222 e7 + 288*(3512+63-s)/8 e8.
+
+| s | Exact-interval moment at 1/99, displayed approximately |
+|---:|---:|
+| 99 | 1.000371348790695 |
+| 100 | 1.000209625827279 |
+| 101 | 1.000047902863863 |
+| 102 | 0.9998861799004471 |
+
+All changes are compared by two independent rational interval engines.
+Fractional packing and free deletion are deliberately favorable assumptions.
+This fence preserves the data endpoints and old remainder. It is not a
+universal 102-unit lower bound for changed endpoints or changed hosting.
+
+More fundamentally, under the retained boundary/cover accounting identity,
+
+    D = mW - mass = 32*(8*111 - 9*C),
+
+where C is the paid COPY mass per local invocation. Helpers and their
+returned idle directions cancel from this identity. The original C is 63.
+Even C=0 saves only 63 per invocation. Saving 100 at these endpoints would
+require C=-37, an impossible nonnegative charge. A valid attempt at the
+100-unit goal must alter this identity's **data/cover boundary term**, not
+just its producer, scalar basis, number of helpers, or cache allocation.
+The claim is scoped to this accounting identity, not arbitrary suppliers.
+
+## 5. Do not turn that obstruction into a universal cost claim
+
+Returning helper coordinates changes the remainder histogram. Thus a fixed
+remainder screen cannot reject every redesigned hosting plan. As a control,
+erase all helper computations, consolidate each data climb, and restore all
+owner directions at their original idle boundaries. With C=63 its moment is
+1.006919923493207 (fails). Additionally grant C=0 and its moment is
+0.9967176251943854 (passes). Neither free construction is supplied.
+
+This passing control removes only 63 rank units per invocation. It shows
+that 100 units is a chosen construction goal, not a necessary condition for
+every possible bit supplier reaching the rate. The full moment is always
+the decisive rate test. A change to the requested goal should be explicit;
+these relaxed profiles do not meet the current goal's construction gate.
+
+## 6. Evidence, attribution, and next gate
+
+The exact owner expander and backward window audit are written independently
+of DaysSky's hosting_core, then compared to that source's output. The pinned
+local word's complete Boolean replay and the previous positive-atanh price
+engine are reused with hashes; the inherited Mercator engine independently
+checks every target interval. No optimizer or network runs in replay.
+These are finite schedule/price checks, not a fresh all-size compiler proof.
+
+PR589 supplies the punctured tuned word (eumemic, with Claude assistance),
+PR555 the frozen selection and v=111 pipeline, DreamingOfClouds the generalized
+chain, and DaysSky/chafreaky the hosting lineage. The current scalar sharing
+identity is an elementary consequence of that chain; no priority claim is
+made. PR521 (applecrusher) and PR677 (commdata2338) were read for native
+unipotent fusion and its restored boundaries. Their two-to-one local query
+count does not furnish a drop-in replacement for these nested owner paths.
+PR717's format-limit axioms independently emphasize boundary conservation;
+this package's claims are proved and checked above rather than adopting its
+solver-dependent results. Exact reviewed heads are in SOURCES.json.
+
+The final queue refresh through #762 also read the descriptions of #757
+(rseligm2) and #761 (VibeCodyH), which supply algebraic proofs of the fixed
+P111 label-functional COPY floor 63 with careful source ordering, and #760
+(ishan-1729), which audits R420's cleanup/restoration debt. Those independent
+results are not imported or independently reverified here. Our extracted
+forms use the actual PR589 word's ordering; the sharing identity, explicit
+owner restoration and changed-remainder prices are separate from their
+factorization and ghost-return theorems.
+
+The next admissible nomination must specify which term replaces
+32*(8*111-9*C), or supply a different fully priced profile and explicitly
+revisit the mass-saving goal. It needs an actual operator with different
+endpoint/cover obligations before another supplier build. No positive
+nomination meeting that gate has been found here. The goal remains active.
diff --git a/research/bit-sharing-hosting-gate/README.md b/research/bit-sharing-hosting-gate/README.md
new file mode 100644
index 0000000000..bde4e5e687
--- /dev/null
+++ b/research/bit-sharing-hosting-gate/README.md
@@ -0,0 +1,51 @@
+# Price sharing at its physical owner boundary
+
+**Pre-construction result: neither tested mechanism supplies 100 net rank
+units per invocation. No supplier was built and no new kappa is claimed.**
+
+This follows the arithmetic screen in `../bit-role-sharing-budget`. It adds
+an exact scalar sharing candidate, a storage plan, and an independent
+reconstruction of all 126,432 frozen helper reservations. It does not turn
+an optimistic profile into an implemented algorithm.
+
+| Candidate | Gross saving per local invocation | Paid return / limitation |
+|---|---:|---|
+| Nine running decoder accumulators across the nine stages | At most 7 rank units | 288 persistent owned rows, nine temporary rows; ADDRESS alignment remains unproved |
+| Eliminate helper indices 0..12 with a hypothetical free producer | 104 rank units | Exactly 104 rank units return at the idle owner boundaries; net zero |
+| Grant all 439 helpers free, then merge every data climb | Rank mass unchanged | Target moment 1.006919923493207 with COPY retained; fails |
+
+The earlier **100** threshold grants rank-8 consolidation of all local mass.
+With the 222 rank-7 data climbs held fixed, even that favorable relaxation
+fails at 100 (moment 1.000209625827279) and 101. It first passes at **102**.
+This is a scoped refinement, not a claim that 102 is attainable or sufficient
+for a different supplier.
+
+Run from the repository, Python standard library only:
+
+```sh
+sh research/bit-sharing-hosting-gate/replay.sh /tmp/new-hosting-gate
+```
+
+The checker supports `python3 -I -O -B`. It replays every local Boolean
+column, checks independent forward/backward window enumeration and owner
+allocation, prices 449 profiles with two rational interval engines, and
+rejects six false-admission/ownership controls. Exact results are in
+`evidence/PRICE.json`; derivation, costs, and the success gate are in
+[PROOF.md](PROOF.md).
+
+The active research goal remains unachieved. It requires a changed operator
+or boundary obligation with an actual hosting witness, at least 100 net
+units saved per invocation, and a strict complete moment below one at a
+saving greater than 1/99. Both supplier bounds are needed before kappa=0.01
+could be claimed; the complex supplier is unchanged.
+
+Prepared for @androolloyd with substantial OpenAI Codex assistance.
+Apache-2.0. Source and predecessor attribution is in PROOF.md and SOURCES.json.
+
+## Changed-boundary follow-up
+
+[Paired boundary preflight](../bit-paired-boundary-gate/README.md) verifies a
+different composable endpoint and an exact 296-helper owner plan. Its target
+invoice passes without consolidation, but the required local scalar word
+has not been constructed. The explicit wrapper around the current word is
+fully charged and rejected. The construction goal remains unachieved.
diff --git a/research/bit-sharing-hosting-gate/SOURCES.json b/research/bit-sharing-hosting-gate/SOURCES.json
new file mode 100644
index 0000000000..079e9e7842
--- /dev/null
+++ b/research/bit-sharing-hosting-gate/SOURCES.json
@@ -0,0 +1,18 @@
+{
+  "base_commit": "156f259b99723468cfdd2b5d47d0ba894f09bea7",
+  "files": {
+    "research/bit-role-sharing-budget/verify.py": "6bed74cccf0bdf6aaa4984f8ae130f2e3380acdf1525385a4a0be6da796d24e4",
+    "research/bit-role-sharing-budget/SOURCES.json": "adf47404dfc461a95a8de980024b7bb3b329b485f6755bdeae13890390e57cee",
+    "research/e8-bit-p111/data/selection9-p111.json": "4ab1ed4529683cd184987f8bc3031fb7408b9cd22c25ab9cf541a8aaf896eaf1",
+    "research/idle-axis-hosting/hosting_core.py": "d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3",
+    "research/complex-k492-owner-repair/vendor/multicold/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482"
+  },
+  "reviewed_prs": {
+    "521": "a190fdb39f31647fc6f651625353710624627348",
+    "677": "613c02b8b4411f991f108dcc1481b3f9100b996f",
+    "717": "67e9e846d9e8814b2dd01133251bb83fafa8f5b6",
+    "757": "e2ec7d7e719031e8f8b8012a4ab5b20faed074ce",
+    "760": "6872990acee84da98ba6bc12218c5f351192bcd4",
+    "761": "287758702129e6cbca187356b92b311e8a1c843d"
+  }
+}
diff --git a/research/bit-sharing-hosting-gate/VALIDATION.json b/research/bit-sharing-hosting-gate/VALIDATION.json
new file mode 100644
index 0000000000..71244090c9
--- /dev/null
+++ b/research/bit-sharing-hosting-gate/VALIDATION.json
@@ -0,0 +1,29 @@
+{
+  "status": "PASS_VALIDATION_NO_SUPPLIER_ADMISSION",
+  "python": "3.14.7",
+  "focused_replay": "PASS_BIT_SHARING_HOSTING_GATE_REPLAY",
+  "isolated_optimized_evidence_byte_equal": true,
+  "minimal_relocated_replay": true,
+  "source_byte_corruption_rejected": true,
+  "expected_receipt_corruption_rejected": true,
+  "local_boolean_columns": 661,
+  "scalar_source_columns": 888,
+  "owner_slots": 126432,
+  "helper_withdrawal_cases": 439,
+  "independent_rational_moment_comparisons": 449,
+  "ownership_admission_negative_controls": 6,
+  "combined_replay": "PASS_DIRTY_ECHO_ALIAS_REPAIR_AND_FINE_GRID",
+  "combined_log_sha256": "6ad257f83f1b20ce4c745ca6195cfeca35dd2be474defc4d3988432f3282df43",
+  "selected_record_check": "PASS 51110230636731/31250000000000000",
+  "evidence_sha256": "81118e70f60551032272192744ef257620e012cd338c8cbb4aa4b65bcbb8dbae",
+  "not_claimed": [
+    "A constructed replacement supplier",
+    "Physical realization of the running cache",
+    "A fresh full native bit hosting/compiler replay",
+    "Root-wide make verify",
+    "Remote CI",
+    "Formal multiplication proof",
+    "A new kappa"
+  ],
+  "goal_status": "ACTIVE_UNACHIEVED"
+}
diff --git a/research/bit-sharing-hosting-gate/evidence/PRICE.json b/research/bit-sharing-hosting-gate/evidence/PRICE.json
new file mode 100644
index 0000000000..4d9072c276
--- /dev/null
+++ b/research/bit-sharing-hosting-gate/evidence/PRICE.json
@@ -0,0 +1,1867 @@
+{
+  "all_helpers_free": {
+    "gross_local_rank_credit": 1011456,
+    "idle_profile": {
+      "7": 21312,
+      "14": 14208,
+      "28": 14208,
+      "42": 14208
+    },
+    "invoice": {
+      "calls": 283104,
+      "deficit": 10272,
+      "passes_target_arithmetic": false,
+      "profile": {
+        "1": 94176,
+        "2": 86688,
+        "3": 2880,
+        "4": 864,
+        "5": 26496,
+        "6": 2880,
+        "7": 26496,
+        "14": 14208,
+        "28": 14208,
+        "42": 14208
+      },
+      "rank_mass": 1808352,
+      "root": {
+        "kappa_ceiling_display": "0.00377249011462766",
+        "kappa_ceiling_upper": "223531782367721702993/59253112818238286874193",
+        "saving": [
+          "894127129470886811971/236118324143482260684800",
+          "223531782367721702993/59029581035870565171200"
+        ]
+      },
+      "target_moment_display": "1.009534083299681",
+      "target_moment_interval": [
+        "27216985044430200526214394052473315880347551388297213749266707257063/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27216985044430200526214394052473315880347551388297213749266707257065/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    "net_rank_credit": 0,
+    "owner_boundary_rank_debit": 1011456,
+    "removed_helper_indices": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19,
+      20,
+      21,
+      22,
+      23,
+      24,
+      25,
+      26,
+      27,
+      28,
+      29,
+      30,
+      31,
+      32,
+      33,
+      34,
+      35,
+      36,
+      37,
+      38,
+      39,
+      40,
+      41,
+      42,
+      43,
+      44,
+      45,
+      46,
+      47,
+      48,
+      49,
+      50,
+      51,
+      52,
+      53,
+      54,
+      55,
+      56,
+      57,
+      58,
+      59,
+      60,
+      61,
+      62,
+      63,
+      64,
+      65,
+      66,
+      67,
+      68,
+      69,
+      70,
+      71,
+      72,
+      73,
+      74,
+      75,
+      76,
+      77,
+      78,
+      79,
+      80,
+      81,
+      82,
+      83,
+      84,
+      85,
+      86,
+      87,
+      88,
+      89,
+      90,
+      91,
+      92,
+      93,
+      94,
+      95,
+      96,
+      97,
+      98,
+      99,
+      100,
+      101,
+      102,
+      103,
+      104,
+      105,
+      106,
+      107,
+      108,
+      109,
+      110,
+      111,
+      112,
+      113,
+      114,
+      115,
+      116,
+      117,
+      118,
+      119,
+      120,
+      121,
+      122,
+      123,
+      124,
+      125,
+      126,
+      127,
+      128,
+      129,
+      130,
+      131,
+      132,
+      133,
+      134,
+      135,
+      136,
+      137,
+      138,
+      139,
+      140,
+      141,
+      142,
+      143,
+      144,
+      145,
+      146,
+      147,
+      148,
+      149,
+      150,
+      151,
+      152,
+      153,
+      154,
+      155,
+      156,
+      157,
+      158,
+      159,
+      160,
+      161,
+      162,
+      163,
+      164,
+      165,
+      166,
+      167,
+      168,
+      169,
+      170,
+      171,
+      172,
+      173,
+      174,
+      175,
+      176,
+      177,
+      178,
+      179,
+      180,
+      181,
+      182,
+      183,
+      184,
+      185,
+      186,
+      187,
+      188,
+      189,
+      190,
+      191,
+      192,
+      193,
+      194,
+      195,
+      196,
+      197,
+      198,
+      199,
+      200,
+      201,
+      202,
+      203,
+      204,
+      205,
+      206,
+      207,
+      208,
+      209,
+      210,
+      211,
+      212,
+      213,
+      214,
+      215,
+      216,
+      217,
+      218,
+      219,
+      220,
+      221,
+      222,
+      223,
+      224,
+      225,
+      226,
+      227,
+      228,
+      229,
+      230,
+      231,
+      232,
+      233,
+      234,
+      235,
+      236,
+      237,
+      238,
+      239,
+      240,
+      241,
+      242,
+      243,
+      244,
+      245,
+      246,
+      247,
+      248,
+      249,
+      250,
+      251,
+      252,
+      253,
+      254,
+      255,
+      256,
+      257,
+      258,
+      259,
+      260,
+      261,
+      262,
+      263,
+      264,
+      265,
+      266,
+      267,
+      268,
+      269,
+      270,
+      271,
+      272,
+      273,
+      274,
+      275,
+      276,
+      277,
+      278,
+      279,
+      280,
+      281,
+      282,
+      283,
+      284,
+      285,
+      286,
+      287,
+      288,
+      289,
+      290,
+      291,
+      292,
+      293,
+      294,
+      295,
+      296,
+      297,
+      298,
+      299,
+      300,
+      301,
+      302,
+      303,
+      304,
+      305,
+      306,
+      307,
+      308,
+      309,
+      310,
+      311,
+      312,
+      313,
+      314,
+      315,
+      316,
+      317,
+      318,
+      319,
+      320,
+      321,
+      322,
+      323,
+      324,
+      325,
+      326,
+      327,
+      328,
+      329,
+      330,
+      331,
+      332,
+      333,
+      334,
+      335,
+      336,
+      337,
+      338,
+      339,
+      340,
+      341,
+      342,
+      343,
+      344,
+      345,
+      346,
+      347,
+      348,
+      349,
+      350,
+      351,
+      352,
+      353,
+      354,
+      355,
+      356,
+      357,
+      358,
+      359,
+      360,
+      361,
+      362,
+      363,
+      364,
+      365,
+      366,
+      367,
+      368,
+      369,
+      370,
+      371,
+      372,
+      373,
+      374,
+      375,
+      376,
+      377,
+      378,
+      379,
+      380,
+      381,
+      382,
+      383,
+      384,
+      385,
+      386,
+      387,
+      388,
+      389,
+      390,
+      391,
+      392,
+      393,
+      394,
+      395,
+      396,
+      397,
+      398,
+      399,
+      400,
+      401,
+      402,
+      403,
+      404,
+      405,
+      406,
+      407,
+      408,
+      409,
+      410,
+      411,
+      412,
+      413,
+      414,
+      415,
+      416,
+      417,
+      418,
+      419,
+      420,
+      421,
+      422,
+      423,
+      424,
+      425,
+      426,
+      427,
+      428,
+      429,
+      430,
+      431,
+      432,
+      433,
+      434,
+      435,
+      436,
+      437,
+      438
+    ]
+  },
+  "all_single_withdrawals": {
+    "count": 439,
+    "highest_moment_helper": 248,
+    "highest_moment_upper": "6926846640672223075452307157033512221959875348502819290153888238363/6739986666787659948666753771754907668409286105635143120275902562304",
+    "lowest_moment_helper": 0,
+    "lowest_moment_upper": "1731680710731606330318646812987632133285378122422946195723136570887/1684996666696914987166688442938726917102321526408785780068975640576",
+    "net_rank_credit_each": 0
+  },
+  "baseline": {
+    "calls": 904896,
+    "deficit": 10272,
+    "passes_target_arithmetic": false,
+    "profile": {
+      "1": 381024,
+      "2": 400416,
+      "3": 22752,
+      "4": 26880,
+      "5": 29376,
+      "6": 17376,
+      "7": 26784,
+      "42": 288
+    },
+    "rank_mass": 1808352,
+    "root": {
+      "kappa_ceiling_display": "0.0017304274698236",
+      "kappa_ceiling_upper": "409293887612951698503/236527618031095212383303",
+      "saving": [
+        "204646943806475849251/118059162071741130342400",
+        "409293887612951698503/236118324143482260684800"
+      ]
+    },
+    "target_moment_display": "1.027739494928555",
+    "target_moment_interval": [
+      "27707801970998165129328266358789862708758851972799718827248429472749/26959946667150639794667015087019630673637144422540572481103610249216",
+      "27707801970998165129328266358789862708758851972799718827248429472751/26959946667150639794667015087019630673637144422540572481103610249216"
+    ]
+  },
+  "hosting": {
+    "independent_parent_expansion_equal": true,
+    "occupied_coordinates_per_replica": 31608,
+    "owner_sha256": "13ebf06203985f4467ef60706d6cdf5c22ae4e00cc7d65628d28eba875cf2705",
+    "slots_all_replicas": 126432,
+    "slots_per_replica": 3951,
+    "windows": {
+      "0": [
+        1,
+        14,
+        [
+          0,
+          1
+        ]
+      ],
+      "1": [
+        1,
+        7,
+        [
+          2
+        ]
+      ],
+      "2": [
+        2,
+        28,
+        [
+          0,
+          1,
+          2,
+          3
+        ]
+      ],
+      "3": [
+        2,
+        7,
+        [
+          4
+        ]
+      ],
+      "4": [
+        3,
+        42,
+        [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5
+        ]
+      ],
+      "5": [
+        3,
+        7,
+        [
+          6
+        ]
+      ],
+      "6": [
+        0,
+        42,
+        [
+          3,
+          4,
+          5,
+          6,
+          7,
+          8
+        ]
+      ],
+      "7": [
+        1,
+        28,
+        [
+          5,
+          6,
+          7,
+          8
+        ]
+      ],
+      "8": [
+        2,
+        14,
+        [
+          7,
+          8
+        ]
+      ],
+      "9": [
+        3,
+        0,
+        []
+      ]
+    }
+  },
+  "independent_moment_comparisons": 449,
+  "joint_free_helper_and_copy_relaxations": {
+    "0": {
+      "calls": "127872",
+      "deficit": "28416",
+      "passes_target_arithmetic": true,
+      "profile": {
+        "7": "85248",
+        "14": 14208,
+        "28": 14208,
+        "42": 14208
+      },
+      "rank_mass": "1790208",
+      "root": {
+        "kappa_ceiling_display": "0.0125974219309974",
+        "kappa_ceiling_upper": "3012431019465693682821/239130755162947954367621",
+        "saving": [
+          "150621550973284684141/11805916207174113034240",
+          "3012431019465693682821/236118324143482260684800"
+        ]
+      },
+      "target_moment_display": "0.9967176251943854",
+      "target_moment_interval": [
+        "26871454017449672280747880159809840419866145789540276766721331502489/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26871454017449672280747880159809840419866145789540276766721331502491/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    "63": {
+      "calls": "130464",
+      "deficit": "10272",
+      "passes_target_arithmetic": false,
+      "profile": {
+        "7": "87840",
+        "14": 14208,
+        "28": 14208,
+        "42": 14208
+      },
+      "rank_mass": "1808352",
+      "root": {
+        "kappa_ceiling_display": "0.00454046092290517",
+        "kappa_ceiling_upper": "269243997839752415801/59298825033710317587001",
+        "saving": [
+          "1076975991359009663203/236118324143482260684800",
+          "269243997839752415801/59029581035870565171200"
+        ]
+      },
+      "target_moment_display": "1.006919923493207",
+      "target_moment_interval": [
+        "3393313429433533973566667994375252279396556649325500958882637104007/3369993333393829974333376885877453834204643052817571560137951281152",
+        "13573253717734135894266671977501009117586226597302003835530548416029/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    }
+  },
+  "largest_net_mass_credit_from_copy_erasure_per_invocation": 63,
+  "live": 28416,
+  "local_invocations": 288,
+  "local_replay": {
+    "columns": 661,
+    "copy_ranks": [
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7,
+      7
+    ],
+    "independent_retained_inputs": 9,
+    "paid_histogram": {
+      "1": 1323,
+      "2": 1342,
+      "3": 79,
+      "4": 44,
+      "5": 102,
+      "6": 11,
+      "7": 19
+    },
+    "rank_mass": 5129,
+    "response_rank": 9,
+    "role_climb_mass": {
+      "helper": 3512,
+      "source": 777,
+      "target": 777
+    }
+  },
+  "negative_controls": [
+    "duplicate owner and helper",
+    "cache carried beyond untouched lifetime",
+    "owner coordinate outside pending frame",
+    "104 gross rank units reported as net",
+    "100 admitted without data rank-seven boundaries",
+    "free helpers alone admitted"
+  ],
+  "nine_stage_running_decoder_cache": {
+    "accumulation_xor_scans_all_replicas": 2304,
+    "address_chart_alignment_proved": false,
+    "best_case_invoice": {
+      "calls": 904608,
+      "deficit": 12288,
+      "passes_target_arithmetic": false,
+      "profile": {
+        "1": 381024,
+        "2": 400416,
+        "3": 22752,
+        "4": 26880,
+        "5": 29376,
+        "6": 17376,
+        "7": 26496,
+        "42": 288
+      },
+      "rank_mass": 1806336,
+      "root": {
+        "kappa_ceiling_display": "0.00206969950648135",
+        "kappa_ceiling_upper": "244853763188315141747/118304015834929445484147",
+        "saving": [
+          "489707526376630283493/236118324143482260684800",
+          "244853763188315141747/118059162071741130342400"
+        ]
+      },
+      "target_moment_display": "1.026605906228685",
+      "target_moment_interval": [
+        "3459655060013401203557901853248841480048935560418524146401334721183/3369993333393829974333376885877453834204643052817571560137951281152",
+        "13838620240053604814231607412995365920195742241674096585605338884733/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    },
+    "dirty_cancellation_xor_scans_first_eight_stages": 2304,
+    "dirty_extraction_temporary_rows": 9,
+    "dirty_form_xor_scans_per_invocation": 471,
+    "dirty_forms_rank": 9,
+    "existing_whole_lifetime_owner_windows": 0,
+    "independent_dirty_columns": 3951,
+    "productive_denominator": 28416,
+    "prospective_physical_rows": 28722,
+    "raw_total_parity_nonzero_rank": 9,
+    "running_accumulator_rows_all_replicas": 288,
+    "running_accumulator_rows_per_replica": 9,
+    "saved_copy_rank_global": 2016,
+    "saved_copy_rank_per_invocation": "7",
+    "scope": "Exact source-only scalar identity; copy saving is an upper credit before new realization and transport costs.",
+    "source_bank_masks": [
+      1,
+      3,
+      6,
+      14,
+      26,
+      58,
+      106,
+      234,
+      170
+    ],
+    "source_bank_rank": 8,
+    "source_forms_rank": 9,
+    "symbolic_source_columns": 888
+  },
+  "physical": 28425,
+  "rank_seven_boundary_fences": {
+    "100": {
+      "calls": "252972",
+      "deficit": "39072",
+      "passes_target_arithmetic": false,
+      "profile": {
+        "2": 13920,
+        "4": 14208,
+        "6": 14208,
+        "7": 85248,
+        "8": "125100",
+        "42": 288
+      },
+      "rank_mass": "1779552",
+      "target_moment_display": "1.000209625827279",
+      "target_moment_interval": [
+        "13482799084137069838509044530951245063177410322473687980050304925417/13479973333575319897333507543509815336818572211270286240551805124608",
+        "6741399542068534919254522265475622531588705161236843990025152462709/6739986666787659948666753771754907668409286105635143120275902562304"
+      ]
+    },
+    "101": {
+      "calls": "252936",
+      "deficit": "39360",
+      "passes_target_arithmetic": false,
+      "profile": {
+        "2": 13920,
+        "4": 14208,
+        "6": 14208,
+        "7": 85248,
+        "8": "125064",
+        "42": 288
+      },
+      "rank_mass": "1779264",
+      "target_moment_display": "1.000047902863863",
+      "target_moment_interval": [
+        "26961238125805592877403607131303783145129189268354637988794711044139/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26961238125805592877403607131303783145129189268354637988794711044141/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    "102": {
+      "calls": "252900",
+      "deficit": "39648",
+      "passes_target_arithmetic": true,
+      "profile": {
+        "2": 13920,
+        "4": 14208,
+        "6": 14208,
+        "7": 85248,
+        "8": "125028",
+        "42": 288
+      },
+      "rank_mass": "1778976",
+      "target_moment_display": "0.9998861799004471",
+      "target_moment_interval": [
+        "26956878083337046077789125200705076163903557891761900017488812237445/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26956878083337046077789125200705076163903557891761900017488812237447/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    "99": {
+      "calls": "253008",
+      "deficit": "38784",
+      "passes_target_arithmetic": false,
+      "profile": {
+        "2": 13920,
+        "4": 14208,
+        "6": 14208,
+        "7": 85248,
+        "8": "125136",
+        "42": 288
+      },
+      "rank_mass": "1779840",
+      "target_moment_display": "1.000371348790695",
+      "target_moment_interval": [
+        "3371244776342835809579071374062649638447556502692514241425813582191/3369993333393829974333376885877453834204643052817571560137951281152",
+        "13484979105371343238316285496250598553790226010770056965703254328765/13479973333575319897333507543509815336818572211270286240551805124608"
+      ]
+    }
+  },
+  "status": "PASS_PREBUILD_HOSTING_GATE_NO_100_NET_UNIT_CONSTRUCTION",
+  "success_goal_met": false,
+  "supplier_built": false,
+  "target_100_mass_credit_requires_effective_copy_mass": -37,
+  "target_saving": "1/99",
+  "thirteen_helper_withdrawal": {
+    "gross_local_rank_credit": 29952,
+    "idle_profile": {
+      "2": 13472,
+      "4": 13600,
+      "6": 13792,
+      "7": 21312,
+      "10": 32,
+      "12": 96,
+      "14": 416,
+      "18": 32,
+      "20": 64,
+      "26": 64,
+      "28": 448,
+      "34": 128,
+      "42": 480
+    },
+    "invoice": {
+      "calls": 884448,
+      "deficit": 10272,
+      "passes_target_arithmetic": false,
+      "profile": {
+        "1": 368352,
+        "2": 393056,
+        "3": 22464,
+        "4": 25984,
+        "5": 29088,
+        "6": 16960,
+        "7": 26784,
+        "10": 32,
+        "12": 96,
+        "14": 416,
+        "18": 32,
+        "20": 64,
+        "26": 64,
+        "28": 448,
+        "34": 128,
+        "42": 480
+      },
+      "rank_mass": 1808352,
+      "root": {
+        "kappa_ceiling_display": "0.00175837690642137",
+        "kappa_ceiling_upper": "415916346054719737991/236534240489536980422791",
+        "saving": [
+          "41591634605471973799/23611832414348226068480",
+          "415916346054719737991/236118324143482260684800"
+        ]
+      },
+      "target_moment_display": "1.027203943736788",
+      "target_moment_interval": [
+        "27693363539430606995803497173054939655159789470739329047651151904865/26959946667150639794667015087019630673637144422540572481103610249216",
+        "27693363539430606995803497173054939655159789470739329047651151904867/26959946667150639794667015087019630673637144422540572481103610249216"
+      ]
+    },
+    "net_rank_credit": 0,
+    "owner_boundary_rank_debit": 29952,
+    "removed_helper_indices": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12
+    ],
+    "returned_slots_one_replica": [
+      [
+        0,
+        0,
+        0,
+        8,
+        1,
+        0
+      ],
+      [
+        0,
+        1,
+        0,
+        8,
+        1,
+        1
+      ],
+      [
+        0,
+        2,
+        0,
+        8,
+        1,
+        2
+      ],
+      [
+        0,
+        3,
+        0,
+        8,
+        1,
+        3
+      ],
+      [
+        0,
+        4,
+        0,
+        8,
+        1,
+        4
+      ],
+      [
+        0,
+        5,
+        0,
+        8,
+        1,
+        5
+      ],
+      [
+        0,
+        6,
+        0,
+        8,
+        1,
+        6
+      ],
+      [
+        0,
+        7,
+        0,
+        8,
+        1,
+        7
+      ],
+      [
+        0,
+        8,
+        0,
+        8,
+        1,
+        8
+      ],
+      [
+        0,
+        9,
+        0,
+        8,
+        1,
+        9
+      ],
+      [
+        0,
+        10,
+        0,
+        8,
+        1,
+        10
+      ],
+      [
+        0,
+        11,
+        0,
+        8,
+        1,
+        11
+      ],
+      [
+        0,
+        12,
+        0,
+        8,
+        1,
+        12
+      ],
+      [
+        2,
+        0,
+        0,
+        8,
+        0,
+        0
+      ],
+      [
+        2,
+        0,
+        8,
+        8,
+        0,
+        1
+      ],
+      [
+        2,
+        0,
+        16,
+        8,
+        0,
+        2
+      ],
+      [
+        2,
+        1,
+        0,
+        8,
+        0,
+        3
+      ],
+      [
+        2,
+        1,
+        8,
+        8,
+        0,
+        4
+      ],
+      [
+        2,
+        1,
+        16,
+        8,
+        0,
+        5
+      ],
+      [
+        2,
+        2,
+        0,
+        8,
+        0,
+        6
+      ],
+      [
+        2,
+        2,
+        8,
+        8,
+        0,
+        7
+      ],
+      [
+        2,
+        2,
+        16,
+        8,
+        0,
+        8
+      ],
+      [
+        2,
+        3,
+        0,
+        8,
+        0,
+        9
+      ],
+      [
+        2,
+        3,
+        8,
+        8,
+        0,
+        10
+      ],
+      [
+        2,
+        3,
+        16,
+        8,
+        0,
+        11
+      ],
+      [
+        2,
+        4,
+        0,
+        8,
+        0,
+        12
+      ],
+      [
+        2,
+        218,
+        16,
+        8,
+        2,
+        0
+      ],
+      [
+        2,
+        219,
+        0,
+        8,
+        2,
+        1
+      ],
+      [
+        2,
+        219,
+        8,
+        8,
+        2,
+        2
+      ],
+      [
+        2,
+        219,
+        16,
+        8,
+        2,
+        3
+      ],
+      [
+        2,
+        220,
+        0,
+        8,
+        2,
+        4
+      ],
+      [
+        2,
+        220,
+        8,
+        8,
+        2,
+        5
+      ],
+      [
+        2,
+        220,
+        16,
+        8,
+        2,
+        6
+      ],
+      [
+        2,
+        221,
+        0,
+        8,
+        2,
+        7
+      ],
+      [
+        2,
+        221,
+        8,
+        8,
+        2,
+        8
+      ],
+      [
+        2,
+        221,
+        16,
+        8,
+        2,
+        9
+      ],
+      [
+        4,
+        0,
+        0,
+        8,
+        2,
+        10
+      ],
+      [
+        4,
+        0,
+        8,
+        8,
+        2,
+        11
+      ],
+      [
+        4,
+        0,
+        16,
+        8,
+        2,
+        12
+      ],
+      [
+        4,
+        85,
+        32,
+        8,
+        4,
+        0
+      ],
+      [
+        4,
+        86,
+        0,
+        8,
+        4,
+        1
+      ],
+      [
+        4,
+        86,
+        8,
+        8,
+        4,
+        2
+      ],
+      [
+        4,
+        86,
+        16,
+        8,
+        4,
+        3
+      ],
+      [
+        4,
+        86,
+        24,
+        8,
+        4,
+        4
+      ],
+      [
+        4,
+        86,
+        32,
+        8,
+        4,
+        5
+      ],
+      [
+        4,
+        87,
+        0,
+        8,
+        4,
+        6
+      ],
+      [
+        4,
+        87,
+        8,
+        8,
+        4,
+        7
+      ],
+      [
+        4,
+        87,
+        16,
+        8,
+        4,
+        8
+      ],
+      [
+        4,
+        87,
+        24,
+        8,
+        4,
+        9
+      ],
+      [
+        4,
+        87,
+        32,
+        8,
+        4,
+        10
+      ],
+      [
+        4,
+        88,
+        0,
+        8,
+        4,
+        11
+      ],
+      [
+        4,
+        88,
+        8,
+        8,
+        4,
+        12
+      ],
+      [
+        4,
+        136,
+        8,
+        8,
+        5,
+        0
+      ],
+      [
+        4,
+        136,
+        16,
+        8,
+        5,
+        1
+      ],
+      [
+        4,
+        136,
+        24,
+        8,
+        5,
+        2
+      ],
+      [
+        4,
+        136,
+        32,
+        8,
+        5,
+        3
+      ],
+      [
+        4,
+        137,
+        0,
+        8,
+        5,
+        4
+      ],
+      [
+        4,
+        137,
+        8,
+        8,
+        5,
+        5
+      ],
+      [
+        4,
+        137,
+        16,
+        8,
+        5,
+        6
+      ],
+      [
+        4,
+        137,
+        24,
+        8,
+        5,
+        7
+      ],
+      [
+        4,
+        137,
+        32,
+        8,
+        5,
+        8
+      ],
+      [
+        4,
+        138,
+        0,
+        8,
+        5,
+        9
+      ],
+      [
+        4,
+        138,
+        8,
+        8,
+        5,
+        10
+      ],
+      [
+        4,
+        138,
+        16,
+        8,
+        5,
+        11
+      ],
+      [
+        4,
+        138,
+        24,
+        8,
+        5,
+        12
+      ],
+      [
+        6,
+        0,
+        0,
+        8,
+        3,
+        0
+      ],
+      [
+        6,
+        0,
+        8,
+        8,
+        3,
+        1
+      ],
+      [
+        6,
+        0,
+        16,
+        8,
+        3,
+        2
+      ],
+      [
+        6,
+        0,
+        24,
+        8,
+        3,
+        3
+      ],
+      [
+        6,
+        0,
+        32,
+        8,
+        3,
+        4
+      ],
+      [
+        6,
+        1,
+        0,
+        8,
+        3,
+        5
+      ],
+      [
+        6,
+        1,
+        8,
+        8,
+        3,
+        6
+      ],
+      [
+        6,
+        1,
+        16,
+        8,
+        3,
+        7
+      ],
+      [
+        6,
+        1,
+        24,
+        8,
+        3,
+        8
+      ],
+      [
+        6,
+        1,
+        32,
+        8,
+        3,
+        9
+      ],
+      [
+        6,
+        2,
+        0,
+        8,
+        3,
+        10
+      ],
+      [
+        6,
+        2,
+        8,
+        8,
+        3,
+        11
+      ],
+      [
+        6,
+        2,
+        16,
+        8,
+        3,
+        12
+      ],
+      [
+        6,
+        125,
+        8,
+        8,
+        7,
+        0
+      ],
+      [
+        6,
+        125,
+        16,
+        8,
+        7,
+        1
+      ],
+      [
+        6,
+        125,
+        24,
+        8,
+        7,
+        2
+      ],
+      [
+        6,
+        125,
+        32,
+        8,
+        7,
+        3
+      ],
+      [
+        6,
+        126,
+        0,
+        8,
+        7,
+        4
+      ],
+      [
+        6,
+        126,
+        8,
+        8,
+        7,
+        5
+      ],
+      [
+        6,
+        126,
+        16,
+        8,
+        7,
+        6
+      ],
+      [
+        6,
+        126,
+        24,
+        8,
+        7,
+        7
+      ],
+      [
+        6,
+        126,
+        32,
+        8,
+        7,
+        8
+      ],
+      [
+        6,
+        127,
+        0,
+        8,
+        7,
+        9
+      ],
+      [
+        6,
+        127,
+        8,
+        8,
+        7,
+        10
+      ],
+      [
+        6,
+        127,
+        16,
+        8,
+        7,
+        11
+      ],
+      [
+        6,
+        127,
+        24,
+        8,
+        7,
+        12
+      ],
+      [
+        7,
+        3,
+        8,
+        8,
+        6,
+        0
+      ],
+      [
+        7,
+        3,
+        16,
+        8,
+        6,
+        1
+      ],
+      [
+        7,
+        4,
+        0,
+        8,
+        6,
+        2
+      ],
+      [
+        7,
+        4,
+        8,
+        8,
+        6,
+        3
+      ],
+      [
+        7,
+        4,
+        16,
+        8,
+        6,
+        4
+      ],
+      [
+        7,
+        5,
+        0,
+        8,
+        6,
+        5
+      ],
+      [
+        7,
+        5,
+        8,
+        8,
+        6,
+        6
+      ],
+      [
+        7,
+        5,
+        16,
+        8,
+        6,
+        7
+      ],
+      [
+        7,
+        6,
+        0,
+        8,
+        6,
+        8
+      ],
+      [
+        7,
+        6,
+        8,
+        8,
+        6,
+        9
+      ],
+      [
+        7,
+        6,
+        16,
+        8,
+        6,
+        10
+      ],
+      [
+        7,
+        7,
+        0,
+        8,
+        6,
+        11
+      ],
+      [
+        7,
+        7,
+        8,
+        8,
+        6,
+        12
+      ],
+      [
+        7,
+        149,
+        16,
+        8,
+        8,
+        0
+      ],
+      [
+        7,
+        150,
+        0,
+        8,
+        8,
+        1
+      ],
+      [
+        7,
+        150,
+        8,
+        8,
+        8,
+        2
+      ],
+      [
+        7,
+        150,
+        16,
+        8,
+        8,
+        3
+      ],
+      [
+        7,
+        151,
+        0,
+        8,
+        8,
+        4
+      ],
+      [
+        7,
+        151,
+        8,
+        8,
+        8,
+        5
+      ],
+      [
+        7,
+        151,
+        16,
+        8,
+        8,
+        6
+      ],
+      [
+        7,
+        152,
+        0,
+        8,
+        8,
+        7
+      ],
+      [
+        7,
+        152,
+        8,
+        8,
+        8,
+        8
+      ],
+      [
+        7,
+        152,
+        16,
+        8,
+        8,
+        9
+      ],
+      [
+        7,
+        153,
+        0,
+        8,
+        8,
+        10
+      ],
+      [
+        7,
+        153,
+        8,
+        8,
+        8,
+        11
+      ],
+      [
+        7,
+        153,
+        16,
+        8,
+        8,
+        12
+      ]
+    ]
+  }
+}
diff --git a/research/bit-sharing-hosting-gate/replay.sh b/research/bit-sharing-hosting-gate/replay.sh
new file mode 100644
index 0000000000..78d68bd4f2
--- /dev/null
+++ b/research/bit-sharing-hosting-gate/replay.sh
@@ -0,0 +1,12 @@
+#!/bin/sh
+set -eu
+if [ "$#" -ne 1 ] || [ -e "$1" ]; then
+    echo "usage: sh research/bit-sharing-hosting-gate/replay.sh NEW_OUTPUT_DIRECTORY" >&2
+    exit 2
+fi
+here=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+mkdir -p -- "$1"
+out=$(CDPATH= cd -- "$1" && pwd)
+python3 -I -B "$here/verify.py" --out "$out/PRICE.json"
+cmp "$out/PRICE.json" "$here/evidence/PRICE.json"
+echo PASS_BIT_SHARING_HOSTING_GATE_REPLAY
diff --git a/research/bit-sharing-hosting-gate/verify.py b/research/bit-sharing-hosting-gate/verify.py
new file mode 100644
index 0000000000..b5a42d4ebb
--- /dev/null
+++ b/research/bit-sharing-hosting-gate/verify.py
@@ -0,0 +1,417 @@
+#!/usr/bin/env python3
+"""Exact pre-construction invoice for helper withdrawal and owner restoration.
+
+Prepared for androolloyd with substantial OpenAI Codex assistance. Apache-2.0.
+Deleted helper computations are granted free, not claimed implemented.
+"""
+import argparse
+from collections import Counter, defaultdict
+from fractions import Fraction as Q
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def module(name, relative):
+    spec = importlib.util.spec_from_file_location(name, ROOT / relative)
+    result = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(result)
+    return result
+
+
+def mass(h):
+    return sum(r*n for r, n in h.items())
+
+
+def clean(h):
+    need(all(n >= 0 for n in h.values()), 'negative child count')
+    return Counter({r: n for r, n in h.items() if n})
+
+
+def schedule():
+    """Independent transcription of the nine-stage chronological recipe."""
+    result = [dict(kind='local', stage=0, pair=0)]
+    idle = 0
+    for pair in range(4):
+        result.append(dict(kind='local', stage=2*pair+1, pair=pair))
+        if pair < 3:
+            result.append(dict(kind='idle', pair=pair+1, rank=14*(pair+1), idx=idle))
+            idle += 1
+            result.append(dict(kind='bridge', dst=pair, src=pair+1))
+        result.append(dict(kind='local', stage=2*pair+2, pair=pair))
+        if pair < 3:
+            result.append(dict(kind='idle', pair=pair+1, rank=7, idx=idle))
+            idle += 1
+            result.append(dict(kind='bridge', dst=pair, src=pair+1))
+        else:
+            for p in range(4):
+                result.append(dict(kind='idle', pair=p, rank=14*(3-p), idx=idle))
+                idle += 1
+    for pair in range(2, -1, -1):
+        result.append(dict(kind='bridge', dst=pair+1, src=pair))
+    return result
+
+
+def windows(events):
+    """Read each window backward, rather than tracking the parent's last-touch table."""
+    result = {}
+    for pos, event in enumerate(events):
+        if event['kind'] != 'idle':
+            continue
+        stages = []
+        p = event['pair']
+        for before in reversed(events[:pos]):
+            if before['kind'] == 'local':
+                if before['pair'] == p:
+                    break
+                stages.append(before['stage'])
+            if before['kind'] == 'bridge' and p in (before['src'], before['dst']):
+                break
+        result[event['idx']] = (p, event['rank'], frozenset(stages))
+    return result
+
+
+def expand(selection, win):
+    """Independent literal owner allocation from the frozen integer selection."""
+    demands = defaultdict(list)
+    for idx, width, stage, count in sorted(selection['stages']):
+        need(width == 8 and stage in win[idx][2], 'stage outside untouched window')
+        demands[idx].extend([stage]*count)
+    next_helper = Counter()
+    slots = []
+    remainder = {}
+    patterns = defaultdict(list)
+    for idx, widths, count in selection['patterns']:
+        need(idx in win and count > 0 and all(w == 8 for w in widths), 'bad pattern')
+        patterns[idx].append((tuple(widths), count))
+    for idx in sorted(win):
+        copy = take = 0
+        for widths, count in sorted(patterns[idx], key=lambda z: (-sum(z[0]), z[0])):
+            need(sum(widths) <= win[idx][1], 'overfull owner')
+            for _ in range(count):
+                offset = 0
+                for width in widths:
+                    need(take < len(demands[idx]), 'missing stage demand')
+                    stage = demands[idx][take]
+                    helper = next_helper[stage]
+                    slots.append((idx, copy, offset, width, stage, helper))
+                    next_helper[stage] += 1
+                    offset += width
+                    take += 1
+                remainder[idx, copy] = win[idx][1] - offset
+                copy += 1
+        need(copy == 222 and take == len(demands[idx]), 'incomplete owner selection')
+    need(next_helper == Counter({s: 439 for s in range(9)}), 'helper coverage')
+    return slots, remainder
+
+
+def audit_slots(slots, win):
+    occupied = set()
+    helpers = set()
+    for idx, copy, offset, width, stage, helper in slots:
+        need(stage in win[idx][2], 'untouched ownership lifetime')
+        need(0 <= copy < 222 and width == 8 and 0 <= offset <= win[idx][1]-width,
+             'owner coordinate range')
+        need((stage, helper) not in helpers and 0 <= helper < 439, 'duplicate helper owner')
+        helpers.add((stage, helper))
+        for axis in range(offset, offset+width):
+            key = idx, copy, axis
+            need(key not in occupied, 'overlapping owner coordinates')
+            occupied.add(key)
+    need(len(helpers) == 9*439, 'missing helper owner')
+    return len(occupied)
+
+
+def role_profiles(word, budget):
+    dims = [budget.rational_rank(word['lines'][i] for i in frame) for frame in word['frames']]
+    current = word['start'][:]
+    profiles = [Counter() for _ in current]
+
+    def visit(role, frame):
+        old = current[role]
+        need(set(word['frames'][old]) <= set(word['frames'][frame]), 'nonnested role path')
+        delta = dims[frame]-dims[old]
+        if delta:
+            profiles[role][delta] += 1
+        current[role] = frame
+
+    for section in ('D', 'A', 'B', 'C'):
+        for frame, target, sources in word[section]:
+            for role in [target, *sources]:
+                visit(role, frame)
+    for role, frame in enumerate(word['final']):
+        visit(role, frame)
+    need(all(mass(h) == 7 for h in profiles[:222]), 'data boundary ranks')
+    need(all(mass(h) == 8 for h in profiles[222:]), 'helper boundary ranks')
+    total = Counter({7: 9})
+    for h in profiles:
+        total.update(h)
+    return profiles, total
+
+
+def decoder_cache(word, budget, win):
+    """An exact scalar sharing candidate, before ADDRESS-chart realization.
+
+    The last source bank is the XOR of the preceding eight. Nine running
+    accumulators suffice; retaining all 72 previous forms is unnecessary.
+    """
+    rows = [1 << i for i in range(8)]
+    inputs = [rows[0]]
+    rows[1] ^= rows[0]
+    for pair in range(4):
+        inputs.append(rows[2*pair+1])
+        rows[2*pair] ^= rows[2*pair+1]
+        if pair < 3:
+            rows[2*pair] ^= rows[2*(pair+1)]
+            rows[2*(pair+1)+1] ^= rows[2*pair+1]
+        inputs.append(rows[2*pair])
+        rows[2*pair+1] ^= rows[2*pair]
+        if pair < 3:
+            rows[2*pair] ^= rows[2*(pair+1)]
+            rows[2*(pair+1)+1] ^= rows[2*pair+1]
+    for pair in range(2, -1, -1):
+        rows[2*(pair+1)] ^= rows[2*pair]
+        rows[2*pair+1] ^= rows[2*(pair+1)+1]
+    for pair in range(4):
+        rows[2*pair], rows[2*pair+1] = rows[2*pair+1], rows[2*pair]
+    need(rows == [1 << i for i in range(8)], 'global scalar boundary')
+    need(inputs == [1, 3, 6, 14, 26, 58, 106, 234, 170], 'source bank masks')
+    parity = 0
+    for mask in inputs:
+        parity ^= mask
+    need(parity == 0 and budget.binary_rank(inputs[:8]) == 8, 'unique nine-stage dependence')
+
+    v = word['v']
+    local = [1 << i for i in range(2*v+word['R'])]
+    for _, target, sources in word['A']:
+        for source in sources:
+            local[target] ^= local[source]
+    source_forms = [local[r] & ((1 << v)-1) for r in word['ret']]
+    dirty_forms = [local[r] >> (2*v) for r in word['ret']]
+    reverse = [1 << i for i in range(2*v+word['R'])]
+    for section in ('C', 'B'):
+        for _, target, sources in reversed(word[section]):
+            for source in sources:
+                reverse[target] ^= reverse[source]
+    need([reverse[r] for r in word['ret']] == [local[r] for r in word['ret']],
+         'reflected scalar copy totals differ')
+    need(budget.binary_rank(source_forms) == budget.binary_rank(dirty_forms) == 9,
+         'source and dirty total ranks')
+    # Each bit is an independent (original bank, live port) source input.
+    version = []
+    for mask in inputs:
+        version.append([sum(form << (v*b) for b in range(8) if mask >> b & 1)
+                        for form in source_forms])
+    accumulators = [0]*9
+    for stage in range(8):
+        accumulators = [a ^ b for a, b in zip(accumulators, version[stage])]
+    need(accumulators == version[8], 'running source total identity')
+    # Supposed raw-total reuse has an independent dirty column in every
+    # stage, even though its source contribution cancels.
+    dirty_parities = [sum(form << (439*s) for s in range(9)) for form in dirty_forms]
+    need(budget.binary_rank(dirty_parities) == 9, 'raw totals do not cancel dirt')
+    need(not any(set(range(9)) <= set(stages) for _, _, stages in win.values()),
+         'unexpected full-lifetime idle owner')
+    return dict(source_bank_masks=inputs, source_bank_rank=8,
+                source_forms_rank=9, dirty_forms_rank=9,
+                symbolic_source_columns=8*v, independent_dirty_columns=9*439,
+                running_accumulator_rows_per_replica=9,
+                running_accumulator_rows_all_replicas=9*32,
+                dirty_extraction_temporary_rows=9,
+                prospective_physical_rows=28425+9*32+9,
+                productive_denominator=28416,
+                raw_total_parity_nonzero_rank=9,
+                existing_whole_lifetime_owner_windows=0,
+                dirty_form_xor_scans_per_invocation=sum(x.bit_count() for x in dirty_forms),
+                accumulation_xor_scans_all_replicas=8*9*32,
+                dirty_cancellation_xor_scans_first_eight_stages=8*9*32,
+                saved_copy_rank_global=9*7*32,
+                saved_copy_rank_per_invocation=Q(9*7*32, 288),
+                address_chart_alignment_proved=False,
+                scope='Exact source-only scalar identity; copy saving is an upper credit before new realization and transport costs.')
+
+
+def main(out):
+    sources = json.loads((HERE/'SOURCES.json').read_text())
+    for path, digest in sources['files'].items():
+        need(hashlib.sha256((ROOT/path).read_bytes()).hexdigest() == digest, 'source hash: '+path)
+    budget = module('sharing_budget', 'research/bit-role-sharing-budget/verify.py')
+    mercator = module('independent_moment', 'research/complex-k492-owner-repair/vendor/multicold/engines/moment.py')
+    hosting = module('parent_hosting', 'research/idle-axis-hosting/hosting_core.py')
+    _, word, expected, constants = budget.pinned_inputs()
+    local, local_receipt = budget.extract_word(word, expected['word'])
+    profiles, total = role_profiles(word, budget)
+    need(total == local, 'role partition differs from full Boolean replay')
+    events = schedule()
+    all_win = windows(events)
+    need(all_win == hosting.windows(events), 'independent window disagreement')
+    win = {i: w for i, w in all_win.items() if w[1] and w[2]}
+    selection = json.loads((ROOT/'research/e8-bit-p111/data/selection9-p111.json').read_text())['bit']
+    slots, rem = expand(selection, win)
+    occupied = audit_slots(slots, win)
+    ys = {(i, tuple(p)): n for i, p, n in selection['patterns']}
+    zs = {(i, w, s): n for i, w, s, n in selection['stages']}
+    parent_slots, parent_rem = hosting.expand(win, ys, zs, {s: [(h, 8) for h in range(439)] for s in range(9)}, 222)
+    need(slots == parent_slots and rem == parent_rem, 'independent owner allocation disagreement')
+
+    def idle_profile(remainders):
+        h = Counter()
+        for i, (_, rank, _) in all_win.items():
+            if i in win:
+                for copy in range(222):
+                    if remainders[i, copy]:
+                        h[remainders[i, copy]] += 32
+            elif rank:
+                h[rank] += 222*32
+        return h
+
+    idle = idle_profile(rem)
+    need(idle == Counter(constants['REM']), 'reconstructed frozen remainder')
+    base = Counter({r: 288*n for r, n in local.items()}) + idle
+    need(dict(base) == {int(r): n for r, n in expected['nine']['profile'].items()}, 'baseline full invoice')
+    checked = 0
+
+    def price(h, root=False):
+        nonlocal checked
+        h = clean(h)
+        first = budget.moment(h, Q(1, 99))
+        second = mercator.moment(h, 64, 28416, Q(1, 99), bad=True)
+        need(max(first[0], second[0]) <= min(first[1], second[1]), 'independent interval disagreement')
+        need(first[1] < 1 or first[0] > 1, 'ambiguous strict target sign')
+        checked += 1
+        result = dict(profile=dict(sorted(h.items())), rank_mass=mass(h),
+                      deficit=64*28416-mass(h), calls=sum(h.values()),
+                      target_moment_interval=list(first),
+                      target_moment_display=format(float(first[1]), '.16g'),
+                      passes_target_arithmetic=first[1] < 1)
+        if root:
+            result['root'] = budget.bracket_root(h)
+        return result
+
+    def withdrawal(removed, root=False):
+        # Grant a replacement producer for free. Charge every vacated owner
+        # direction at the original idle boundary, joined with its old tail.
+        h = base.copy()
+        for helper in removed:
+            for rank, count in profiles[222+helper].items():
+                h[rank] -= 288*count
+        returned = rem.copy()
+        owners = []
+        for idx, copy, offset, width, stage, helper in slots:
+            if helper in removed:
+                returned[idx, copy] += width
+                owners.append([idx, copy, offset, width, stage, helper])
+        new_idle = idle_profile(returned)
+        h.subtract(idle)
+        h.update(new_idle)
+        h = clean(h)
+        local_credit = 288*8*len(removed)
+        boundary_debit = mass(new_idle)-mass(idle)
+        need(local_credit == boundary_debit and mass(h) == mass(base), 'unpaid vacated owner axes')
+        return dict(removed_helper_indices=sorted(removed),
+                    gross_local_rank_credit=local_credit,
+                    owner_boundary_rank_debit=boundary_debit, net_rank_credit=0,
+                    idle_profile=dict(sorted(new_idle.items())), invoice=price(h, root),
+                    returned_slots_one_replica=owners)
+
+    singles = []
+    for helper in range(439):
+        result = withdrawal({helper})
+        singles.append((result['invoice']['target_moment_interval'][1], helper))
+    thirteen = withdrawal(set(range(13)), True)
+    all_helpers = withdrawal(set(range(439)), True)
+    cache = decoder_cache(word, budget, win)
+    cache_best_case = base.copy()
+    cache_best_case[7] -= 9*32
+    cache['best_case_invoice'] = price(cache_best_case, True)
+    # Independent of how much consolidation is later obtained, this one
+    # linear dependence cannot remove 100 units from the complete invoice.
+    need(cache['saved_copy_rank_per_invocation'] == 7, 'cache credit')
+
+    # This refinement keeps the 222 forced data climbs at rank <=7, while
+    # still granting fractional rank-8 packing of every other local unit.
+    fences = {}
+    for removed_mass in (99, 100, 101, 102):
+        h = idle.copy()
+        h[7] += 288*222
+        h[8] += 288*Q(3512+63-removed_mass, 8)
+        fences[str(removed_mass)] = price(h)
+    need(not fences['101']['passes_target_arithmetic'] and fences['102']['passes_target_arithmetic'],
+         'rank-seven boundary fence')
+
+    # Stronger escape control: changing hosting changes the moment even
+    # when it does not change mass. Erase every helper at zero producer cost,
+    # grant unfragmented data climbs, and separately grant zero COPY cost.
+    no_helpers_idle = Counter(all_helpers['idle_profile'])
+    unlimited = {}
+    for copy_mass in (63, 0):
+        h = no_helpers_idle.copy()
+        h[7] += 288*(222+Q(copy_mass, 7))
+        unlimited[str(copy_mass)] = price(h, True)
+    need(not unlimited['63']['passes_target_arithmetic'] and unlimited['0']['passes_target_arithmetic'],
+         'scope control: joint boundary relaxation')
+
+    controls = []
+    def reject(name, action):
+        try:
+            action()
+        except (ValueError, KeyError):
+            controls.append(name)
+        else:
+            raise ValueError('negative control accepted: '+name)
+    bad = slots[:]
+    bad[1] = bad[0]
+    reject('duplicate owner and helper', lambda: audit_slots(bad, win))
+    bad = slots[:]
+    old = list(bad[0]); old[4] = next(s for s in range(9) if s not in win[old[0]][2]); bad[0] = tuple(old)
+    reject('cache carried beyond untouched lifetime', lambda: audit_slots(bad, win))
+    bad = slots[:]
+    old = list(bad[0]); old[2] = win[old[0]][1]; bad[0] = tuple(old)
+    reject('owner coordinate outside pending frame', lambda: audit_slots(bad, win))
+    reject('104 gross rank units reported as net', lambda: need(thirteen['net_rank_credit'] == 288*104, 'gross is not net'))
+    reject('100 admitted without data rank-seven boundaries', lambda: need(fences['100']['passes_target_arithmetic'], 'target fails'))
+    reject('free helpers alone admitted', lambda: need(unlimited['63']['passes_target_arithmetic'], 'target fails'))
+
+    owner_digest = hashlib.sha256(json.dumps(slots, separators=(',', ':')).encode()).hexdigest()
+    result = dict(status='PASS_PREBUILD_HOSTING_GATE_NO_100_NET_UNIT_CONSTRUCTION',
+                  success_goal_met=False, supplier_built=False, target_saving=Q(1, 99),
+                  live=28416, physical=28425, local_invocations=288,
+                  baseline=price(base, True), local_replay=local_receipt,
+                  hosting=dict(windows={i: [p, r, sorted(s)] for i, (p, r, s) in all_win.items()},
+                               slots_per_replica=len(slots), slots_all_replicas=32*len(slots),
+                               occupied_coordinates_per_replica=occupied, owner_sha256=owner_digest,
+                               independent_parent_expansion_equal=True),
+                  thirteen_helper_withdrawal=thirteen, all_helpers_free=all_helpers,
+                  nine_stage_running_decoder_cache=cache,
+                  all_single_withdrawals=dict(count=439, net_rank_credit_each=0,
+                                             lowest_moment_helper=min(singles)[1],
+                                             lowest_moment_upper=min(singles)[0],
+                                             highest_moment_helper=max(singles)[1],
+                                             highest_moment_upper=max(singles)[0]),
+                  rank_seven_boundary_fences=fences,
+                  joint_free_helper_and_copy_relaxations=unlimited,
+                  largest_net_mass_credit_from_copy_erasure_per_invocation=63,
+                  target_100_mass_credit_requires_effective_copy_mass=-37,
+                  negative_controls=controls)
+    # Keep the all-helper receipt compact; the source-bound deterministic
+    # expander and its digest reconstruct all slots without a large duplicate.
+    result['all_helpers_free'].pop('returned_slots_one_replica')
+    result['independent_moment_comparisons'] = checked
+    out.write_text(json.dumps(result, indent=2, sort_keys=True, default=str)+'\n')
+    print(result['status'])
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--out', required=True, type=Path)
+    args = parser.parse_args()
+    main(args.out)
diff --git a/research/cyclic-dirty-commutator-audit/CLAIM.json b/research/cyclic-dirty-commutator-audit/CLAIM.json
new file mode 100644
index 0000000000..16135d4c57
--- /dev/null
+++ b/research/cyclic-dirty-commutator-audit/CLAIM.json
@@ -0,0 +1,34 @@
+{
+  "track": "Adversarial mathematical audit",
+  "assignment_seed": 67,
+  "seed_source": "Python secrets.randbelow(100), backed by operating-system randomness",
+  "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "source_pr": 628,
+  "source_head": "0768f97d06c623b8211e651543c66135796b62bf",
+  "object": "DIRTY-PROOF.md exact source/scratch restoration and rounded balanced-commutator composition",
+  "method": "Independent integer-grid interpreter; half-grid tie and low-precision stress; exact rational operator comparison; negative instruction-order and alias controls",
+  "expected_deliverable": "Scoped audit note, reproducible checker, source pins, exact evidence and meaningful negative controls; no new kappa claim",
+  "expected_finish_utc": "2026-10-13T03:30:00Z",
+  "coordination": "No pinned issues at claim time; local claim per sprint instructions. PR628 has no comments or reviews. Open PR metadata searched for PR628, stable scan, periodic closure and dirty commutator overlap.",
+  "candidates_in_order": [
+    "PR619 fixed-family packing ceiling: independently re-enumerate capacity/remainder proof",
+    "PR628 dirty cyclic inverse: audit rounded commutator restoration and error propagation",
+    "PR559 source recurrence correction: audit finite/base-case transition"
+  ],
+  "selection": "67 mod 3 = 1 selects the second candidate; PR619 already has a maintainer independent enumeration, PR559 is inherited by repeated frontier replays. Seed67 also fixes deterministic stress generation.",
+  "user_steering": [
+    "Improve kappa as well as fixing the verifier",
+    "Explore a structural improvement instead of only marginal packing"
+  ],
+  "result": {
+    "status": "completed",
+    "kind": "Research note, primitive construction, independent verification and repair; ancillary non-frontier conditional arithmetic refinement",
+    "findings": [
+      "Concrete read-only phase alias defect and tested one-line patch",
+      "Multiway dirty echo with logarithmic borrowed storage and subquadratic leaf calls for fixed fanout above two",
+      "PR659 final-grid conditional kappa 0.001656193765416678434092, gain 4.34092e-19; not a new frontier"
+    ],
+    "result_link": "https://github.com/androolloyd/integer-mult-bounds/tree/codex/audit-cyclic-inverse-seed67/research/cyclic-dirty-commutator-audit",
+    "overlap_refresh": "No pinned issue at final refresh. PR628 and PR659 heads unchanged. Concurrent PR663 at e0e546fd01b396478c68b6b6c5a16d87515983ba audits the original binary schedule; it does not supply the new echo schedule or phase-alias guard. PR671 reports a stronger kappa than the pinned PR659 refinement; no record claim."
+  }
+}
diff --git a/research/cyclic-dirty-commutator-audit/ECHO-PROOF.md b/research/cyclic-dirty-commutator-audit/ECHO-PROOF.md
new file mode 100644
index 0000000000..23bf89c55e
--- /dev/null
+++ b/research/cyclic-dirty-commutator-audit/ECHO-PROOF.md
@@ -0,0 +1,171 @@
+# Multiway dirty echo: fewer factor calls with logarithmic borrowed storage
+
+This changes PR628's **binary composition schedule**, retaining its classical
+rounded inverse leaf, coefficient preparation, charged phase access and routing.
+For each fixed fanout k >= 2 it uses O(n^alpha) factor calls, where
+alpha = log_k(4k-4) < 2 for k > 2, with O(log n) borrowed length-L arrays.
+It does not provide a common-label Clifford supplier, bit-reversible compiler,
+transform layout, or new multiplication κ. The phase-alias repair is required
+at this interface too and is included in `echo.py` before execution.
+
+## Exact algebra; no commutativity assumption
+
+Let A_1,...,A_k be arbitrary composable linear maps on equal-length arrays.
+Source x, target y and dirty arrays z_1,...,z_(k-1) are all distinct. Define C
+as the following ordered sequence of shears:
+
+    z_1 += A_1 x
+    z_2 += A_2 z_1
+    ...
+    z_(k-1) += A_(k-1) z_(k-2)
+
+Define D as C with its first shear omitted. Execute
+
+    C; y += A_k z_(k-1); C^-1;
+    D; y -= A_k z_(k-1); D^-1.
+
+C^-1 and D^-1 reverse the operation order and negate every shear. They restore
+all dirty arrays. The two target updates occur on dirty-chain states that differ
+only by the propagated contribution of the first link. Inductively that
+difference at z_i is A_i ... A_1 x. Consequently the net target increment is
+A_k ... A_1 x. This proof holds for noncommuting maps and arbitrary initial dirt.
+The source is never a target of an ideal shear. With k=2, D is empty and this
+reduces to the original binary commutator.
+
+The complete count is
+
+    (k-1) + 1 + (k-1) + (k-2) + 1 + (k-2) = 4k-4.
+
+It includes both ladders, both inverse ladders and both target updates. There
+is no clean length-L work array or implicit copying. The two endpoint maps
+are each called twice; each interior map is called four times.
+
+## Recursive schedule and storage
+
+Partition n factors into k' = min(k,n) consecutive groups, as evenly as
+possible, preserving their order. Use k'-1 dirty arrays for this node. Recursively
+implement each group map using a disjoint pool of deeper borrowed arrays,
+which can be reused between calls because every call restores that pool.
+Neither an ancestor source nor an ancestor target belongs to the deeper pool.
+All mutable arrays, including surplus scratch, are checked distinct at entry.
+
+For group sizes n_i, the exact recurrences implemented by `resources` are
+
+    S(1) = 0, N(1) = 1
+    S(n) = k'-1 + max_i S(n_i)
+    N(n) = 2 N(n_1) + 2 N(n_k') + 4 sum_(1<i<k') N(n_i).
+
+For n=k^h these give S=(k-1)h and N=(4k-4)^h. In general depth is at most
+ceil(log_k n), so S <= (k-1)ceil(log_k n) and
+N <= (4k-4)^ceil(log_k n). For fixed k this is O(n^alpha),
+alpha=log_k(4k-4). The constant in O(log n) borrowed storage depends on k.
+One must not increase k with n while claiming that constant is uniform.
+For every fixed epsilon>0, a sufficiently large *fixed* k makes alpha<1+epsilon.
+The flat choice k=n instead uses n-1 borrowed arrays and exactly 4n-4 calls.
+
+| Factors | Binary: arrays / calls | Fanout 8: arrays / calls | Flat: arrays / calls |
+|---|---:|---:|---:|
+| 8 | 3 / 64 | 7 / 28 | 7 / 28 |
+| 16 | 4 / 256 | 8 / 112 | 15 / 60 |
+| 64 | 6 / 4096 | 14 / 784 | 63 / 252 |
+| 512 | 9 / 262144 | 21 / 21952 | 511 / 2044 |
+
+The generator streams instructions using O(k log_k n) active scheduling
+records. It does not retain the expanded word. A positive or negative child
+call takes the same resources. Negative calls reverse the full instruction
+word, rather than negating signs in forward order.
+
+## Exact restoration despite rounded, nonlinear increments
+
+A valid PR628 leaf adds a deterministic function of its source to its target,
+restores its source exactly, and does not read its target when computing the
+increment. Its negative leaf subtracts exactly that same grid value. Fixed,
+non-aliased phase and factor data are essential here.
+
+Inductively, a recursive call adds a deterministic function of its source and
+initial deeper dirt, independently of its target, and restores the source and
+all deeper dirt. Thus C's child calls can be undone in reverse order: each sees
+the same source and deeper dirt as its forward mate. The intervening target
+update changes only y, which is excluded from every ladder's scratch pool.
+The same argument applies to D. This proves exact source and scratch restoration
+at every level for valid finite-grid inputs. Reversing the complete word gives
+an exact inverse. It does **not** prove that the rounded target increment is
+independent of dirt; the error estimate below bounds that dependence.
+
+As with the pinned leaf, all input contracts must hold throughout execution.
+This is not transactional rollback on arbitrary malformed coefficients or
+stateful callbacks. The explicit alias checks reject ordinary list-identity
+aliasing before any mutation; arbitrary overlapping views are outside the API.
+
+## Complete inherited error and cost budget
+
+Use PR628's leaf estimates with n=r-1, beta in (0,1], grid u=2^-w, and
+multipliers bounded by r. The same hypotheses and preparation remain required.
+Let D bound the initial joint max norm, K=r/beta,
+a=13(r+1)/beta^3 and G=2+K. A rounded leaf on input norm at most B has error
+at most a(B+1)u; an ideal shear has Lipschitz norm at most 1+K. Enforce
+au<=1 and u<=beta^2/2.
+
+Writing M_j for the computed joint norm after j leaves gives
+(M_j + 1) <= G^j(D+1). Comparing the complete rounded instruction word with the
+complete ideal word gives, by propagation through each remaining ideal shear,
+
+    E_N <= N a (D+1) u G^(N-1).
+
+This argument applies to the actual expanded word, including every restoration
+operation. Substitute the new exact N; do not reuse the predecessor's 4n²
+upper bound when measuring the improvement. The ideal identity proved above
+cancels all initial borrowed dirt. Hence this E_N bounds target error while
+actual source and scratch restoration are exact.
+
+For requested p bits choose
+
+    w >= p+1+ceil(log2(N a (D+1)))+(N-1)ceil(log2 G),
+
+as well as the two leaf precision conditions. This budgets execution error
+at most 2^(-p-1). The inherited coefficient/phase preparation error must still
+be budgeted to 2^(-p-1), scaled for the original source norm as specified in
+PR628. It does not receive a free exact phase table from this construction.
+
+Under PR628's log2(beta^-1)=O(r³), fixed fanout k gives
+
+    N = O(r^alpha),
+    w = O(p + log(D+1) + r^(3+alpha)).
+
+Joint transient integer magnitudes add O(log(D+1)+N log G) bits; the leaf's
+causal state and closure add O(log(beta^-1)+log r), all covered by that budget.
+Borrowed data storage is O(L log r) words for fixed k. Clean arithmetic storage,
+read-only factor descriptors, indexing and fast-arithmetic workspace retain
+PR628's qualifications. Charging the same factor preparation and leaf arithmetic
+as PR628 gives the conditional local work upper bound
+
+    soft-O((L r^alpha + r³) (p + log(D+1) + r^(3+alpha)))
+
+plus charged phase-oracle and routing work. Every leaf still includes its
+forward pass, output pass, undo pass and validation/access costs; none are
+removed by a speedup claim. With k=8, alpha=log_8 28≈1.602452, replacing the
+binary precision power 5 by about 4.602452. With flat k=n the corresponding
+power is 4, but borrowed arrays become O(r), not O(log r).
+
+The Fraction prototype tests identities, rounding and restoration; its timings
+are **not** evidence for a fast fixed-precision implementation. No complete
+multiplication recurrence follows without integrating the required transform,
+paid storage/layout, bit supplier and all conditional assembly assumptions.
+
+## Evidence and attribution
+
+`verify_echo.py` compares the streamed ideal word against direct composition of
+arbitrary noncommuting 2x2 integer matrices. It separately compares rounded
+execution with an integer-grid arithmetic interpreter (sharing only the tested
+schedule), and with PR628's independently assembled dense cyclic inverse oracle.
+The latter checks the complete error bound at a precision chosen by the formula
+above, with positive, zero and negative initial dirt. These finite tests support
+the implementation; they are not a formal proof of the general statement.
+The algebraic and inductive arguments above state the general obligations.
+
+The schedule and analysis here were prepared for @androolloyd with substantial
+OpenAI Codex assistance, under Apache-2.0. The rounded leaf and original binary
+dirty inverse are Chafik Boukhalfa / chafreaky's PR628 work, with OpenAI Codex
+assistance, built on Ali Romman's PR621 kernel and the sources retained in
+SOURCE.json. This note claims an improvement relative to that pinned binary
+schedule, not priority over all historical reversible-pebbling literature.
diff --git a/research/cyclic-dirty-commutator-audit/README.md b/research/cyclic-dirty-commutator-audit/README.md
new file mode 100644
index 0000000000..76e263abd1
--- /dev/null
+++ b/research/cyclic-dirty-commutator-audit/README.md
@@ -0,0 +1,179 @@
+# Multiway dirty echo and phase-alias repair for PR628
+
+**A subquadratic composition schedule and a concrete executable admission fix.**
+The new [echo construction](ECHO-PROOF.md) replaces binary dirty commutators
+with a forward/undo ladder and a second ladder omitting the first link. For
+fixed fanout k it uses O(n^log_k(4k-4)) factor calls and O(log n) borrowed arrays.
+At k=8, the exponent is about 1.602452 instead of 2. For 512 factors it uses
+21 borrowed arrays and 21,952 calls, versus 9 arrays and 262,144 calls for the
+binary schedule. The flat variant uses n-1 arrays and 4n-4 calls.
+
+The written proof includes the exact noncommutative identity, rounded exact
+restoration, all recursive calls and the inherited complete-word error budget.
+Under PR628's separation bound the precision power falls from r^5 to roughly
+r^4.602452 for fixed fanout 8. This is a **classical local primitive**, not a
+paid common-label supplier or a new multiplication κ. The one-line admission
+repair below is independently useful even without adopting the new schedule.
+
+The [full-transform and bit integration experiment](../dirty-echo-integration/README.md)
+now implements complete synthetic Fourier transforms and Boolean address
+interchanges with this echo. The functional checks pass, but the complete
+all-role recursive bill rejects this direct adapter as a route to larger κ.
+Its proof and exact counterexamples identify the remaining interface and
+cost obligations without changing the local echo result.
+
+The [bit role-sharing cost screen](../bit-role-sharing-budget/README.md)
+then prices arbitrary XOR role pooling, ideal local consolidation, and
+cross-stage rank/repair targets before attempting a replacement supplier.
+It rejects the first two routes to κ=0.01 and records exact requirements
+for a genuinely changed paid profile. No new κ is claimed.
+
+## Executable admission defect
+
+At PR628 head `0768f97d06c623b8211e651543c66135796b62bf`, `dirty.py::compose`
+checks that the mutable source, target and scratch arrays are distinct, but
+allows its supposedly read-only `phases` list to alias any of them. Its entry
+unit-modulus check does not make that list immutable during execution.
+
+With `x = phases = [1, 1]`, `y = [0, 0]`, one outer factor with `b = 1/4`,
+scale 1, β = 1/2, direction +1 and eight fractional bits, the call returns
+normally with **x = [1, 15/16]**. Exact restoration fails. All entry checks pass.
+This is not a counterexample to the written lemma under genuinely read-only
+phases: it is a missing executable admission check for that hypothesis.
+
+## Why it fails, independently of numerical precision
+
+The outer coefficient at site i is `b * phases[i]`. The first causal lift makes
+`x[1] = 1+b`. Because phases aliases x, the undo now reads the changed phase and
+subtracts `b*(1+b)`, instead of the original b. Thus
+
+    x[1] after undo = (1+b) - b(1+b) = 1-b².
+
+For dyadic b in (0, 1/2] and a grid representing b and b², this calculation is
+exact. Increasing precision cannot fix it. The replay checks b = 1/8, 1/4,
+3/8 and 1/2 at 8, 16 and 64 bits. Aliasing the target also returns normally
+with damaged data. Aliasing scratch can instead fail only after mutations;
+that is not rejection before execution.
+
+The proof's undo argument requires the same coefficient on the forward and
+reverse lifts. The recursive cancellation also requires phases to remain
+unchanged between paired calls. The mutable-array identity exclusion already
+present in `compose` does not enforce either requirement for phases.
+
+## Repair and replay
+
+[phase-alias-guard.patch](phase-alias-guard.patch) inserts this check immediately
+after the existing mutable-array identity check, before any writes:
+
+```python
+c.need(all(phases is not v for v in arrays), 'phase array aliases mutable data')
+```
+
+It is a patch against the pinned pending PR628 package, which is not on this
+main base. Applying it to that package fixes the ordinary-list identity alias
+case without copying the length-L phase array or adding array passes. It takes
+O(h) identity checks per invocation for h borrowed arrays; those same arrays
+are already enumerated by the existing admission checks. Distinct lists with
+equal values remain valid. General mutable views, concurrent mutation and
+stateful coefficient callbacks are outside this list-based guard; the generic
+`lift` API still requires fixed coefficient/multiplier/destination callbacks.
+
+From the repository root, the reproducible command is:
+
+```sh
+git fetch https://github.com/CrocSwap/integer-mult-bounds.git 0768f97d06c623b8211e651543c66135796b62bf && python3 -I -B research/cyclic-dirty-commutator-audit/verify.py
+```
+
+Expected final line:
+
+```text
+PASS_PHASE_ALIAS_REPAIR_AND_INTEGER_GRID_AUDIT 300 differential cases; 19 pre-mutation alias rejections
+```
+
+The verifier reads Git blobs at the exact pin, checks every consumed source
+hash in [SOURCE.json](SOURCE.json), and applies the submitted patch in a
+throwaway directory. It performs no network access or tracked-file writes.
+`--out /absolute/new/report.json` optionally saves evidence. `-O` is also
+supported by this audit; its checks do not rely on Python assertions.
+
+The 300 valid cases compare the original, patched, and separately implemented
+integer-grid execution paths bit for bit: 1/2/3/5/8 factors, lengths 1/2/3/5/8,
+precisions 4/8/16, both directions and signs, nonzero dirty data, inner/outer
+factors and varying rational unit phases. The PR628 producer uses Gaussian
+rational pairs throughout; [integer_model.py](integer_model.py) stores data as
+integer grid coordinates and compiles a flat instruction word before reversing
+it. No producer arithmetic or schedule helper is imported by that model.
+Seed 67 fixes the generated values. The finite domain is completed in full;
+there is no random early stopping and no impossibility claim.
+
+The source and every scratch array must be restored exactly; positive then
+negative execution must return all arrays exactly. The repaired path rejects
+19 source/target/scratch aliases before any mutation. Distinct equal-valued
+phase lists are accepted. Removing the guard must reproduce source damage.
+All eight inherited instruction mutations must still fail. Explicit positive
+and negative half-grid tie controls check rounding toward positive infinity.
+This is finite differential evidence, not a formal proof of the all-length
+rounded inverse, its precision bound, or integer multiplication.
+
+## Reproduce the complete contribution
+
+From the repository root, use this single compound command and a new output
+directory (Python standard library and Git only):
+
+```sh
+git fetch https://github.com/CrocSwap/integer-mult-bounds.git 0768f97d06c623b8211e651543c66135796b62bf 4982f0ca66ffe0960b5a6451deb5b66b1039326b a6895a69f8ad98ab45777b03e9e6f48888c39f6f && sh research/cyclic-dirty-commutator-audit/replay.sh /tmp/dirty-echo-sprint-replay
+```
+
+Expected final line: `PASS_DIRTY_ECHO_ALIAS_REPAIR_AND_FINE_GRID`.
+The script checks the repair, echo, same-input Fraction benchmark and the
+separately scoped [PR659 final-grid refinement](../gauge44-notri-fine-grid/README.md).
+It also runs the full-transform/bit integration and its scoped cost rejection.
+The bit role-sharing budget screen is included as the final check.
+The final-grid component reconstructs the pinned complex supplier afresh and takes
+roughly three minutes on the recorded machine. It requires assertions in
+inherited engines. The alias and echo checkers separately support `-I -O`.
+
+`verify_echo.py` completes 72 exact noncommuting matrix cases, 744 rounded
+integer-grid comparisons, 120 dense inverse/error-budget cases and 62
+pre-mutation phase-alias rejections. Three instruction mutations fail. Factor
+counts, fanouts, directions, precision grids and dirty values are explicit in
+the checker; the seed is 67 and every listed case is completed. The independent
+matrix oracle checks the schedule; the integer interpreter checks arithmetic
+on that schedule; the inherited dense oracle checks the target/error bound.
+These are distinct forms of evidence, not independent human or formal review.
+
+The same-input benchmark uses 16 factors, length 8, 1024 fractional bits and
+three repetitions. Source, target, factors, phases and the common scratch-pool
+prefix are identical; scratch counts are explicitly different. The binary,
+fanout-8 and flat methods use 256/112/60 calls and 4/8/15 arrays respectively.
+All three restore exactly and meet the same 32-bit dense accuracy check.
+See [evidence/BENCHMARK.json](evidence/BENCHMARK.json) for timings. These measure
+the Fraction prototype only, not a practical integer multiplication algorithm.
+
+## Pins, overlap, scope and attribution
+
+Main base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`. OS assignment seed: 67,
+adversarial mathematical audit. [CLAIM.json](CLAIM.json) records the candidates,
+selection and local claim; no pinned coordination issue existed. The selected
+main certificate was κ = 0.001635527380375392 (#626/#543), which is unchanged.
+
+The final queue refresh found concurrent
+[PR663](https://github.com/CrocSwap/integer-mult-bounds/pull/663), by @0xkilgore,
+at `e0e546fd01b396478c68b6b6c5a16d87515983ba`. It independently audits nonlinear
+restoration and proves the exact **binary** leaf count, retaining quadratic
+asymptotics. Our comparison uses actual binary calls, not the loose 4n²
+allowance. The **changed multiway schedule**, phase-alias counterexample/guard,
+and independent rounded integer-grid arithmetic are distinct additions.
+PR665 concerns a spectral residual encoder's unfavorable boundary bill;
+PR666 concerns composite-radix nonvanishing. Neither is used as a dependency.
+
+PR628's dirty inverse and its proof are by **Chafik Boukhalfa / chafreaky**, with
+substantial OpenAI Codex assistance. Its PR621 kernel, by **Ali Romman**, and
+OpenAI, Pan, Mehlhorn–Sagraloff–Wang, Brent and filtering sources retain their
+original attribution; see the source-pinned NOTICE.md and SOURCE.json. This
+audit does not claim their algorithms as new work. The unrelated final-grid
+refinement requested during the sprint is in
+[../gauge44-notri-fine-grid](../gauge44-notri-fine-grid/README.md).
+
+New audit, integer interpreter and repair prepared for **@androolloyd** with
+substantial **OpenAI Codex** assistance. Apache-2.0, under the repository license.
diff --git a/research/cyclic-dirty-commutator-audit/SOURCE.json b/research/cyclic-dirty-commutator-audit/SOURCE.json
new file mode 100644
index 0000000000..e563cd8d78
--- /dev/null
+++ b/research/cyclic-dirty-commutator-audit/SOURCE.json
@@ -0,0 +1,19 @@
+{
+  "repository": "https://github.com/CrocSwap/integer-mult-bounds",
+  "pull_request": 628,
+  "commit": "0768f97d06c623b8211e651543c66135796b62bf",
+  "package": "research/prime-power-cyclic-scan",
+  "files": {
+    "dirty.py": "09e7f41141594e6540828330d27be27c083ee6569660ae42c0cd519b09fc8d21",
+    "weighted.py": "8b0f93d131a30e64eb0ccd893779daffea79c0c00f1d2a30a91d23eb2bf0bff5",
+    "check.py": "a3e46b556894d71a1c83bbbac01c50c1a541285fc9422a3567d5eb1d1ee86e7d",
+    "scan.py": "1a9c01ca1a29a9be1e756858161202621db29d5d332a4266b4017a9502a50d7e",
+    "interval_kernel.py": "9b7bb24640a9a7d3f83c7951dfef483ec933db4c50de6c0130b85f450eeddfbe",
+    "DIRTY-PROOF.md": "bb7c2fdc1c4673d56531fd56fb8790c81a16813ac152c10f1afabc9efdd70d61",
+    "NOTICE.md": "abeacf1ad1491d5797cfcf1f3832799bbf3b24b99597229d7bc884059a51ec68",
+    "SOURCE.json": "38a425e2d3a72a5e39b18b54c728e40407e121d481a1c6423edd5c18e9b68a04",
+    "dirty_controls.py": "f4897b7d164972897176e5c1069f2876fb9249bb58de6c57446f41bd00a7e598"
+  },
+  "license": "Apache-2.0",
+  "attribution": "Chafik Boukhalfa / chafreaky, with substantial OpenAI Codex assistance; PR621 kernel by Ali Romman and sources credited in the pinned NOTICE.md"
+}
diff --git a/research/cyclic-dirty-commutator-audit/VALIDATION.json b/research/cyclic-dirty-commutator-audit/VALIDATION.json
new file mode 100644
index 0000000000..f15bd24bdb
--- /dev/null
+++ b/research/cyclic-dirty-commutator-audit/VALIDATION.json
@@ -0,0 +1,21 @@
+{
+  "status": "PASS",
+  "python": "3.14.7",
+  "platform": "Darwin-25.1.0-arm64-arm-64bit-Mach-O",
+  "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "checks": {
+    "complete_replay": "PASS_DIRTY_ECHO_ALIAS_REPAIR_AND_FINE_GRID",
+    "phase_audit_normal_and_optimized_equal": true,
+    "echo_normal_and_optimized_equal": true,
+    "corrupted_source_hash_rejected": true,
+    "optimized_fine_grid_rejected": true,
+    "selected_record": "PASS 51110230636731/31250000000000000",
+    "staged_whitespace": "PASS"
+  },
+  "scope": "All affected standalone packages replayed. No root make verify, remote CI, proof assistant, full bit circuit rebuild or selected-frontier change is claimed.",
+  "evidence_sha256": {
+    "evidence/ALIAS.json": "330587a37501b9b69158d138811bfbd128a3e0b706aac5f948eb9a321b8c9bf2",
+    "evidence/BENCHMARK.json": "4d81ddf816ef8245c4003ba5d787685585bad14c9bb146c9185ce9631e8153bf",
+    "evidence/ECHO.json": "37f8c5f792278320fe3d514ddf6b00aea85102eb85155ea9a8ad644143b314c5"
+  }
+}
diff --git a/research/cyclic-dirty-commutator-audit/benchmark.py b/research/cyclic-dirty-commutator-audit/benchmark.py
new file mode 100644
index 0000000000..c997484e6e
--- /dev/null
+++ b/research/cyclic-dirty-commutator-audit/benchmark.py
@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Same-input Fraction prototype timing; no fast-arithmetic performance claim."""
+import argparse
+import copy
+from fractions import Fraction as F
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+import platform
+import statistics
+import subprocess
+import tempfile
+import time
+
+HERE=Path(__file__).resolve().parent
+ROOT=HERE.parents[1]
+
+
+def load(name,path):
+    spec=importlib.util.spec_from_file_location(name,path)
+    module=importlib.util.module_from_spec(spec);spec.loader.exec_module(module)
+    return module
+
+
+def need(ok,message):
+    if not ok:
+        raise ValueError(message)
+
+
+def main():
+    ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--out',type=Path,required=True);args=ap.parse_args()
+    E=load('benchmark_echo',HERE/'echo.py')
+    source=json.loads((HERE/'SOURCE.json').read_text())
+    nf=16;length=8;bits=1024;beta=F(1,2);repetitions=3
+    factors=[(i%2==0,(F(1,4),F((-1)**i,8)),F(3 if i==0 else 1)) for i in range(nf)]
+    phases=[(F(1),F(0)),(F(0),F(1)),(F(3,5),F(4,5))]
+    phases=[phases[i%3] for i in range(length)]
+    before=[[(F(7+2*i+j,4),F(7-3*i-j,8)) for i in range(length)] for j in range(nf+1)]
+    rows=[]
+    with tempfile.TemporaryDirectory(prefix='echo-benchmark-') as temp:
+        root=Path(temp)
+        for name,digest in source['files'].items():
+            result=subprocess.run(['git','show',source['commit']+':'+source['package']+'/'+name],cwd=ROOT,capture_output=True)
+            need(result.returncode==0 and hashlib.sha256(result.stdout).hexdigest()==digest,'pinned source '+name)
+            (root/name).write_bytes(result.stdout)
+        D=load('benchmark_binary',root/'dirty.py')
+        expected=D.exact_operator(before[0],factors,phases,1)
+        for label,fanout in (('pinned binary',2),('echo fanout 8',8),('flat echo',nf)):
+            depth,N=E.resources(nf,fanout)
+            seconds=[]
+            for _ in range(repetitions):
+                arrays=copy.deepcopy(before[:depth+2]);saved=copy.deepcopy(arrays)
+                start=time.perf_counter()
+                if fanout==2:
+                    stats=dict(leaves=0,scalar_steps=0)
+                    D.compose(*arrays[:2],factors,arrays[2:],phases,beta,bits,1,stats=stats)
+                else:
+                    stats=E.compose(D,*arrays[:2],factors,arrays[2:],phases,beta,bits,1,fanout=fanout)
+                seconds.append(time.perf_counter()-start)
+                need(stats['leaves']==N,'benchmark count')
+                need(arrays[0]==saved[0] and arrays[2:]==saved[2:],'benchmark restoration')
+                need(all(D.c.norm2(D.c.sub(D.c.sub(y,y0),z))<=F(1,1<<64) for y,y0,z in zip(arrays[1],saved[1],expected)),'benchmark 32-bit accuracy')
+            rows.append(dict(method=label,borrowed_arrays=depth,leaf_calls=N,seconds=seconds,median_seconds=statistics.median(seconds)))
+    args.out.write_text(json.dumps(dict(python=platform.python_version(),platform=platform.platform(),factors=nf,length=length,bits=bits,repetitions=repetitions,results=rows,scope='Same source, target, phases, factors, precision and prefix of a common scratch pool. Unequal scratch counts are explicit. Fraction prototype timing only; no practical multiplication speedup claim.'),indent=2)+'\n')
+    for row in rows:
+        print(row['method'],row['leaf_calls'],'calls',row['borrowed_arrays'],'arrays',round(row['median_seconds'],4),'median seconds')
+
+
+if __name__=='__main__':
+    main()
diff --git a/research/cyclic-dirty-commutator-audit/echo.py b/research/cyclic-dirty-commutator-audit/echo.py
new file mode 100644
index 0000000000..76a3117136
--- /dev/null
+++ b/research/cyclic-dirty-commutator-audit/echo.py
@@ -0,0 +1,75 @@
+"""Multiway dirty echo composition of PR628's restored-input leaf shears.
+
+Prepared for androolloyd with substantial OpenAI Codex assistance. Apache-2.0.
+No new multiplication exponent is asserted. Read ECHO-PROOF.md for the storage
+tradeoff and the complete inherited local error recurrence.
+"""
+
+
+def partition(count, fanout):
+    if count < 1 or fanout < 2:
+        raise ValueError('positive factor count and fanout >= 2 required')
+    k = min(count, fanout)
+    quotient, remainder = divmod(count, k)
+    return [quotient + (i < remainder) for i in range(k)]
+
+
+def resources(count, fanout):
+    if count < 1 or fanout < 2:
+        raise ValueError('positive factor count and fanout >= 2 required')
+    if count == 1:
+        return 0, 1
+    sizes = partition(count, fanout)
+    children = [resources(n, fanout) for n in sizes]
+    scratch = len(sizes)-1 + max(depth for depth, _ in children)
+    calls = sum((2 if i in (0, len(sizes)-1) else 4)*cost
+                for i, (_, cost) in enumerate(children))
+    return scratch, calls
+
+
+def instructions(first, count, src, dst, scratch_first, fanout, sign=1):
+    """Stream the exact instruction word or its reverse inverse."""
+    if count == 1:
+        yield src, dst, first, sign
+        return
+    sizes = partition(count, fanout)
+    k = len(sizes)
+    offsets = [first]
+    for size in sizes[:-1]:
+        offsets.append(offsets[-1]+size)
+    # C: populate the whole dirty chain. D: the same chain without its first link.
+    chain = [(offsets[i], sizes[i], src if i == 0 else scratch_first+i-1,
+              scratch_first+i, 1) for i in range(k-1)]
+    last = (offsets[-1], sizes[-1], scratch_first+k-2, dst, 1)
+    invert = lambda commands: [(a,n,s,t,-q) for a,n,s,t,q in reversed(commands)]
+    commands = chain + [last] + invert(chain) + chain[1:] + invert([last]) + invert(chain[1:])
+    if sign == -1:
+        commands = invert(commands)
+    for a,n,s,t,q in commands:
+        yield from instructions(a,n,s,t,scratch_first+k-1,fanout,q)
+
+
+def compose(leaf_module, x, y, factors, scratch, phases, beta, bits, direction,
+            sign=1, fanout=8):
+    """Apply the dirty echo using a pinned PR628 leaf, restoring x and scratch."""
+    if direction not in (-1,1) or sign not in (-1,1):
+        raise ValueError('orientation and sign')
+    depth, count = resources(len(factors), fanout)
+    arrays = [x,y]+scratch
+    if len(scratch) < depth:
+        raise ValueError('dirty depth')
+    if len({id(a) for a in arrays}) != len(arrays):
+        raise ValueError('all ancestor arrays distinct')
+    if any(phases is a for a in arrays):
+        raise ValueError('phase array aliases mutable data')
+    if not x or any(len(a) != len(x) for a in arrays) or len(phases) != len(x):
+        raise ValueError('array lengths')
+    if any(a*a+b*b != 1 for a,b in phases):
+        raise ValueError('unit phases')
+    stats = dict(leaves=0,scalar_steps=0)
+    for src,dst,index,q in instructions(0,len(factors),0,1,2,fanout,sign):
+        leaf_module.leaf(arrays[src],arrays[dst],factors[index],phases,beta,bits,
+                         direction,q,stats)
+    if stats['leaves'] != count:
+        raise ValueError('leaf accounting')
+    return stats
diff --git a/research/cyclic-dirty-commutator-audit/evidence/ALIAS.json b/research/cyclic-dirty-commutator-audit/evidence/ALIAS.json
new file mode 100644
index 0000000000..e5ebcbadc8
--- /dev/null
+++ b/research/cyclic-dirty-commutator-audit/evidence/ALIAS.json
@@ -0,0 +1,277 @@
+{
+  "status": "PASS_PHASE_ALIAS_REPAIR_AND_INTEGER_GRID_AUDIT",
+  "source_commit": "0768f97d06c623b8211e651543c66135796b62bf",
+  "source_hashes": {
+    "dirty.py": "09e7f41141594e6540828330d27be27c083ee6569660ae42c0cd519b09fc8d21",
+    "weighted.py": "8b0f93d131a30e64eb0ccd893779daffea79c0c00f1d2a30a91d23eb2bf0bff5",
+    "check.py": "a3e46b556894d71a1c83bbbac01c50c1a541285fc9422a3567d5eb1d1ee86e7d",
+    "scan.py": "1a9c01ca1a29a9be1e756858161202621db29d5d332a4266b4017a9502a50d7e",
+    "interval_kernel.py": "9b7bb24640a9a7d3f83c7951dfef483ec933db4c50de6c0130b85f450eeddfbe",
+    "DIRTY-PROOF.md": "bb7c2fdc1c4673d56531fd56fb8790c81a16813ac152c10f1afabc9efdd70d61",
+    "NOTICE.md": "abeacf1ad1491d5797cfcf1f3832799bbf3b24b99597229d7bc884059a51ec68",
+    "SOURCE.json": "38a425e2d3a72a5e39b18b54c728e40407e121d481a1c6423edd5c18e9b68a04",
+    "dirty_controls.py": "f4897b7d164972897176e5c1069f2876fb9249bb58de6c57446f41bd00a7e598"
+  },
+  "original_counterexamples": [
+    {
+      "alias": 0,
+      "message": "accepted",
+      "unchanged": false,
+      "after": [
+        [
+          [
+            "1",
+            "0"
+          ],
+          [
+            "15/16",
+            "0"
+          ]
+        ],
+        [
+          [
+            "85/128",
+            "0"
+          ],
+          [
+            "169/256",
+            "0"
+          ]
+        ]
+      ]
+    },
+    {
+      "alias": 1,
+      "message": "accepted",
+      "unchanged": false,
+      "after": [
+        [
+          [
+            "1",
+            "0"
+          ],
+          [
+            "277/256",
+            "0"
+          ]
+        ],
+        [
+          [
+            "171/256",
+            "0"
+          ],
+          [
+            "171/256",
+            "0"
+          ]
+        ]
+      ]
+    }
+  ],
+  "exact_source_alias_family": [
+    {
+      "b": "1/8",
+      "bits": 8,
+      "source_second": "63/64"
+    },
+    {
+      "b": "1/8",
+      "bits": 16,
+      "source_second": "63/64"
+    },
+    {
+      "b": "1/8",
+      "bits": 64,
+      "source_second": "63/64"
+    },
+    {
+      "b": "1/4",
+      "bits": 8,
+      "source_second": "15/16"
+    },
+    {
+      "b": "1/4",
+      "bits": 16,
+      "source_second": "15/16"
+    },
+    {
+      "b": "1/4",
+      "bits": 64,
+      "source_second": "15/16"
+    },
+    {
+      "b": "3/8",
+      "bits": 8,
+      "source_second": "55/64"
+    },
+    {
+      "b": "3/8",
+      "bits": 16,
+      "source_second": "55/64"
+    },
+    {
+      "b": "3/8",
+      "bits": 64,
+      "source_second": "55/64"
+    },
+    {
+      "b": "1/2",
+      "bits": 8,
+      "source_second": "3/4"
+    },
+    {
+      "b": "1/2",
+      "bits": 16,
+      "source_second": "3/4"
+    },
+    {
+      "b": "1/2",
+      "bits": 64,
+      "source_second": "3/4"
+    }
+  ],
+  "rejected_aliases": [
+    {
+      "factors": 1,
+      "alias": 0,
+      "unchanged": true
+    },
+    {
+      "factors": 1,
+      "alias": 1,
+      "unchanged": true
+    },
+    {
+      "factors": 2,
+      "alias": 0,
+      "unchanged": true
+    },
+    {
+      "factors": 2,
+      "alias": 1,
+      "unchanged": true
+    },
+    {
+      "factors": 2,
+      "alias": 2,
+      "unchanged": true
+    },
+    {
+      "factors": 3,
+      "alias": 0,
+      "unchanged": true
+    },
+    {
+      "factors": 3,
+      "alias": 1,
+      "unchanged": true
+    },
+    {
+      "factors": 3,
+      "alias": 2,
+      "unchanged": true
+    },
+    {
+      "factors": 3,
+      "alias": 3,
+      "unchanged": true
+    },
+    {
+      "factors": 5,
+      "alias": 0,
+      "unchanged": true
+    },
+    {
+      "factors": 5,
+      "alias": 1,
+      "unchanged": true
+    },
+    {
+      "factors": 5,
+      "alias": 2,
+      "unchanged": true
+    },
+    {
+      "factors": 5,
+      "alias": 3,
+      "unchanged": true
+    },
+    {
+      "factors": 5,
+      "alias": 4,
+      "unchanged": true
+    },
+    {
+      "factors": 8,
+      "alias": 0,
+      "unchanged": true
+    },
+    {
+      "factors": 8,
+      "alias": 1,
+      "unchanged": true
+    },
+    {
+      "factors": 8,
+      "alias": 2,
+      "unchanged": true
+    },
+    {
+      "factors": 8,
+      "alias": 3,
+      "unchanged": true
+    },
+    {
+      "factors": 8,
+      "alias": 4,
+      "unchanged": true
+    }
+  ],
+  "positive": {
+    "cases": 300,
+    "forward_leaf_executions": 6420,
+    "inverse_cases": 300,
+    "distinct_equal_phase_control": true,
+    "output_digest": "3f1116efe767b4ca14e8c6646a1fbc68ee5c3c82fd2d8f458e7ffde2a1b37624"
+  },
+  "missing_guard_control": true,
+  "inherited_controls": {
+    "status": "passed",
+    "positive": 1,
+    "controls": [
+      {
+        "name": "undo_in_forward_order",
+        "rejected": "dirty restoration"
+      },
+      {
+        "name": "wrong_inner_phase",
+        "rejected": "dense error"
+      },
+      {
+        "name": "omit_inner_shift",
+        "rejected": "dense error"
+      },
+      {
+        "name": "negative_word_not_reversed",
+        "rejected": "dense error"
+      },
+      {
+        "name": "omit_last_commutator_term",
+        "rejected": "dense error"
+      },
+      {
+        "name": "omit_scratch_restoration",
+        "rejected": "dirty restoration"
+      },
+      {
+        "name": "overwrite_dirty_scratch",
+        "rejected": "dirty restoration"
+      },
+      {
+        "name": "insufficient_rounding",
+        "rejected": "dense error"
+      }
+    ]
+  },
+  "scope": "Read-only phase alias admission and finite exact restoration; no new kappa or all-length formal proof"
+}
diff --git a/research/cyclic-dirty-commutator-audit/evidence/BENCHMARK.json b/research/cyclic-dirty-commutator-audit/evidence/BENCHMARK.json
new file mode 100644
index 0000000000..a883d9c1cf
--- /dev/null
+++ b/research/cyclic-dirty-commutator-audit/evidence/BENCHMARK.json
@@ -0,0 +1,44 @@
+{
+  "python": "3.14.7",
+  "platform": "Darwin-25.1.0-arm64-arm-64bit-Mach-O",
+  "factors": 16,
+  "length": 8,
+  "bits": 1024,
+  "repetitions": 3,
+  "results": [
+    {
+      "method": "pinned binary",
+      "borrowed_arrays": 4,
+      "leaf_calls": 256,
+      "seconds": [
+        0.24837933387607336,
+        0.249744291882962,
+        0.28671433264389634
+      ],
+      "median_seconds": 0.249744291882962
+    },
+    {
+      "method": "echo fanout 8",
+      "borrowed_arrays": 8,
+      "leaf_calls": 112,
+      "seconds": [
+        0.12257891707122326,
+        0.12043329095467925,
+        0.11979654198512435
+      ],
+      "median_seconds": 0.12043329095467925
+    },
+    {
+      "method": "flat echo",
+      "borrowed_arrays": 15,
+      "leaf_calls": 60,
+      "seconds": [
+        0.06886491598561406,
+        0.0731649580411613,
+        0.07123987469822168
+      ],
+      "median_seconds": 0.07123987469822168
+    }
+  ],
+  "scope": "Same source, target, phases, factors, precision and prefix of a common scratch pool. Unequal scratch counts are explicit. Fraction prototype timing only; no practical multiplication speedup claim."
+}
diff --git a/research/cyclic-dirty-commutator-audit/evidence/ECHO.json b/research/cyclic-dirty-commutator-audit/evidence/ECHO.json
new file mode 100644
index 0000000000..2821d30fe1
--- /dev/null
+++ b/research/cyclic-dirty-commutator-audit/evidence/ECHO.json
@@ -0,0 +1,1409 @@
+{
+  "status": "PASS_MULTIWAY_DIRTY_ECHO",
+  "source_commit": "0768f97d06c623b8211e651543c66135796b62bf",
+  "ideal": {
+    "noncommuting_cases": 72,
+    "negative_controls": [
+      "missing_first_undo",
+      "missing_dirty_subtraction",
+      "sign_only_inverse"
+    ]
+  },
+  "rounded": {
+    "cases": 744,
+    "output_digest": "093bed38742ebc68be6536641bfd4fbc295185d79d4d83dfb590a382f942244a",
+    "seed": 67
+  },
+  "dense": [
+    {
+      "factors": 1,
+      "fanout": 2,
+      "length": 1,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 1,
+      "bits": 43,
+      "error_squared": "0",
+      "bound": "143/2199023255552"
+    },
+    {
+      "factors": 1,
+      "fanout": 2,
+      "length": 1,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 1,
+      "bits": 44,
+      "error_squared": "45/5725472681694883771408449536",
+      "bound": "195/2199023255552"
+    },
+    {
+      "factors": 1,
+      "fanout": 2,
+      "length": 1,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 1,
+      "bits": 45,
+      "error_squared": "9/22901890726779535085633798144",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 1,
+      "fanout": 2,
+      "length": 1,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 1,
+      "bits": 43,
+      "error_squared": "0",
+      "bound": "143/2199023255552"
+    },
+    {
+      "factors": 1,
+      "fanout": 2,
+      "length": 1,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 1,
+      "bits": 44,
+      "error_squared": "45/5725472681694883771408449536",
+      "bound": "195/2199023255552"
+    },
+    {
+      "factors": 1,
+      "fanout": 2,
+      "length": 1,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 1,
+      "bits": 45,
+      "error_squared": "9/22901890726779535085633798144",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 1,
+      "fanout": 2,
+      "length": 3,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 1,
+      "bits": 44,
+      "error_squared": "845325/79583760790549063077508723769344",
+      "bound": "325/4398046511104"
+    },
+    {
+      "factors": 1,
+      "fanout": 2,
+      "length": 3,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 1,
+      "bits": 44,
+      "error_squared": "531045/39791880395274531538754361884672",
+      "bound": "13/137438953472"
+    },
+    {
+      "factors": 1,
+      "fanout": 2,
+      "length": 3,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 1,
+      "bits": 45,
+      "error_squared": "44181/39791880395274531538754361884672",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 1,
+      "fanout": 2,
+      "length": 3,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 1,
+      "bits": 44,
+      "error_squared": "861605/79583760790549063077508723769344",
+      "bound": "325/4398046511104"
+    },
+    {
+      "factors": 1,
+      "fanout": 2,
+      "length": 3,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 1,
+      "bits": 44,
+      "error_squared": "85545/9947970098818632884688590471168",
+      "bound": "13/137438953472"
+    },
+    {
+      "factors": 1,
+      "fanout": 2,
+      "length": 3,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 1,
+      "bits": 45,
+      "error_squared": "634741/159167521581098126155017447538688",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 1,
+      "fanout": 8,
+      "length": 1,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 1,
+      "bits": 43,
+      "error_squared": "0",
+      "bound": "143/2199023255552"
+    },
+    {
+      "factors": 1,
+      "fanout": 8,
+      "length": 1,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 1,
+      "bits": 44,
+      "error_squared": "45/5725472681694883771408449536",
+      "bound": "195/2199023255552"
+    },
+    {
+      "factors": 1,
+      "fanout": 8,
+      "length": 1,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 1,
+      "bits": 45,
+      "error_squared": "9/22901890726779535085633798144",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 1,
+      "fanout": 8,
+      "length": 1,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 1,
+      "bits": 43,
+      "error_squared": "0",
+      "bound": "143/2199023255552"
+    },
+    {
+      "factors": 1,
+      "fanout": 8,
+      "length": 1,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 1,
+      "bits": 44,
+      "error_squared": "45/5725472681694883771408449536",
+      "bound": "195/2199023255552"
+    },
+    {
+      "factors": 1,
+      "fanout": 8,
+      "length": 1,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 1,
+      "bits": 45,
+      "error_squared": "9/22901890726779535085633798144",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 1,
+      "fanout": 8,
+      "length": 3,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 1,
+      "bits": 44,
+      "error_squared": "845325/79583760790549063077508723769344",
+      "bound": "325/4398046511104"
+    },
+    {
+      "factors": 1,
+      "fanout": 8,
+      "length": 3,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 1,
+      "bits": 44,
+      "error_squared": "531045/39791880395274531538754361884672",
+      "bound": "13/137438953472"
+    },
+    {
+      "factors": 1,
+      "fanout": 8,
+      "length": 3,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 1,
+      "bits": 45,
+      "error_squared": "44181/39791880395274531538754361884672",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 1,
+      "fanout": 8,
+      "length": 3,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 1,
+      "bits": 44,
+      "error_squared": "861605/79583760790549063077508723769344",
+      "bound": "325/4398046511104"
+    },
+    {
+      "factors": 1,
+      "fanout": 8,
+      "length": 3,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 1,
+      "bits": 44,
+      "error_squared": "85545/9947970098818632884688590471168",
+      "bound": "13/137438953472"
+    },
+    {
+      "factors": 1,
+      "fanout": 8,
+      "length": 3,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 1,
+      "bits": 45,
+      "error_squared": "634741/159167521581098126155017447538688",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 3,
+      "fanout": 2,
+      "length": 1,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 10,
+      "bits": 74,
+      "error_squared": "0",
+      "bound": "1105/17592186044416"
+    },
+    {
+      "factors": 3,
+      "fanout": 2,
+      "length": 1,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 10,
+      "bits": 75,
+      "error_squared": "1565/72294377378634985855245359210525277143195264745472",
+      "bound": "65/1099511627776"
+    },
+    {
+      "factors": 3,
+      "fanout": 2,
+      "length": 1,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 10,
+      "bits": 75,
+      "error_squared": "29129/72294377378634985855245359210525277143195264745472",
+      "bound": "3055/35184372088832"
+    },
+    {
+      "factors": 3,
+      "fanout": 2,
+      "length": 1,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 10,
+      "bits": 74,
+      "error_squared": "0",
+      "bound": "1105/17592186044416"
+    },
+    {
+      "factors": 3,
+      "fanout": 2,
+      "length": 1,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 10,
+      "bits": 75,
+      "error_squared": "1565/72294377378634985855245359210525277143195264745472",
+      "bound": "65/1099511627776"
+    },
+    {
+      "factors": 3,
+      "fanout": 2,
+      "length": 1,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 10,
+      "bits": 75,
+      "error_squared": "29129/72294377378634985855245359210525277143195264745472",
+      "bound": "3055/35184372088832"
+    },
+    {
+      "factors": 3,
+      "fanout": 2,
+      "length": 3,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 10,
+      "bits": 74,
+      "error_squared": "28655844187523137/3033638881398473833126108562755128330203856779768202392502272",
+      "bound": "2015/17592186044416"
+    },
+    {
+      "factors": 3,
+      "fanout": 2,
+      "length": 3,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 10,
+      "bits": 75,
+      "error_squared": "9237084879216701/24269111051187790665008868502041026641630854238145619140018176",
+      "bound": "1235/17592186044416"
+    },
+    {
+      "factors": 3,
+      "fanout": 2,
+      "length": 3,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 10,
+      "bits": 75,
+      "error_squared": "10322297665046461/12134555525593895332504434251020513320815427119072809570009088",
+      "bound": "3055/35184372088832"
+    },
+    {
+      "factors": 3,
+      "fanout": 2,
+      "length": 3,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 10,
+      "bits": 74,
+      "error_squared": "42698701217693925/6067277762796947666252217125510256660407713559536404785004544",
+      "bound": "2015/17592186044416"
+    },
+    {
+      "factors": 3,
+      "fanout": 2,
+      "length": 3,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 10,
+      "bits": 75,
+      "error_squared": "24634345476875921/12134555525593895332504434251020513320815427119072809570009088",
+      "bound": "1235/17592186044416"
+    },
+    {
+      "factors": 3,
+      "fanout": 2,
+      "length": 3,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 10,
+      "bits": 75,
+      "error_squared": "26584679622033565/24269111051187790665008868502041026641630854238145619140018176",
+      "bound": "3055/35184372088832"
+    },
+    {
+      "factors": 3,
+      "fanout": 3,
+      "length": 1,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 8,
+      "bits": 67,
+      "error_squared": "0",
+      "bound": "221/2199023255552"
+    },
+    {
+      "factors": 3,
+      "fanout": 3,
+      "length": 1,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 8,
+      "bits": 68,
+      "error_squared": "161033/4412498619301451773391440381501786935009476608",
+      "bound": "13/137438953472"
+    },
+    {
+      "factors": 3,
+      "fanout": 3,
+      "length": 1,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 8,
+      "bits": 69,
+      "error_squared": "35989/4412498619301451773391440381501786935009476608",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 3,
+      "fanout": 3,
+      "length": 1,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 8,
+      "bits": 67,
+      "error_squared": "0",
+      "bound": "221/2199023255552"
+    },
+    {
+      "factors": 3,
+      "fanout": 3,
+      "length": 1,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 8,
+      "bits": 68,
+      "error_squared": "161033/4412498619301451773391440381501786935009476608",
+      "bound": "13/137438953472"
+    },
+    {
+      "factors": 3,
+      "fanout": 3,
+      "length": 1,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 8,
+      "bits": 69,
+      "error_squared": "35989/4412498619301451773391440381501786935009476608",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 3,
+      "fanout": 3,
+      "length": 3,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 8,
+      "bits": 68,
+      "error_squared": "50235948989669053/1481268985057848551331107696657777504982351943246192574464",
+      "bound": "403/4398046511104"
+    },
+    {
+      "factors": 3,
+      "fanout": 3,
+      "length": 3,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 8,
+      "bits": 68,
+      "error_squared": "15893177211013505/740634492528924275665553848328888752491175971623096287232",
+      "bound": "247/2199023255552"
+    },
+    {
+      "factors": 3,
+      "fanout": 3,
+      "length": 3,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 8,
+      "bits": 69,
+      "error_squared": "9247784926834873/2962537970115697102662215393315555009964703886492385148928",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 3,
+      "fanout": 3,
+      "length": 3,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 8,
+      "bits": 68,
+      "error_squared": "12915486017201725/740634492528924275665553848328888752491175971623096287232",
+      "bound": "403/4398046511104"
+    },
+    {
+      "factors": 3,
+      "fanout": 3,
+      "length": 3,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 8,
+      "bits": 68,
+      "error_squared": "6881949794205245/370317246264462137832776924164444376245587985811548143616",
+      "bound": "247/2199023255552"
+    },
+    {
+      "factors": 3,
+      "fanout": 3,
+      "length": 3,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 8,
+      "bits": 69,
+      "error_squared": "29427656934528385/2962537970115697102662215393315555009964703886492385148928",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 3,
+      "fanout": 8,
+      "length": 1,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 8,
+      "bits": 67,
+      "error_squared": "0",
+      "bound": "221/2199023255552"
+    },
+    {
+      "factors": 3,
+      "fanout": 8,
+      "length": 1,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 8,
+      "bits": 68,
+      "error_squared": "161033/4412498619301451773391440381501786935009476608",
+      "bound": "13/137438953472"
+    },
+    {
+      "factors": 3,
+      "fanout": 8,
+      "length": 1,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 8,
+      "bits": 69,
+      "error_squared": "35989/4412498619301451773391440381501786935009476608",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 3,
+      "fanout": 8,
+      "length": 1,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 8,
+      "bits": 67,
+      "error_squared": "0",
+      "bound": "221/2199023255552"
+    },
+    {
+      "factors": 3,
+      "fanout": 8,
+      "length": 1,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 8,
+      "bits": 68,
+      "error_squared": "161033/4412498619301451773391440381501786935009476608",
+      "bound": "13/137438953472"
+    },
+    {
+      "factors": 3,
+      "fanout": 8,
+      "length": 1,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 8,
+      "bits": 69,
+      "error_squared": "35989/4412498619301451773391440381501786935009476608",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 3,
+      "fanout": 8,
+      "length": 3,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 8,
+      "bits": 68,
+      "error_squared": "50235948989669053/1481268985057848551331107696657777504982351943246192574464",
+      "bound": "403/4398046511104"
+    },
+    {
+      "factors": 3,
+      "fanout": 8,
+      "length": 3,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 8,
+      "bits": 68,
+      "error_squared": "15893177211013505/740634492528924275665553848328888752491175971623096287232",
+      "bound": "247/2199023255552"
+    },
+    {
+      "factors": 3,
+      "fanout": 8,
+      "length": 3,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 8,
+      "bits": 69,
+      "error_squared": "9247784926834873/2962537970115697102662215393315555009964703886492385148928",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 3,
+      "fanout": 8,
+      "length": 3,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 8,
+      "bits": 68,
+      "error_squared": "12915486017201725/740634492528924275665553848328888752491175971623096287232",
+      "bound": "403/4398046511104"
+    },
+    {
+      "factors": 3,
+      "fanout": 8,
+      "length": 3,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 8,
+      "bits": 68,
+      "error_squared": "6881949794205245/370317246264462137832776924164444376245587985811548143616",
+      "bound": "247/2199023255552"
+    },
+    {
+      "factors": 3,
+      "fanout": 8,
+      "length": 3,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 8,
+      "bits": 69,
+      "error_squared": "29427656934528385/2962537970115697102662215393315555009964703886492385148928",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 8,
+      "fanout": 2,
+      "length": 1,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 64,
+      "bits": 239,
+      "error_squared": "0",
+      "bound": "65/1099511627776"
+    },
+    {
+      "factors": 8,
+      "fanout": 2,
+      "length": 1,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 64,
+      "bits": 239,
+      "error_squared": "4989435893397/2741269410823147446219127729268166784348343231814783179906247636881838092476569145600345677802954456012709195009546903735298970372662851350642641405711745024",
+      "bound": "429/4398046511104"
+    },
+    {
+      "factors": 8,
+      "fanout": 2,
+      "length": 1,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 64,
+      "bits": 240,
+      "error_squared": "1452604069621/10965077643292589784876510917072667137393372927259132719624990547527352369906276582401382711211817824050836780038187614941195881490651405402570565622846980096",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 8,
+      "fanout": 2,
+      "length": 1,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 64,
+      "bits": 239,
+      "error_squared": "0",
+      "bound": "65/1099511627776"
+    },
+    {
+      "factors": 8,
+      "fanout": 2,
+      "length": 1,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 64,
+      "bits": 239,
+      "error_squared": "4989435893397/2741269410823147446219127729268166784348343231814783179906247636881838092476569145600345677802954456012709195009546903735298970372662851350642641405711745024",
+      "bound": "429/4398046511104"
+    },
+    {
+      "factors": 8,
+      "fanout": 2,
+      "length": 1,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 64,
+      "bits": 240,
+      "error_squared": "1452604069621/10965077643292589784876510917072667137393372927259132719624990547527352369906276582401382711211817824050836780038187614941195881490651405402570565622846980096",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 8,
+      "fanout": 2,
+      "length": 3,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 64,
+      "bits": 239,
+      "error_squared": "25012018725593465758207676536753764881195449/14921643010776665487231202847319449202697081322937083109118992047262987886568752811993941016185699182830626276869444444599800332856747994008262671588744561453707761209110354228277090975744",
+      "bound": "221/2199023255552"
+    },
+    {
+      "factors": 8,
+      "fanout": 2,
+      "length": 3,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 64,
+      "bits": 240,
+      "error_squared": "1246487912690573773150211195903693762759665/7460821505388332743615601423659724601348540661468541554559496023631493943284376405996970508092849591415313138434722222299900166428373997004131335794372280726853880604555177114138545487872",
+      "bound": "533/8796093022208"
+    },
+    {
+      "factors": 8,
+      "fanout": 2,
+      "length": 3,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 64,
+      "bits": 240,
+      "error_squared": "5388206309890779698307747718168044438689597/14921643010776665487231202847319449202697081322937083109118992047262987886568752811993941016185699182830626276869444444599800332856747994008262671588744561453707761209110354228277090975744",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 8,
+      "fanout": 2,
+      "length": 3,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 64,
+      "bits": 239,
+      "error_squared": "3790598039546558908593877583481261759554029/7460821505388332743615601423659724601348540661468541554559496023631493943284376405996970508092849591415313138434722222299900166428373997004131335794372280726853880604555177114138545487872",
+      "bound": "221/2199023255552"
+    },
+    {
+      "factors": 8,
+      "fanout": 2,
+      "length": 3,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 64,
+      "bits": 240,
+      "error_squared": "47079401493958852903851521803885361060162749/298432860215533309744624056946388984053941626458741662182379840945259757731375056239878820323713983656612525537388888891996006657134959880165253431774891229074155224182207084565541819514880",
+      "bound": "533/8796093022208"
+    },
+    {
+      "factors": 8,
+      "fanout": 2,
+      "length": 3,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 64,
+      "bits": 240,
+      "error_squared": "4773240439263082300599962001440040421936377/74608215053883327436156014236597246013485406614685415545594960236314939432843764059969705080928495914153131384347222222999001664283739970041313357943722807268538806045551771141385454878720",
+      "bound": "611/8796093022208"
+    },
+    {
+      "factors": 8,
+      "fanout": 8,
+      "length": 1,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 28,
+      "bits": 130,
+      "error_squared": "0",
+      "bound": "91/1099511627776"
+    },
+    {
+      "factors": 8,
+      "fanout": 8,
+      "length": 1,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 28,
+      "bits": 130,
+      "error_squared": "374468104205/813434668745320182953987865430192360034339446265098424297960809146313384280976961266778112",
+      "bound": "3549/35184372088832"
+    },
+    {
+      "factors": 8,
+      "fanout": 8,
+      "length": 1,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 28,
+      "bits": 131,
+      "error_squared": "38642112517/1626869337490640365907975730860384720068678892530196848595921618292626768561953922533556224",
+      "bound": "4277/70368744177664"
+    },
+    {
+      "factors": 8,
+      "fanout": 8,
+      "length": 1,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 28,
+      "bits": 130,
+      "error_squared": "0",
+      "bound": "91/1099511627776"
+    },
+    {
+      "factors": 8,
+      "fanout": 8,
+      "length": 1,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 28,
+      "bits": 130,
+      "error_squared": "374468104205/813434668745320182953987865430192360034339446265098424297960809146313384280976961266778112",
+      "bound": "3549/35184372088832"
+    },
+    {
+      "factors": 8,
+      "fanout": 8,
+      "length": 1,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 28,
+      "bits": 131,
+      "error_squared": "38642112517/1626869337490640365907975730860384720068678892530196848595921618292626768561953922533556224",
+      "bound": "4277/70368744177664"
+    },
+    {
+      "factors": 8,
+      "fanout": 8,
+      "length": 3,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 28,
+      "bits": 131,
+      "error_squared": "6248821216110216436302313660656658871345525/70844736043436518934519144626304199326530513372698682292576752254659285632505374174288390856297353106785558384056888983552",
+      "bound": "2093/35184372088832"
+    },
+    {
+      "factors": 8,
+      "fanout": 8,
+      "length": 3,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 28,
+      "bits": 131,
+      "error_squared": "15932219435059081712197789542517528471738409/141689472086873037869038289252608398653061026745397364585153504509318571265010748348576781712594706213571116768113777967104",
+      "bound": "4823/70368744177664"
+    },
+    {
+      "factors": 8,
+      "fanout": 8,
+      "length": 3,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 28,
+      "bits": 131,
+      "error_squared": "27241056707538584615835301376211581387851881/141689472086873037869038289252608398653061026745397364585153504509318571265010748348576781712594706213571116768113777967104",
+      "bound": "4277/70368744177664"
+    },
+    {
+      "factors": 8,
+      "fanout": 8,
+      "length": 3,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 28,
+      "bits": 131,
+      "error_squared": "17464830442413420430508333479578740636257061/141689472086873037869038289252608398653061026745397364585153504509318571265010748348576781712594706213571116768113777967104",
+      "bound": "2093/35184372088832"
+    },
+    {
+      "factors": 8,
+      "fanout": 8,
+      "length": 3,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 28,
+      "bits": 131,
+      "error_squared": "22511005339547848749148379316838236463188161/141689472086873037869038289252608398653061026745397364585153504509318571265010748348576781712594706213571116768113777967104",
+      "bound": "4823/70368744177664"
+    },
+    {
+      "factors": 8,
+      "fanout": 8,
+      "length": 3,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 28,
+      "bits": 131,
+      "error_squared": "34279220853882733379714650533495435021266693/141689472086873037869038289252608398653061026745397364585153504509318571265010748348576781712594706213571116768113777967104",
+      "bound": "4277/70368744177664"
+    },
+    {
+      "factors": 15,
+      "fanout": 2,
+      "length": 1,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 232,
+      "bits": 745,
+      "error_squared": "0",
+      "bound": "8671/140737488355328"
+    },
+    {
+      "factors": 15,
+      "fanout": 2,
+      "length": 1,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 232,
+      "bits": 745,
+      "error_squared": "26485763091070992175565/5710700771677330204002772890396232381091665072677555053630350787335347204427553759172521865229731160725058598729487519356049219506473630119158250928169843590310591176159158679568123858901160890164040100522811138100615719824772304531741655051699685051331161940944226795745164868436415112265153854712470593004502372245273094874996200278593074535774631429026695937608627838666767585718768890929554991060407777084890782294623896400836916624676824850759529681500055749542281216",
+      "bound": "6409/70368744177664"
+    },
+    {
+      "factors": 15,
+      "fanout": 2,
+      "length": 1,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 232,
+      "bits": 746,
+      "error_squared": "1619106082426018522612697/45685606173418641632022183123169859048733320581420440429042806298682777635420430073380174921837849285800468789835900154848393756051789040953266007425358748722484729409273269436544990871209287121312320804182489104804925758598178436253933240413597480410649295527553814365961318947491320898121230837699764744036018977962184758999969602228744596286197051432213567500869022709334140685750151127436439928483262216679126258356991171206695332997414598806076237452000445996338249728",
+      "bound": "17719/281474976710656"
+    },
+    {
+      "factors": 15,
+      "fanout": 2,
+      "length": 1,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 232,
+      "bits": 745,
+      "error_squared": "0",
+      "bound": "8671/140737488355328"
+    },
+    {
+      "factors": 15,
+      "fanout": 2,
+      "length": 1,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 232,
+      "bits": 745,
+      "error_squared": "26485763091070992175565/5710700771677330204002772890396232381091665072677555053630350787335347204427553759172521865229731160725058598729487519356049219506473630119158250928169843590310591176159158679568123858901160890164040100522811138100615719824772304531741655051699685051331161940944226795745164868436415112265153854712470593004502372245273094874996200278593074535774631429026695937608627838666767585718768890929554991060407777084890782294623896400836916624676824850759529681500055749542281216",
+      "bound": "6409/70368744177664"
+    },
+    {
+      "factors": 15,
+      "fanout": 2,
+      "length": 1,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 232,
+      "bits": 746,
+      "error_squared": "1619106082426018522612697/45685606173418641632022183123169859048733320581420440429042806298682777635420430073380174921837849285800468789835900154848393756051789040953266007425358748722484729409273269436544990871209287121312320804182489104804925758598178436253933240413597480410649295527553814365961318947491320898121230837699764744036018977962184758999969602228744596286197051432213567500869022709334140685750151127436439928483262216679126258356991171206695332997414598806076237452000445996338249728",
+      "bound": "17719/281474976710656"
+    },
+    {
+      "factors": 15,
+      "fanout": 2,
+      "length": 3,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 232,
+      "bits": 745,
+      "error_squared": "828049581361743174180849626544853309498581570039399851350132836704601467923479265/48692955547735180801212293210498753309951637695953364963344145348456932647933386313399535818747842021433802380896731098161269340081979008526767240983014659397839634002648650681425983228646070507954928135357669564473026256906395889422104302310852320129608016105256275258804524059491983446698052513702760893720674386885933219192757017868553729836222091935129794361521088685690929112949159937029054790126171868336615986558525334673264041264368568131579268374857300404105179657048804610491467180280272878138177454088639766975821643776",
+      "bound": "13949/140737488355328"
+    },
+    {
+      "factors": 15,
+      "fanout": 2,
+      "length": 3,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 232,
+      "bits": 746,
+      "error_squared": "22520935430994631609425476602758938867738747415112225526605575960056237151409206721/4869295554773518080121229321049875330995163769595336496334414534845693264793338631339953581874784202143380238089673109816126934008197900852676724098301465939783963400264865068142598322864607050795492813535766956447302625690639588942210430231085232012960801610525627525880452405949198344669805251370276089372067438688593321919275701786855372983622209193512979436152108868569092911294915993702905479012617186833661598655852533467326404126436856813157926837485730040410517965704880461049146718028027287813817745408863976697582164377600",
+      "bound": "4147/70368744177664"
+    },
+    {
+      "factors": 15,
+      "fanout": 2,
+      "length": 3,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 232,
+      "bits": 746,
+      "error_squared": "4643792340411310210875446289144470339139753363166317428099589438771904726778182841/973859110954703616024245864209975066199032753919067299266882906969138652958667726267990716374956840428676047617934621963225386801639580170535344819660293187956792680052973013628519664572921410159098562707153391289460525138127917788442086046217046402592160322105125505176090481189839668933961050274055217874413487737718664383855140357371074596724441838702595887230421773713818582258983198740581095802523437366732319731170506693465280825287371362631585367497146008082103593140976092209829343605605457562763549081772795339516432875520",
+      "bound": "17719/281474976710656"
+    },
+    {
+      "factors": 15,
+      "fanout": 2,
+      "length": 3,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 232,
+      "bits": 745,
+      "error_squared": "2833860952067816967216359281852913379235410051023493988615534836166692547841638493/48692955547735180801212293210498753309951637695953364963344145348456932647933386313399535818747842021433802380896731098161269340081979008526767240983014659397839634002648650681425983228646070507954928135357669564473026256906395889422104302310852320129608016105256275258804524059491983446698052513702760893720674386885933219192757017868553729836222091935129794361521088685690929112949159937029054790126171868336615986558525334673264041264368568131579268374857300404105179657048804610491467180280272878138177454088639766975821643776",
+      "bound": "13949/140737488355328"
+    },
+    {
+      "factors": 15,
+      "fanout": 2,
+      "length": 3,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 232,
+      "bits": 746,
+      "error_squared": "33219798774891811146907197853910780505527493728411070808206095094709461383488530209/1217323888693379520030307330262468832748790942398834124083603633711423316198334657834988395468696050535845059522418277454031733502049475213169181024575366484945990850066216267035649580716151762698873203383941739111825656422659897235552607557771308003240200402631406881470113101487299586167451312842569022343016859672148330479818925446713843245905552298378244859038027217142273227823728998425726369753154296708415399663963133366831601031609214203289481709371432510102629491426220115262286679507006821953454436352215994174395541094400",
+      "bound": "4147/70368744177664"
+    },
+    {
+      "factors": 15,
+      "fanout": 2,
+      "length": 3,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 232,
+      "bits": 746,
+      "error_squared": "8869251604270016567756516532175029835117761518923611236582879986120957204292407513/608661944346689760015153665131234416374395471199417062041801816855711658099167328917494197734348025267922529761209138727015866751024737606584590512287683242472995425033108133517824790358075881349436601691970869555912828211329948617776303778885654001620100201315703440735056550743649793083725656421284511171508429836074165239909462723356921622952776149189122429519013608571136613911864499212863184876577148354207699831981566683415800515804607101644740854685716255051314745713110057631143339753503410976727218176107997087197770547200",
+      "bound": "17719/281474976710656"
+    },
+    {
+      "factors": 15,
+      "fanout": 8,
+      "length": 1,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 106,
+      "bits": 366,
+      "error_squared": "0",
+      "bound": "24115/281474976710656"
+    },
+    {
+      "factors": 15,
+      "fanout": 8,
+      "length": 1,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 106,
+      "bits": 366,
+      "error_squared": "89281955663251126060205/470828457587543489955908529969589549067812493326246344826496146259535641909074445749847973267257381681953143440883001800827771096696485068444355025733328928408925493393730181645534017478717092796370346111731187622933579826298402820776481783808",
+      "bound": "14469/140737488355328"
+    },
+    {
+      "factors": 15,
+      "fanout": 8,
+      "length": 1,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 106,
+      "bits": 366,
+      "error_squared": "1388777972514789750598549/7533255321400695839294536479513432785084999893219941517223938340152570270545191131997567572276118106911250295054128028813244337547143761095109680411733262854542807894299682906328544279659473484741925537787699001966937277220774445132423708540928",
+      "bound": "32383/281474976710656"
+    },
+    {
+      "factors": 15,
+      "fanout": 8,
+      "length": 1,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 106,
+      "bits": 366,
+      "error_squared": "0",
+      "bound": "24115/281474976710656"
+    },
+    {
+      "factors": 15,
+      "fanout": 8,
+      "length": 1,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 106,
+      "bits": 366,
+      "error_squared": "89281955663251126060205/470828457587543489955908529969589549067812493326246344826496146259535641909074445749847973267257381681953143440883001800827771096696485068444355025733328928408925493393730181645534017478717092796370346111731187622933579826298402820776481783808",
+      "bound": "14469/140737488355328"
+    },
+    {
+      "factors": 15,
+      "fanout": 8,
+      "length": 1,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 106,
+      "bits": 366,
+      "error_squared": "1388777972514789750598549/7533255321400695839294536479513432785084999893219941517223938340152570270545191131997567572276118106911250295054128028813244337547143761095109680411733262854542807894299682906328544279659473484741925537787699001966937277220774445132423708540928",
+      "bound": "32383/281474976710656"
+    },
+    {
+      "factors": 15,
+      "fanout": 8,
+      "length": 3,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 106,
+      "bits": 367,
+      "error_squared": "4925787502410341580710662181163854899674122968610189108911297726940931114632164357/128466358564594633191134058457714627982241562144990502489728833760027489039142444347832800788720441236196493791343630919950821383322857730827332052677936494036646789492946127549946041995412032703377751706576364528624996636360404464456875356814414554758691705958879118020481730584552915604837676735266816",
+      "bound": "33761/562949953421312"
+    },
+    {
+      "factors": 15,
+      "fanout": 8,
+      "length": 3,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 106,
+      "bits": 367,
+      "error_squared": "12464544849815371107830606939794529373905154580064155725988075184112622439034139317/321165896411486582977835146144286569955603905362476256224322084400068722597856110869582001971801103090491234478359077299877053458307144327068330131694841235091616973732365318874865104988530081758444379266440911321562491590901011161142188392036036386896729264897197795051204326461382289012094191838167040",
+      "bound": "4823/70368744177664"
+    },
+    {
+      "factors": 15,
+      "fanout": 8,
+      "length": 3,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 106,
+      "bits": 366,
+      "error_squared": "58134713075175657394046369019568088103673704628108120898523963706443103019695678517/802914741028716457444587865360716424889009763406190640560805211000171806494640277173955004929502757726228086195897693249692633645767860817670825329237103087729042434330913297187162762471325204396110948166102278303906228977252527902855470980090090967241823162242994487628010816153455722530235479595417600",
+      "bound": "32383/281474976710656"
+    },
+    {
+      "factors": 15,
+      "fanout": 8,
+      "length": 3,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 106,
+      "bits": 367,
+      "error_squared": "519729018960351193924107899621428772599085454900933768796171406128387808861304821/32116589641148658297783514614428656995560390536247625622432208440006872259785611086958200197180110309049123447835907729987705345830714432706833013169484123509161697373236531887486510498853008175844437926644091132156249159090101116114218839203603638689672926489719779505120432646138228901209419183816704",
+      "bound": "33761/562949953421312"
+    },
+    {
+      "factors": 15,
+      "fanout": 8,
+      "length": 3,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 106,
+      "bits": 367,
+      "error_squared": "40071829024751500046707951824954747387660167768995257594890099125912531062064408513/3211658964114865829778351461442865699556039053624762562243220844000687225978561108695820019718011030904912344783590772998770534583071443270683301316948412350916169737323653188748651049885300817584443792664409113215624915909010111611421883920360363868967292648971977950512043264613822890120941918381670400",
+      "bound": "4823/70368744177664"
+    },
+    {
+      "factors": 15,
+      "fanout": 8,
+      "length": 3,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 106,
+      "bits": 366,
+      "error_squared": "8559498705710083523383014504369354693882374475478540509856313172886369727388593/313638570714342366189292134906529853472269438830543218969064535546942111911968858271076173800587014736807846170272536425661185017878070631902666144233243393644157200910513006713735454090361407967230839127383702462463370694239268712052918351597691784078837172751169721729691725059943641613373234216960",
+      "bound": "32383/281474976710656"
+    },
+    {
+      "factors": 15,
+      "fanout": 15,
+      "length": 1,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 56,
+      "bits": 216,
+      "error_squared": "0",
+      "bound": "4823/70368744177664"
+    },
+    {
+      "factors": 15,
+      "fanout": 15,
+      "length": 1,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 56,
+      "bits": 216,
+      "error_squared": "141731419059209494418081/3698145447070748073156451013535941245605565472299547500482147698953927105011768415629245558413880385765443213402728068606961366675122875256713688465276928",
+      "bound": "1365/17592186044416"
+    },
+    {
+      "factors": 15,
+      "fanout": 15,
+      "length": 1,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 56,
+      "bits": 216,
+      "error_squared": "80750875490868573067689/3698145447070748073156451013535941245605565472299547500482147698953927105011768415629245558413880385765443213402728068606961366675122875256713688465276928",
+      "bound": "4277/70368744177664"
+    },
+    {
+      "factors": 15,
+      "fanout": 15,
+      "length": 1,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 56,
+      "bits": 216,
+      "error_squared": "0",
+      "bound": "4823/70368744177664"
+    },
+    {
+      "factors": 15,
+      "fanout": 15,
+      "length": 1,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 56,
+      "bits": 216,
+      "error_squared": "141731419059209494418081/3698145447070748073156451013535941245605565472299547500482147698953927105011768415629245558413880385765443213402728068606961366675122875256713688465276928",
+      "bound": "1365/17592186044416"
+    },
+    {
+      "factors": 15,
+      "fanout": 15,
+      "length": 1,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 56,
+      "bits": 216,
+      "error_squared": "80750875490868573067689/3698145447070748073156451013535941245605565472299547500482147698953927105011768415629245558413880385765443213402728068606961366675122875256713688465276928",
+      "bound": "4277/70368744177664"
+    },
+    {
+      "factors": 15,
+      "fanout": 15,
+      "length": 3,
+      "direction": -1,
+      "dirt": 0,
+      "leaves": 56,
+      "bits": 216,
+      "error_squared": "4469312902018044354498375218647677166937990768781085983262104042180800920700366249/15766334033501153507421764115142242402016309537637234986908571243607226486245098724690480646849458192496143384575601812501475912206755078147479551285293912999508271476432503620237965680521608015007696161765064704",
+      "bound": "6097/70368744177664"
+    },
+    {
+      "factors": 15,
+      "fanout": 15,
+      "length": 3,
+      "direction": -1,
+      "dirt": 7,
+      "leaves": 56,
+      "bits": 216,
+      "error_squared": "4275868738896586507070669641523122694659513303890538547968889313658541583615924833/19707917541876441884277205143927803002520386922046543733635714054509033107806373405863100808561822740620179230719502265626844890258443847684349439106617391249385339345540629525297457100652010018759620202206330880",
+      "bound": "3367/35184372088832"
+    },
+    {
+      "factors": 15,
+      "fanout": 15,
+      "length": 3,
+      "direction": -1,
+      "dirt": -13,
+      "leaves": 56,
+      "bits": 216,
+      "error_squared": "29606853994122114731003365988150761731721936761259705183233336072103628243558611361/197079175418764418842772051439278030025203869220465437336357140545090331078063734058631008085618227406201792307195022656268448902584438476843494391066173912493853393455406295252974571006520100187596202022063308800",
+      "bound": "2457/35184372088832"
+    },
+    {
+      "factors": 15,
+      "fanout": 15,
+      "length": 3,
+      "direction": 1,
+      "dirt": 0,
+      "leaves": 56,
+      "bits": 216,
+      "error_squared": "928292141682012100728373382425671284856991889052187995639767230840714987333094285/15766334033501153507421764115142242402016309537637234986908571243607226486245098724690480646849458192496143384575601812501475912206755078147479551285293912999508271476432503620237965680521608015007696161765064704",
+      "bound": "6097/70368744177664"
+    },
+    {
+      "factors": 15,
+      "fanout": 15,
+      "length": 3,
+      "direction": 1,
+      "dirt": 7,
+      "leaves": 56,
+      "bits": 216,
+      "error_squared": "27179187133988352265839775869005989457845006379591525573167584631510616693488913441/394158350837528837685544102878556060050407738440930874672714281090180662156127468117262016171236454812403584614390045312536897805168876953686988782132347824987706786910812590505949142013040200375192404044126617600",
+      "bound": "3367/35184372088832"
+    },
+    {
+      "factors": 15,
+      "fanout": 15,
+      "length": 3,
+      "direction": 1,
+      "dirt": -13,
+      "leaves": 56,
+      "bits": 216,
+      "error_squared": "129942182422432128177329513823410682739333250085494721157211118506592345350314693373/394158350837528837685544102878556060050407738440930874672714281090180662156127468117262016171236454812403584614390045312536897805168876953686988782132347824987706786910812590505949142013040200375192404044126617600",
+      "bound": "2457/35184372088832"
+    }
+  ],
+  "alias_rejections": 62,
+  "resources": [
+    {
+      "factors": 8,
+      "fanout": 2,
+      "borrowed_arrays": 3,
+      "leaf_calls": 64
+    },
+    {
+      "factors": 8,
+      "fanout": 8,
+      "borrowed_arrays": 7,
+      "leaf_calls": 28
+    },
+    {
+      "factors": 16,
+      "fanout": 2,
+      "borrowed_arrays": 4,
+      "leaf_calls": 256
+    },
+    {
+      "factors": 16,
+      "fanout": 8,
+      "borrowed_arrays": 8,
+      "leaf_calls": 112
+    },
+    {
+      "factors": 16,
+      "fanout": 16,
+      "borrowed_arrays": 15,
+      "leaf_calls": 60
+    },
+    {
+      "factors": 64,
+      "fanout": 2,
+      "borrowed_arrays": 6,
+      "leaf_calls": 4096
+    },
+    {
+      "factors": 64,
+      "fanout": 8,
+      "borrowed_arrays": 14,
+      "leaf_calls": 784
+    },
+    {
+      "factors": 64,
+      "fanout": 64,
+      "borrowed_arrays": 63,
+      "leaf_calls": 252
+    },
+    {
+      "factors": 512,
+      "fanout": 2,
+      "borrowed_arrays": 9,
+      "leaf_calls": 262144
+    },
+    {
+      "factors": 512,
+      "fanout": 8,
+      "borrowed_arrays": 21,
+      "leaf_calls": 21952
+    },
+    {
+      "factors": 512,
+      "fanout": 512,
+      "borrowed_arrays": 511,
+      "leaf_calls": 2044
+    }
+  ],
+  "scope": "Classical local primitive with a symbolic proof; finite executable evidence is not formal verification or a new kappa."
+}
diff --git a/research/cyclic-dirty-commutator-audit/integer_model.py b/research/cyclic-dirty-commutator-audit/integer_model.py
new file mode 100644
index 0000000000..9a1a329070
--- /dev/null
+++ b/research/cyclic-dirty-commutator-audit/integer_model.py
@@ -0,0 +1,90 @@
+"""Independent integer-grid execution of PR628's stated dirty shear schedule.
+
+Data values are pairs of integers in units of 2**-bits. Coefficients remain
+exact rational pairs. No producer module or arithmetic helper is imported.
+The instruction word is compiled first, then inverted as a flat word.
+"""
+from fractions import Fraction
+
+
+def plus(a, b):
+    return a[0] + b[0], a[1] + b[1]
+
+
+def minus(a, b):
+    return a[0] - b[0], a[1] - b[1]
+
+
+def product(a, b):
+    return a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0]
+
+
+def conjugate(z):
+    return z[0], -z[1]
+
+
+def nearest(q):
+    """Round to an integer, with an exact half rounded toward +infinity."""
+    q = Fraction(q)
+    quotient, remainder = divmod(q.numerator, q.denominator)
+    return quotient + (2 * remainder >= q.denominator)
+
+
+def rounded_product(coefficient, value):
+    return tuple(nearest(q) for q in product(coefficient, value))
+
+
+def word(factors, source=0, target=1, depth=0):
+    """Expand the positive word into (source, target, factor, sign) leaves."""
+    if len(factors) == 1:
+        return [(source, target, factors[0], 1)]
+    middle = len(factors) // 2
+    scratch = depth + 2
+    b = word(factors[:middle], source, scratch, depth + 1)
+    a = word(factors[middle:], scratch, target, depth + 1)
+    return b + a + inverse(b) + inverse(a)
+
+
+def inverse(instructions):
+    return [(src, dst, factor, -sign) for src, dst, factor, sign in reversed(instructions)]
+
+
+def execute_leaf(arrays, instruction, phases, bits, direction):
+    src, dst, (inside, b, scale), sign = instruction
+    x, y = arrays[src], arrays[dst]
+    length, grid = len(x), 1 << bits
+    step = -direction if inside else direction
+    order = list(range(length))[::step]
+    coefficients = [product(b, conjugate(phases[(i + direction) % length]) if inside else phases[i])
+                    for i in range(length)]
+    power = (grid, 0)
+    for position, i in enumerate(order):
+        if position:
+            x[i] = plus(x[i], rounded_product(coefficients[i], x[order[position - 1]]))
+        power = rounded_product(coefficients[i], power)
+    denominator = (grid - power[0], -power[1])
+    norm = denominator[0] ** 2 + denominator[1] ** 2
+    numerator = product(x[order[-1]], conjugate(denominator))
+    seed = tuple(nearest(Fraction(v * grid, norm)) for v in numerator)
+    power = (grid, 0)
+    for i in order:
+        power = rounded_product(coefficients[i], power)
+        correction = tuple(Fraction(v, grid) for v in power)
+        value = plus(x[i], rounded_product(correction, seed))
+        multiplier = conjugate(phases[i]) if inside else (-b[0], -b[1])
+        multiplier = tuple(v * scale for v in multiplier)
+        increment = rounded_product(multiplier, value)
+        destination = (i - direction) % length if inside else i
+        y[destination] = plus(y[destination], tuple(sign * v for v in increment))
+    for position in range(length - 1, 0, -1):
+        i, previous = order[position], order[position - 1]
+        x[i] = minus(x[i], rounded_product(coefficients[i], x[previous]))
+
+
+def execute(arrays, factors, phases, bits, direction, sign):
+    instructions = word(factors)
+    if sign == -1:
+        instructions = inverse(instructions)
+    for instruction in instructions:
+        execute_leaf(arrays, instruction, phases, bits, direction)
+    return len(instructions)
diff --git a/research/cyclic-dirty-commutator-audit/phase-alias-guard.patch b/research/cyclic-dirty-commutator-audit/phase-alias-guard.patch
new file mode 100644
index 0000000000..6323498dfb
--- /dev/null
+++ b/research/cyclic-dirty-commutator-audit/phase-alias-guard.patch
@@ -0,0 +1,10 @@
+--- a/research/prime-power-cyclic-scan/dirty.py
++++ b/research/prime-power-cyclic-scan/dirty.py
+@@ -53,6 +53,7 @@
+     c.need(sign in(-1,1)and d in(-1,1),'orientation and sign')
+     c.need(factors and len(scratch)>=(len(factors)-1).bit_length(),'dirty depth')
+     arrays=[x,y]+scratch;c.need(len({id(v)for v in arrays})==len(arrays),'all ancestor arrays distinct')
++    c.need(all(phases is not v for v in arrays),'phase array aliases mutable data')
+     c.need(len(x)>0 and all(len(v)==len(x)for v in arrays)and len(phases)==len(x),'array lengths')
+     c.need(all(c.norm2(t)==1 for t in phases),'unit phases')
+     if len(factors)==1:return leaf(x,y,factors[0],phases,beta,bits,d,sign,stats)
diff --git a/research/cyclic-dirty-commutator-audit/replay.sh b/research/cyclic-dirty-commutator-audit/replay.sh
new file mode 100644
index 0000000000..da15b0dcb7
--- /dev/null
+++ b/research/cyclic-dirty-commutator-audit/replay.sh
@@ -0,0 +1,23 @@
+#!/bin/sh
+# Reproduce this sprint contribution without fetching or modifying tracked files.
+set -eu
+if [ "$#" -ne 1 ]; then
+    echo "usage: sh research/cyclic-dirty-commutator-audit/replay.sh NEW_OUTPUT_DIRECTORY" >&2
+    exit 2
+fi
+root=$(CDPATH= cd -- "$(dirname -- "$0")/../.." && pwd)
+if [ -e "$1" ]; then
+    echo "Use a new output directory" >&2
+    exit 2
+fi
+mkdir -p -- "$1"
+out=$(CDPATH= cd -- "$1" && pwd)
+python3 -I -B "$root/research/cyclic-dirty-commutator-audit/verify.py" --out "$out/ALIAS.json"
+python3 -I -B "$root/research/cyclic-dirty-commutator-audit/verify_echo.py" --out "$out/ECHO.json"
+python3 -I -B "$root/research/cyclic-dirty-commutator-audit/benchmark.py" --out "$out/BENCHMARK.json"
+python3 -B "$root/research/gauge44-notri-fine-grid/verify.py" --out "$out/fine-grid"
+sh "$root/research/dirty-echo-integration/replay.sh" "$out/integration"
+sh "$root/research/bit-role-sharing-budget/replay.sh" "$out/bit-role-sharing"
+sh "$root/research/bit-sharing-hosting-gate/replay.sh" "$out/bit-sharing-hosting-gate"
+sh "$root/research/bit-paired-boundary-gate/replay.sh" "$out/bit-paired-boundary-gate"
+echo PASS_DIRTY_ECHO_ALIAS_REPAIR_AND_FINE_GRID
diff --git a/research/cyclic-dirty-commutator-audit/verify.py b/research/cyclic-dirty-commutator-audit/verify.py
new file mode 100644
index 0000000000..2013b6a3da
--- /dev/null
+++ b/research/cyclic-dirty-commutator-audit/verify.py
@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""Reproduce the pinned phase-alias defect and validate its one-line repair.
+
+Uses only Python's standard library and Git. Fetch the source commit named in
+SOURCE.json before running. No network access or tracked-file writes occur here.
+"""
+import argparse
+import copy
+import difflib
+from fractions import Fraction as F
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+import random
+import subprocess
+import sys
+import tempfile
+
+HERE = Path(__file__).resolve().parent
+REPO = HERE.parents[1]
+GUARD = "    c.need(all(phases is not v for v in arrays),'phase array aliases mutable data')\n"
+ANCHOR = "    arrays=[x,y]+scratch;c.need(len({id(v)for v in arrays})==len(arrays),'all ancestor arrays distinct')\n"
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def call(module, arrays, factors, phases, bits, direction, sign):
+    stats = dict(leaves=0, scalar_steps=0)
+    module.compose(arrays[0], arrays[1], factors, arrays[2:], phases,
+                   F(1, 2), bits, direction, sign, stats)
+    return stats['leaves']
+
+
+def encode(value):
+    return json.dumps(value, sort_keys=True, separators=(',', ':'), default=str).encode()
+
+
+def aliases(module, factors_count):
+    results = []
+    depth = (factors_count - 1).bit_length()
+    factors = [(False, (F(1, 4), F(0)), F(1))] * factors_count
+    for index in range(2 + depth):
+        arrays = [[(F(1), F(0))] * 2 for _ in range(2 + depth)]
+        before = copy.deepcopy(arrays)
+        try:
+            call(module, arrays, factors, arrays[index], 8, 1, 1)
+        except ValueError as error:
+            message = str(error)
+        else:
+            message = 'accepted'
+        results.append(dict(alias=index, message=message, unchanged=arrays == before, after=arrays))
+    return results
+
+
+def positive_checks(original, patched, model):
+    rng = random.Random(67)
+    units = [(F(1), F(0)), (F(0), F(1)), (F(-1), F(0)),
+             (F(3, 5), F(4, 5)), (F(-5, 13), F(12, 13))]
+    traces = hashlib.sha256()
+    cases = leaves = 0
+    for nf in (1, 2, 3, 5, 8):
+        factors = [(i % 2 == 0, (F(1, 4), F((-1)**i, 8)), F(3 if i == 0 else 1))
+                   for i in range(nf)]
+        for length in (1, 2, 3, 5, 8):
+            phases = [rng.choice(units) for _ in range(length)]
+            for bits in (4, 8, 16):
+                grid = 1 << bits
+                integers = [[(rng.randrange(-2*grid, 2*grid+1), rng.randrange(-2*grid, 2*grid+1))
+                             for _ in range(length)] for _ in range(2+(nf-1).bit_length())]
+                values = [[(F(x, grid), F(y, grid)) for x, y in array] for array in integers]
+                for direction in (-1, 1):
+                    for sign in (-1, 1):
+                        baseline, fixed, independent = copy.deepcopy(values), copy.deepcopy(values), copy.deepcopy(integers)
+                        calls = call(original, baseline, factors, phases, bits, direction, sign)
+                        need(call(patched, fixed, factors, phases, bits, direction, sign) == calls, 'changed leaf count')
+                        need(model.execute(independent, factors, phases, bits, direction, sign) == calls, 'independent leaf count')
+                        expected = [[(F(x, grid), F(y, grid)) for x, y in array] for array in independent]
+                        need(fixed == baseline == expected, 'integer-grid differential mismatch')
+                        need(fixed[0] == values[0] and fixed[2:] == values[2:], 'source/scratch restoration')
+                        call(patched, fixed, factors, phases, bits, direction, -sign)
+                        model.execute(independent, factors, phases, bits, direction, -sign)
+                        need(fixed == values and independent == integers, 'exact inverse word')
+                        traces.update(encode(baseline))
+                        cases += 1
+                        leaves += calls
+    # Equal values are allowed; only identity aliasing is forbidden.
+    arrays = [[(F(1), F(0))] * 2 for _ in range(2)]
+    phases = arrays[0].copy()
+    call(patched, arrays, [(False, (F(1, 4), F(0)), F(1))], phases, 8, 1, 1)
+    need(phases == [(F(1), F(0))] * 2, 'read-only phases changed')
+    return dict(cases=cases, forward_leaf_executions=leaves, inverse_cases=cases,
+                distinct_equal_phase_control=True, output_digest=traces.hexdigest())
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--out', type=Path)
+    args = ap.parse_args()
+    source = json.loads((HERE/'SOURCE.json').read_text())
+    blobs = {}
+    for name, expected in source['files'].items():
+        result = subprocess.run(['git', 'show', source['commit']+':'+source['package']+'/'+name],
+                                cwd=REPO, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        need(result.returncode == 0, 'Missing pinned source; run the README fetch command first')
+        need(hashlib.sha256(result.stdout).hexdigest() == expected, 'source hash mismatch: '+name)
+        blobs[name] = result.stdout
+    original_text = blobs['dirty.py'].decode()
+    need(original_text.count(ANCHOR) == 1, 'unambiguous patch anchor')
+    patched_text = original_text.replace(ANCHOR, ANCHOR+GUARD)
+    path = source['package']+'/dirty.py'
+    patch = ''.join(difflib.unified_diff(original_text.splitlines(True), patched_text.splitlines(True),
+                                       fromfile='a/'+path, tofile='b/'+path))
+    need(patch == (HERE/'phase-alias-guard.patch').read_text(), 'patch differs from tested repair')
+    model = load('integer_audit_model', HERE/'integer_model.py')
+    # Positive and negative half-grid ties differ under sign negation.
+    need([model.nearest(F(n, 2)) for n in (-3, -1, 1, 3)] == [-1, 0, 1, 2], 'tie rule')
+    with tempfile.TemporaryDirectory(prefix='cyclic-dirty-audit-') as temp:
+        root = Path(temp)
+        for directory in ('original', 'patched'):
+            for name, content in blobs.items():
+                target = root/directory/name
+                target.parent.mkdir(parents=True, exist_ok=True)
+                target.write_bytes(content)
+        application = subprocess.run(['git', 'apply', '-p3', str(HERE/'phase-alias-guard.patch')],
+                                     cwd=root/'patched', capture_output=True, text=True)
+        need(application.returncode == 0, 'patch application: '+application.stderr)
+        need((root/'patched/dirty.py').read_text() == patched_text, 'applied patch content')
+        original = load('original_dirty_audit', root/'original/dirty.py')
+        patched = load('patched_dirty_audit', root/'patched/dirty.py')
+        original_counterexamples = aliases(original, 1)
+        need(original_counterexamples[0]['message'] == 'accepted', 'source alias no longer accepted')
+        need(original_counterexamples[0]['after'][0][1] == (F(15, 16), F(0)), 'counterexample changed')
+        need(original_counterexamples[1]['message'] == 'accepted' and not original_counterexamples[1]['unchanged'], 'target alias no longer accepted')
+        # Independent exact family: source[1] becomes 1-b^2 when phases aliases source.
+        family = []
+        for b in (F(1, 8), F(1, 4), F(3, 8), F(1, 2)):
+            for bits in (8, 16, 64):
+                arrays = [[(F(1), F(0))]*2, [(F(0), F(0))]*2]
+                call(original, arrays, [(False, (b, F(0)), F(1))], arrays[0], bits, 1, 1)
+                expected = 1-b*b
+                need(arrays[0][1] == (expected, F(0)), 'exact alias family')
+                family.append(dict(b=str(b), bits=bits, source_second=str(expected)))
+        rejected = []
+        for nf in (1, 2, 3, 5, 8):
+            for row in aliases(patched, nf):
+                need(row['message'] == 'phase array aliases mutable data' and row['unchanged'], 'alias rejected after mutation or accepted')
+                rejected.append(dict(factors=nf, alias=row['alias'], unchanged=True))
+        positives = positive_checks(original, patched, model)
+        # Deleting the new guard must re-expose the counterexample, not merely fail syntax.
+        (root/'patched/dirty.py').write_text(patched_text.replace(GUARD, ''))
+        mutant = load('missing_guard_audit', root/'patched/dirty.py')
+        need(not aliases(mutant, 1)[0]['unchanged'], 'missing-guard control did not detect source damage')
+        # Run the predecessor's instruction mutation suite against the patched code.
+        (root/'patched/dirty.py').write_text(patched_text)
+        result = subprocess.run([sys.executable, '-I', '-O', '-B', str(root/'patched/dirty_controls.py'),
+                                 '--out', str(root/'controls.json')], capture_output=True, text=True)
+        need(result.returncode == 0, 'inherited controls failed: '+result.stderr)
+        inherited = json.loads((root/'controls.json').read_text())
+        need(len(inherited['controls']) == 8, 'inherited control count')
+    report = dict(status='PASS_PHASE_ALIAS_REPAIR_AND_INTEGER_GRID_AUDIT', source_commit=source['commit'],
+                  source_hashes=source['files'], original_counterexamples=original_counterexamples,
+                  exact_source_alias_family=family, rejected_aliases=rejected,
+                  positive=positives, missing_guard_control=True, inherited_controls=inherited,
+                  scope='Read-only phase alias admission and finite exact restoration; no new kappa or all-length formal proof')
+    if args.out:
+        args.out.write_bytes(json.dumps(report, indent=2, default=str).encode()+b'\n')
+    print(report['status'], positives['cases'], 'differential cases;', len(rejected), 'pre-mutation alias rejections')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/cyclic-dirty-commutator-audit/verify_echo.py b/research/cyclic-dirty-commutator-audit/verify_echo.py
new file mode 100644
index 0000000000..6c49221752
--- /dev/null
+++ b/research/cyclic-dirty-commutator-audit/verify_echo.py
@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""Independent ideal identity, integer-grid differential, and dense error checks."""
+import argparse
+import copy
+from fractions import Fraction as F
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+import random
+import subprocess
+import tempfile
+
+HERE = Path(__file__).resolve().parent
+REPO = HERE.parents[1]
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+E = load('dirty_echo', HERE/'echo.py')
+M = load('echo_integer_model', HERE/'integer_model.py')
+
+
+def matvec(matrix, vector):
+    return [sum(a*b for a,b in zip(row,vector)) for row in matrix]
+
+
+def ideal_checks():
+    # Arbitrary noncommuting integer maps: direct matrix composition, no leaf or
+    # schedule recurrence, is the oracle for the streamed echo's target effect.
+    rng = random.Random(67)
+    cases = 0
+    for nf in (1,2,3,5,8,15,16,64):
+        matrices = [[[rng.randrange(-2,3) for _ in range(2)] for _ in range(2)] for _ in range(nf)]
+        for fanout in sorted({2,3,4,8,max(2,nf)}):
+            depth,calls = E.resources(nf,fanout)
+            before = [[rng.randrange(-7,8) for _ in range(2)] for _ in range(depth+2)]
+            expected = before[0][:]
+            for matrix in matrices:
+                expected = matvec(matrix,expected)
+            positive = list(E.instructions(0,nf,0,1,2,fanout))
+            negative = list(E.instructions(0,nf,0,1,2,fanout,-1))
+            need(len(positive) == calls, 'ideal leaf count')
+            need(negative == [(s,t,i,-q) for s,t,i,q in reversed(positive)], 'reverse inverse word')
+            for sign,word in ((1,positive),(-1,negative)):
+                arrays = copy.deepcopy(before)
+                for src,dst,index,q in word:
+                    increment = matvec(matrices[index],arrays[src])
+                    arrays[dst] = [a+q*b for a,b in zip(arrays[dst],increment)]
+                need(arrays[0] == before[0] and arrays[2:] == before[2:], 'ideal restoration')
+                need(arrays[1] == [a+sign*b for a,b in zip(before[1],expected)], 'ideal noncommuting product')
+                cases += 1
+    # Drop the first-link undo: both restoration and ideal target checks detect it.
+    nf=3;fanout=3;before=[[2],[7],[3],[5]];word=list(E.instructions(0,nf,0,1,2,fanout))
+    mutants = {'missing_first_undo': [op for j,op in enumerate(word) if j != 4],
+               'missing_dirty_subtraction': [op for op in word if op != (3,1,2,-1)]}
+    for name,word in mutants.items():
+        arrays=copy.deepcopy(before)
+        for src,dst,index,q in word:
+            arrays[dst][0] += q*(index+2)*arrays[src][0]
+        need(arrays[0] != before[0] or arrays[2:] != before[2:] or arrays[1] != [55], name+' escaped')
+    # Opposite signs in forward order are not generally the inverse of the word.
+    arrays=copy.deepcopy(before[:3])
+    for src,dst,index,q in E.instructions(0,2,0,1,2,2):
+        arrays[dst][0] -= q*(index+2)*arrays[src][0]
+    need(arrays != [before[0],[-5],before[2]], 'wrong inverse order escaped')
+    return dict(noncommuting_cases=cases,negative_controls=list(mutants)+['sign_only_inverse'])
+
+
+def rounded_checks(D):
+    rng = random.Random(67)
+    units = [(F(1),F(0)),(F(0),F(1)),(F(3,5),F(4,5))]
+    cases=0;digest=hashlib.sha256()
+    for nf in (1,2,3,5,8,15,16):
+        factors=[(i%2==0,(F(1,4),F((-1)**i,8)),F(3 if i==0 else 1)) for i in range(nf)]
+        for fanout in sorted({2,3,4,8,max(2,nf)}):
+            depth,leaves=E.resources(nf,fanout)
+            for length in (1,2,3):
+                phases=[units[i%3] for i in range(length)]
+                for bits in (4,16):
+                    grid=1<<bits
+                    integers=[[(rng.randrange(-grid,grid+1),rng.randrange(-grid,grid+1)) for _ in range(length)] for _ in range(2+depth)]
+                    original=[[(F(a,grid),F(b,grid)) for a,b in array] for array in integers]
+                    for direction in (-1,1):
+                        for sign in (-1,1):
+                            arrays=copy.deepcopy(original);expected=copy.deepcopy(integers)
+                            stats=E.compose(D,*arrays[:2],factors,arrays[2:],phases,F(1,2),bits,direction,sign,fanout)
+                            need(stats['leaves'] == leaves, 'rounded leaf count')
+                            # Shared schedule; the independent arithmetic checks below
+                            # do not constitute an independent identity proof.
+                            for src,dst,index,q in E.instructions(0,nf,0,1,2,fanout,sign):
+                                M.execute_leaf(expected,(src,dst,factors[index],q),phases,bits,direction)
+                            need(arrays == [[(F(a,grid),F(b,grid)) for a,b in z] for z in expected], 'integer arithmetic differential')
+                            need(arrays[0] == original[0] and arrays[2:] == original[2:], 'rounded restoration')
+                            digest.update(json.dumps(arrays,default=str).encode())
+                            E.compose(D,*arrays[:2],factors,arrays[2:],phases,F(1,2),bits,direction,-sign,fanout)
+                            need(arrays == original, 'rounded exact inverse')
+                            cases+=1
+    return dict(cases=cases,output_digest=digest.hexdigest(),seed=67)
+
+
+def ceil_log2(q):
+    result=q.numerator.bit_length()-q.denominator.bit_length()
+    if F(2)**result < q:
+        result+=1
+    return result
+
+
+def dense_checks(D):
+    results=[];beta=F(1,2);r=3;p=32;a=13*(r+1)/beta**3;G=2+F(r)/beta
+    for nf in (1,3,8,15):
+        factors=[(i%2==0,(F(1,4),F((-1)**i,8)),F(r if i==0 else 1)) for i in range(nf)]
+        for fanout in sorted({2,8,max(2,nf)}):
+            depth,N=E.resources(nf,fanout)
+            for length in (1,3):
+                phases=[(F(1),F(0)),(F(0),F(1)),(F(3,5),F(4,5))][:length]
+                for direction in (-1,1):
+                    for dirt in (0,7,-13):
+                        before=[[(F(dirt+2*i+j,4),F(dirt-3*i-j,8)) for i in range(length)] for j in range(depth+2)]
+                        magnitude=max(abs(x)+abs(y) for array in before for x,y in array)
+                        bits=max(p+1+ceil_log2(N*a*(magnitude+1))+(N-1)*ceil_log2(G),ceil_log2(a),ceil_log2(2/beta**2))
+                        u=F(1,1<<bits);bound=N*a*(magnitude+1)*u*G**(N-1)
+                        need(a*u<=1 and u<=beta**2/2 and bound<=F(1,1<<(p+1)), 'complete precision budget')
+                        expected=D.exact_operator(before[0],factors,phases,direction)
+                        arrays=copy.deepcopy(before)
+                        E.compose(D,*arrays[:2],factors,arrays[2:],phases,beta,bits,direction,fanout=fanout)
+                        error=max(D.c.norm2(D.c.sub(D.c.sub(y,y0),z)) for y,y0,z in zip(arrays[1],before[1],expected))
+                        need(error<=bound**2, 'dense error bound')
+                        need(arrays[0]==before[0] and arrays[2:]==before[2:], 'dense source/scratch restoration')
+                        results.append(dict(factors=nf,fanout=fanout,length=length,direction=direction,dirt=dirt,leaves=N,bits=bits,error_squared=str(error),bound=str(bound)))
+    return results
+
+
+def admission_checks(D):
+    cases=0
+    for nf in (1,3,8,15):
+        for fanout in sorted({2,8,max(2,nf)}):
+            depth,_=E.resources(nf,fanout)
+            for alias in range(depth+2):
+                arrays=[[(F(1),F(0))]*2 for _ in range(depth+2)]
+                before=copy.deepcopy(arrays)
+                try:
+                    E.compose(D,*arrays[:2],[(False,(F(1,4),F(0)),F(1))]*nf,arrays[2:],arrays[alias],F(1,2),8,1,fanout=fanout)
+                except ValueError as error:
+                    need(str(error)=='phase array aliases mutable data' and arrays==before, 'late alias rejection')
+                else:
+                    raise ValueError('phase alias accepted')
+                cases+=1
+    for count,fanout in ((0,2),(1,1),(2,0)):
+        try:
+            E.resources(count,fanout)
+        except ValueError:
+            pass
+        else:
+            raise ValueError('invalid resource domain accepted')
+    return cases
+
+
+def main():
+    parser=argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--out',type=Path,required=True)
+    args=parser.parse_args()
+    source=json.loads((HERE/'SOURCE.json').read_text())
+    with tempfile.TemporaryDirectory(prefix='dirty-echo-') as temp:
+        root=Path(temp)
+        for name,digest in source['files'].items():
+            result=subprocess.run(['git','show',source['commit']+':'+source['package']+'/'+name],cwd=REPO,capture_output=True)
+            need(result.returncode==0,'fetch pinned PR628 first')
+            need(hashlib.sha256(result.stdout).hexdigest()==digest,'source hash '+name)
+            (root/name).write_bytes(result.stdout)
+        D=load('echo_leaf_source',root/'dirty.py')
+        ideal=ideal_checks();print('PASS ideal noncommuting identity',ideal['noncommuting_cases'],flush=True)
+        rounded=rounded_checks(D);print('PASS rounded integer differential',rounded['cases'],flush=True)
+        dense=dense_checks(D);print('PASS dense error checks',len(dense),flush=True)
+        aliases=admission_checks(D)
+    resources=[]
+    for nf in (8,16,64,512):
+        for fanout in sorted({2,8,nf}):
+            depth,calls=E.resources(nf,fanout)
+            resources.append(dict(factors=nf,fanout=fanout,borrowed_arrays=depth,leaf_calls=calls))
+            if nf==fanout:
+                need(depth==nf-1 and calls==4*nf-4,'flat resources')
+    report=dict(status='PASS_MULTIWAY_DIRTY_ECHO',source_commit=source['commit'],ideal=ideal,rounded=rounded,dense=dense,alias_rejections=aliases,resources=resources,scope='Classical local primitive with a symbolic proof; finite executable evidence is not formal verification or a new kappa.')
+    args.out.write_text(json.dumps(report,indent=2)+'\n')
+    print(report['status'],ideal['noncommuting_cases'],'ideal;',rounded['cases'],'rounded;',len(dense),'dense;',aliases,'alias rejections')
+
+
+if __name__=='__main__':
+    main()
diff --git a/research/dirty-echo-integration/CLAIM.json b/research/dirty-echo-integration/CLAIM.json
new file mode 100644
index 0000000000..e36db8b84b
--- /dev/null
+++ b/research/dirty-echo-integration/CLAIM.json
@@ -0,0 +1,22 @@
+{
+  "continuation_of": "https://github.com/CrocSwap/integer-mult-bounds/pull/673",
+  "base_commit": "0e35f56cab3cae1eb0a99447135569d687c5695a",
+  "main_base": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "authorization": "User requested full-transform and bit-supplier integration to test for a substantial kappa improvement.",
+  "scope": "Implement the all-role adapter around multiway echo, execute complete synthetic Fourier rounds and Boolean address interchange, and price its complete recursive child bill before any exponent claim.",
+  "hypothesis": "Subquadratic dirty shear composition may improve the paid all-role supplier recurrence after an explicit adapter.",
+  "method": "Exact Gaussian rational synthetic-ring transforms, symbolic Boolean basis columns, independent direct Fourier/convolution/permutation oracles, complete all-role child accounting and exact moment comparisons.",
+  "coordination": "Continue existing PR673. Final refresh through PR693; PR673 remains open at the base head with no reviews/comments. No second sprint PR. PR677 concerns a different native ADDRESS shear; PR670/674 shorten unchanged scalar words; PR679 prices selector batching; PR689 refines balanced ternary placement in our original echo. None is consumed as a dependency.",
+  "overlap_heads": {
+    "679": "dce137e540acd2b689281afe222cd32c0ec1f1ae",
+    "689": "0dedef12f05f9a06faf9d4e1c8b1462c0e3bff3a"
+  },
+  "result": {
+    "status": "COMPLETED_SCOPED_NEGATIVE_INTEGRATION_RESULT",
+    "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/673",
+    "functional": "All-role complex and Boolean adapters, complete stored-order synthetic transforms and convolution pass exact references.",
+    "cost": "Even optimistic one-child additive leaves give moment >= 6-6/n >= 3 for n>=2. This adapter provides no positive supplier saving and no new kappa.",
+    "boundary_counterexamples": "Rank-r-minus-one Newton wrap correction; radix-3 kernel singular on a length-5 GF(4) cycle.",
+    "scope": "No impossibility claim for other adapters, suppliers or finite-field length restrictions. Selected frontier and inherited supplier profiles unchanged."
+  }
+}
diff --git a/research/dirty-echo-integration/PROOF.md b/research/dirty-echo-integration/PROOF.md
new file mode 100644
index 0000000000..9540138bf3
--- /dev/null
+++ b/research/dirty-echo-integration/PROOF.md
@@ -0,0 +1,243 @@
+# Full-transform and bit integration: an exact adapter with an unfavorable bill
+
+This note continues PR673 at `0e35f56cab3cae1eb0a99447135569d687c5695a`.
+Its result has two parts: an implemented functional adapter, and a rejection
+of **this adapter's** recursive cost as a source of a positive saving. It does
+not rule out other integrations of the echo mechanism or another supplier.
+The PR628 inverse and PR673 local cost improvement remain separate valid
+objects under their stated contracts.
+
+## 1. The interfaces that must be connected
+
+PR673 supplies an additive shear
+
+    E(A): (x,y,z) -> (x,y+A x,z),
+
+where z contains arbitrary borrowed data. A supplier for the recursive
+framework must instead apply its required operator to **every physical role**,
+including roles used as scratch in its scalar word. The complex endpoint is a
+product of C kernels on selected binary address positions; the bit endpoint
+is an interchange of two address chunks, acting on Boolean data.
+`upstream/03-motifs.tex`, `04-swap.tex` and `05-layers.tex` specify these
+contracts. Restoring a scratch role is insufficient when that role is owed
+its own endpoint transform.
+
+Let A be an invertible operator. Three shears, in execution order,
+
+    y += A x; x -= A^-1 y; y += A x
+
+send (x,y) to (-A^-1 y, A x). Exchanging the two roles and negating the
+second gives (A x,A^-1 y). Each shear is implemented with the same distinct
+borrowed pool, excluding both current pair roles, and restores that pool.
+No fresh zero array is assumed. Pair all W roles, with W even and at least
+two plus the echo's scratch depth. Process the pairs serially. A borrowed
+role may already have been transformed or may still contain its original
+value; the shear contract permits either, and restores it before proceeding.
+
+### Complex endpoint
+
+For the selected positions let A=C^tensor_d, with
+C=((1+i)I+(1-i)X)/2. From the retained identities,
+
+    A^-1 = gamma Z A Z,  gamma=(-i)^d,
+
+where Z is the product of sign changes on those positions. Before the three
+shears, replace y by Z y. After the exchange/negation, replace the second
+output by gamma^-1 Z times that output. The final pair is exactly (A x,A y).
+Both forward and inverse C leaves are implemented explicitly. For grouped
+positions of width f the same identity holds with d replaced by df; the
+inverse wrappers add no recursive children under the inherited interface.
+
+### Bit endpoint
+
+Let the address consist of H_1,...,H_d,D_1,...,D_d, with arbitrary other
+fields held fixed. Each A_i interchanges H_i and D_i. These permutations
+commute and are involutions, so A=product_i A_i satisfies A^-1=A.
+Over Boolean data subtraction equals addition. The same three shears followed
+by a role exchange therefore yield (A x,A y), without complex phases.
+The implemented tests use radix 3 or 5 with one digit per field. The identity
+is valid for arbitrary equal-length fields and spectators: it is an identity
+of commuting address permutations, not an interpolation from finite tests.
+
+`adapter.py` implements both endpoints, streams the additive leaf results,
+and uses scalar swaps for the role exchange. It needs no clean full-array
+output buffer. Its indexed source reads are explicit **reference operations**;
+they are not a free tape-routing primitive. Permutation tables used by the
+finite test are read-only test descriptions, not a claimed constant-size
+uniform machine description.
+
+## 2. Complete synthetic Fourier transform integration
+
+The multiplication framework's transform is over R_r=C[y]/(y^r+1), with
+power-of-two r. It uses normalized butterflies and signed coefficient
+permutations. It is not an ordinary complex DFT on independently approximated
+roots. `transform.py` implements the retained contract for axis lengths t_i
+that divide 2r, with M=product_i t_i.
+
+In each decimation-in-frequency round, one address position on each active
+axis is selected. The identity
+
+    H0^tensor_d = b^d S_d C^tensor_d S_d, b=(1-i)/2,
+
+converts the all-role C adapter to the normalized butterfly layer. At address
+x, S_d is the fourth-root phase i^(sum of selected bits). The grouped twiddle
+is multiplication of each polynomial record by
+
+    y^E, E = -sum_i (2r/u_i) b_i k_i mod 2r,
+
+where u_i is the current recursive axis length, b_i the selected branch bit
+and k_i its lower unprocessed bits. The monomial acts by a signed rotation of
+coefficients; the implementation cycles in place with one held scalar.
+
+The output stays in bit-reversed frequency order B. There is **no hidden
+frequency permutation** in the implementation. Reversing the rounds applies
+the inverse twiddle first and then the same normalized butterfly. Thus the
+two procedures implement B F-minus and F-plus B^-1, and their composite is
+I/M. A convolution uses two forward transforms, pointwise multiplication in
+R_r, then the opposite transform, followed by scaling by M². Both forward
+transforms and the opposite transform include a 1/M normalization; charging
+only a factor M would give the wrong answer. The direct convolution oracle
+checks the cyclic address wrap and the negacyclic coefficient wrap separately.
+
+The harness includes nonzero data on every role, entire input-basis checks
+for the all-role C adapter, full Boolean symbolic columns, and independent
+DFT/convolution definitions. No rounded numerical equality is used. Fraction
+arithmetic is a prototype, not a fixed-precision or fixed-tape implementation.
+
+For a simple exact resource bound, each C shear adds at most two source
+values, with dyadic coefficients of denominator 2, into one target. After J
+such leaves the common fractional-bit budget grows by at most J, while the
+joint max magnitude grows by less than 3^J. Phase, sign and role-exchange
+wrappers are isometries. The additional H0 factors add at most sum_round d
+fractional bits and are contractions. Signed twiddles add none. This gives
+a deliberately loose word budget
+
+    initial_fraction_bits + O(J + sum_round d + log(initial_norm+1)).
+
+This is an explicit bound for this exact prototype schedule. It does not
+establish the retained O(p) precision guard in the growing-parameter
+multiplication reduction. Preparation, source access and routing remain paid
+obligations. The cost rejection below already holds with all of them free.
+
+## 3. The complete recursive bill rejects this route
+
+Suppose d=n f selected coordinates are grouped into n groups of f. Let N(n)
+be the exact leaf count of one echo. There are three shears per pair and W/2
+pairs, so the complete all-role program invokes
+
+    L = 3 W N(n)/2
+
+additive leaves. Grant an optimistic oracle in which each additive leaf costs
+only **one** recursive child on f coordinates and one role of volume V/W.
+This is already more generous than the ordinary lowering: applying a child
+to the source, adding it to the target and undoing the child takes two child
+calls. Charge zero for the surrounding scalar operations, phases, role
+exchange, storage, preparation, routing and precision. These favorable
+omissions can only make admission easier.
+
+For a candidate exponent sigma=1-b, the normalized recurrence moment is
+
+    Phi(b) = (L/W) (1/n)^(1-b) = 3 N(n)/(2 n^(1-b)).
+
+Even Phi(0) must be below 1 to obtain a strict saving by this bill. The flat
+echo has N(n)=4n-4, giving
+
+    Phi(0) = 6 - 6/n >= 3, for n>=2.
+
+Recursive grouping does not improve this lower bound. First, induction gives
+N(t)>=2t-1: at an internal node each group is invoked at least twice and
+the number of groups is at most t. For an internal node with group sizes
+n_1,...,n_k, use 2N(n_i)>=4n_i-2 on each endpoint and 4N(n_i)>=4n_i on
+each interior group. Summing yields N(n)>=4n-4. Hence every fanout supported
+here has Phi(0)>=6-6/n. Since n>1, Phi(b) increases with b, so **every b>=0
+is rejected**. This is a lower bound on the cost of this specific all-role
+adapter, not an optimality theorem for arbitrary suppliers.
+
+The corresponding optimistic finite profile is H_1=L, m=n and W physical
+roles. Its deficit Wm-sum_j j H_j is negative. The same calculation applies
+to the Boolean and complex adapters. Borrowing more roles does not help:
+the W factor cancels because every role is owed an output transform.
+
+For example, a flat eight-factor shear needs 28 leaves and seven scratch
+roles. Taking W=10 roles, all outputs require 420 leaves, yielding moment
+420/(10*8)=5.25 at b=0. Pricing only the raw 28-leaf shear while counting ten
+completed outputs would give the false coefficient 28/80=0.35. The missing
+outputs are detected by the `skip_borrowed_outputs` functional control.
+
+Pointwise scalar shortening in an otherwise unchanged supplier likewise does
+not change its child histogram, recursive volume fractions or strict moment.
+It can improve constants or finite cutoffs. It cannot by itself be multiplied
+into κ. This experiment does not modify any accepted supplier's profile.
+
+## 4. Why the literal cyclic inverse is not an automatic replacement
+
+### The Newton factor is triangular
+
+In the pinned exact-DFT source, with h_j=1/product_(s=1)^j(1-u^s), the Newton
+factor is T=P(J_r), where J_r is the **nilpotent lower shift**. PR621/628 instead
+handle C=P(Z_L), a cyclic shift polynomial. For L=r, C-T is strictly upper
+triangular and every first-superdiagonal entry is h_(r-1)=1/r. Its rank is
+exactly r-1, as seen from rows 0 through r-2 and columns 1 through r-1.
+Where C is invertible, the inverse difference C^-1(C-T)T^-1 also has rank r-1.
+
+This identifies a missing boundary correction; rank alone is not a lower
+bound on all algorithms for this structured correction. At r=4, replacing T
+by C in the actual Newton factorization sends e_0 to
+
+    (13/16-i/16, 21/32+3i/32, 1/2+i/8, 1/4)
+
+instead of F_4 e_0=(1,1,1,1). `boundaries.py` checks both the correct full
+factorization and this counterexample exactly. The present functional adapter
+uses the correct retained C butterfly; it does not pretend that cyclic and
+triangular P operators agree.
+
+### Complex nonvanishing does not transfer to bit arithmetic
+
+Allow even a two-bit extension field GF(4)=GF(2)[u]/(u²+u+1). The primitive
+radix-3 kernel has nonzero preparation denominators and is
+
+    P(z)=1+u z+z².
+
+Nevertheless,
+
+    (1+u z+z²)(1+u z+u z²+z³)=1+z⁵.
+
+Thus on a length-5 cycle, the nonzero vector (1,u,u,1,0) lies in the kernel
+of P(S_5). Expanding each GF(4) value into two F2 coordinates preserves this
+counterexample. There is no inverse to implement on that domain.
+
+More generally, any nonconstant polynomial over a finite field with nonzero
+constant term has a nonzero root alpha in a finite extension. Its multiplicative
+order L is finite, so it shares a nonconstant factor with z^L-1. Multiplication
+by P modulo z^L-1 is therefore singular. This rules out the *all-cycle-length*
+finite-field analogue of the particular complex nonvanishing premise; it does
+not rule out restrictions on admissible lengths, another kernel, or bit
+address permutations. The Boolean adapter above works with permutations and
+makes no use of this invalid cyclic inverse.
+
+## 5. What a substantial κ improvement must change
+
+For the retained outer assembly, kappa < a/(1+a), with a below both supplier
+endpoints. Therefore kappa=0.01 requires **both** supplier savings above 1/99.
+The current pinned bit profile gives c≈0.0017334270. Its strict adjacent root
+bracket gives an upper outer ceiling below 0.001730427469824 even if the
+complex supplier ceases to bind. Scalar-call speedups do not alter this ceiling.
+
+`price.py` evaluates both pinned paid moments at the necessary rates for
+kappa 0.002, 0.005 and 0.01, retaining the bit fallback charge. At the 0.01
+target, uniformly scaling **every paid term**, with unchanged width and live
+volume, would need a reduction strictly exceeding about **2.6990784206%** on
+the bit side and **2.4734894761%** on the pinned PR659 complex side. These are
+optimistic diagnostic budget targets, not feasible fractional gate deletions
+or admitted replacement profiles. They identify the quantity a new construction
+must improve: the weighted recursive bill at the desired rate, including
+its physical hosting and fallback obligations.
+
+Credit: the OpenAI #109 integer-multiplication interfaces and pinned exact-DFT
+source; classical Newton/q-calculus sources credited by Ali Romman's #621;
+Chafik Boukhalfa's #628 leaf; PR673's echo schedule; DreamingOfClouds/eumemic and
+the retained #589 lineage; Jeremy Kothe's #659 and its source notices. The
+source-suppressed replay principle already appears in the pinned exact-DFT
+source's `loc:replay`, with Bennett and catalytic-space attribution. This
+continuation does not claim that general principle as new. Prepared for
+@androolloyd with substantial OpenAI Codex assistance, under Apache-2.0.
diff --git a/research/dirty-echo-integration/README.md b/research/dirty-echo-integration/README.md
new file mode 100644
index 0000000000..0eb39b9757
--- /dev/null
+++ b/research/dirty-echo-integration/README.md
@@ -0,0 +1,124 @@
+# Full-transform and bit-adapter experiment: functional success, no κ gain
+
+The requested integration is implemented as an exact reference experiment.
+The multiway echo can be wrapped to transform **every role**, then used in
+complete normalized synthetic Fourier transforms and Boolean address-chunk
+interchanges. The complete recursive bill rejects this direct adapter as a
+route to positive exponent saving—even with free routing and unusually cheap
+recursive leaves. The selected result and existing supplier profiles remain
+unchanged.
+
+[PROOF.md](PROOF.md) states the all-role identity, transform conventions, complete
+child recurrence, scoped cost rejection and two exact boundary counterexamples.
+This extends [PR673](https://github.com/CrocSwap/integer-mult-bounds/pull/673),
+whose local dirty inverse improvement remains independently reviewable.
+
+| Integration obligation | Result |
+|---|---|
+| Apply the complex kernel to every physical role | Exact adapter and all-input basis replay pass |
+| Apply the bit address interchange to every role | Exact symbolic Boolean replay passes |
+| Forward and opposite synthetic transforms | Stored order, signed polynomial twiddles and normalization pass |
+| Transform / pointwise product / opposite transform | Exact cyclic/negacyclic convolution passes |
+| Complete recursive supplier cost | Rejected: even optimistic moment is at least 3 at saving zero |
+| Replace triangular Newton factor by cyclic kernel | Rejected: explicit radix-4 wrong output; boundary rank r-1 |
+| Transfer complex cyclic conditioning to bit fields | Rejected: radix-3 kernel is singular on a length-5 GF(4) cycle |
+| New κ from this integration | None |
+
+## Reproduce
+
+Standard Python and the source tree at this PR are sufficient. No network,
+optional numerical library, compiler, optimizer or historical workspace is
+needed. From the repository root, with a new output directory:
+
+```sh
+sh research/dirty-echo-integration/replay.sh /tmp/dirty-echo-integration
+```
+
+Expected final line:
+
+```text
+PASS_INTEGRATION_EXPERIMENT_WITH_REJECTED_SUPPLIER_BILL
+```
+
+The cost rejection is a **passed negative research result**, not a passing
+supplier admission. The driver checks freshly produced deterministic evidence
+against [evidence/FUNCTIONAL.json](evidence/FUNCTIONAL.json) and
+[evidence/PRICE.json](evidence/PRICE.json). The functional checker also runs
+under `-I -O`; pricing deliberately refuses `-O` because it invokes an inherited
+assertion-based rational moment engine.
+
+The completed domain contains 168 complex all-input basis cases, 11,616
+symbolic Boolean output rows (covering every independent input bit), six
+complete transform/convolution configurations, 40 additional full-transform
+basis columns, 59 signed-rotation checks, 12 instruction/interface controls
+and six wrong-convolution-normalization controls. Tested transform axes are
+(2), (2,2), (4,2), (4,4), (8,2), and (4,2,2), with synthetic record widths 2
+or 4. Boolean address radices are 3 and 5, with one through three field pairs
+as explicitly listed in the checker. No random search or unreported early stop
+is involved. The general claims use the separate written identities, not
+extrapolation from these finite cases.
+
+## Why the earlier 12× call reduction does not become 12× κ
+
+One echo restores its borrowed roles. The recursive supplier owes those roles
+their own transforms. Completing every output requires three echo shears per
+pair of roles. With N(n) echo leaves and W roles, this is 3 W N(n)/2 leaves.
+Even granting one child per additive leaf, the normalized moment at saving
+zero is 3 N(n)/(2n), at least 6-6/n. It exceeds one for every n>=2.
+
+This closes the direct all-role echo route priced here. It does not establish
+a lower bound for every possible integration. The next useful mechanism must
+change the paid rank/volume profile or share work across roles so this bill
+no longer applies. A faster implementation of the same finite scalar word
+can improve constants and cutoffs without changing κ.
+
+For the pinned profiles, κ=0.01 would require both supplier savings above
+1/99. The bit supplier alone currently caps the outer saving below
+0.001730427469824. At the required 1/99 rate, diagnostic uniform reductions
+of the paid moments would need to exceed approximately **2.70% on the bit
+side and 2.47% on the complex side**. These percentages include the bit fallback
+term and are budget targets, not an admitted construction. The exact intervals
+and values at smaller targets are in PRICE.json. The complex comparison is
+against pinned PR659, not a claim about newer pending frontier proposals.
+
+## Scope, pins and attribution
+
+The adapters are indexed-read exact-arithmetic prototypes. They implement the
+finite operator and normalization contracts; they do not supply a fixed-tape
+compiler, a new physical hosting plan, an O(p) precision guard, or a revised
+finite supplier invoice. The optimistic cost already fails before those
+additional costs. No full bit-circuit rebuild, complete multiplication proof,
+practical runtime speedup or new κ is claimed.
+
+[SOURCES.json](SOURCES.json) binds the inherited echo, synthetic-transform
+contracts, kernel proof, supplier profiles and rational engines by SHA-256.
+Both checkers reject source drift. The exact primary Newton source is also
+identified by immutable commit and blob. Base PR673 commit:
+`0e35f56cab3cae1eb0a99447135569d687c5695a`; main base:
+`66849e1475c930fd7732b1a0067ffee7e1e95f60`.
+
+Credit the OpenAI integer-multiplication and exact-DFT preprints, their classical
+Newton/replay sources, Ali Romman (#621), Chafik Boukhalfa (#628), the credited
+DreamingOfClouds/eumemic bit lineage (#589), and Jeremy Kothe's complex witness
+(#659, with icekylinx and the owner/construction lineage). Their existing notices
+remain in force. Concurrent #677 treats a different native ADDRESS shear and
+query minimum; it is context, not a dependency. #670/#674 improve scalar XOR
+counts without changing the paid histogram, consistent with the distinction
+made here. The submission does not reopen their searches or claim their results.
+
+The final queue refresh also found Dillon Amburgey's
+[#689](https://github.com/CrocSwap/integer-mult-bounds/pull/689) at
+`0dedef12f05f9a06faf9d4e1c8b1462c0e3bff3a`, which refines balanced ternary
+block placement in the pinned PR673 echo without changing its scratch use.
+This package leaves that generator unchanged. The all-role cost lower bound
+allows any group ordering, so the local refinement does not remove this
+particular obstruction. Greer Guthrie's
+[#679](https://github.com/CrocSwap/integer-mult-bounds/pull/679) at
+`dce137e540acd2b689281afe222cd32c0ec1f1ae` separately prices selector-batched
+children with their joined volume. Neither proposal is a dependency of this
+adapter or its finite evidence. Queue inspected through #693; newer pending
+complex values are not substituted into the pinned comparison.
+
+Prepared for **@androolloyd with substantial OpenAI Codex assistance**.
+Apache-2.0. Independent arithmetic means distinct program paths, not independent
+human review or proof-assistant certification.
diff --git a/research/dirty-echo-integration/SOURCES.json b/research/dirty-echo-integration/SOURCES.json
new file mode 100644
index 0000000000..920b1a9992
--- /dev/null
+++ b/research/dirty-echo-integration/SOURCES.json
@@ -0,0 +1,30 @@
+{
+  "base_commit": "0e35f56cab3cae1eb0a99447135569d687c5695a",
+  "main_base": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a",
+  "pr621": "520774462b19b29af41554b74def31f9d01e997e",
+  "pr628": "0768f97d06c623b8211e651543c66135796b62bf",
+  "pr589": "a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46",
+  "pr659": "4982f0ca66ffe0960b5a6451deb5b66b1039326b",
+  "files": {
+    "research/cyclic-dirty-commutator-audit/echo.py": "63d44c48801f51720a7cc994d6b5e2e857d1aa4fae4c6b83c0cca032b3d9e13b",
+    "upstream/build/sections/03-motifs.tex": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb",
+    "upstream/build/sections/04-swap.tex": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906",
+    "upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594",
+    "upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c",
+    "research/prime-power-cyclic-inverse/PROOF.md": "2b8056c88e66f692f407450fff0414d41bcd09db8597be22e274a6c3dc20eb9e",
+    "research/prime-power-cyclic-inverse/SOURCE.json": "81217e4ecbb1da767d6a23f043d66e69d53c9001c056176efc641ddadea275f2",
+    "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4",
+    "research/e8-bit-p111-tuned/tune/README.md": "46c7917fb252949f38b7bcd88cf568efc282e3ea065b61d11e457e41673d0b2d",
+    "research/gauge44-notri-fine-grid/evidence/CERTIFICATE.json": "3f9f9b210dffcfdd98eabbb71b9b4ff71d292706d47114364a7b7036a0995c8f",
+    "research/complex-k492-owner-repair/vendor/multicold/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482",
+    "research/complex-k492-owner-repair/vendor/multicold/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c",
+    "certificates/selected-result.json": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53"
+  },
+  "exact_fourier_primary": {
+    "url": "https://github.com/openai/math/blob/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/An-explicit-power-saving-for-the-exact-discrete-Fourier-transform-September-25-2026/build/sections/local.tex",
+    "git_blob": "260a19bd8f7189afbe89b0af0508d979cd1e1ca6",
+    "sha256": "616e2707aabf2f7591a687331d4cb0f2fa486f92c3f7fe96a133b90faff60561",
+    "consumed_scope": "Newton factorization and source-suppressed dirty replay, read for the proof; no external file needed by replay."
+  }
+}
diff --git a/research/dirty-echo-integration/VALIDATION.json b/research/dirty-echo-integration/VALIDATION.json
new file mode 100644
index 0000000000..ecf73522db
--- /dev/null
+++ b/research/dirty-echo-integration/VALIDATION.json
@@ -0,0 +1,32 @@
+{
+  "verified_at_utc": "2026-10-13T04:21:19.604732+00:00",
+  "python": "3.14.7",
+  "platform": "Darwin",
+  "base_commit": "0e35f56cab3cae1eb0a99447135569d687c5695a",
+  "status": "PASS_FUNCTIONAL_INTEGRATION_AND_SCOPED_COST_REJECTION",
+  "checks": {
+    "standalone_replay": "PASS_INTEGRATION_EXPERIMENT_WITH_REJECTED_SUPPLIER_BILL",
+    "combined_replay": "PASS_DIRTY_ECHO_ALIAS_REPAIR_AND_FINE_GRID",
+    "normal_vs_isolated_optimized_functional_receipt": "byte-identical",
+    "relocated_minimal_checkout": "pass, only this package plus pinned inherited files",
+    "changed_source_pin": "rejected by each checker before evidence output",
+    "corrupted_expected_evidence": "rejected by replay comparison",
+    "optimized_price": "rejected before evidence output; inherited engine requires assertions",
+    "selected_record_integrity": "pass",
+    "unchanged_upstream_and_supplier_profiles": "pass against base commit",
+    "python_syntax_and_local_links": "pass",
+    "staged_whitespace": "pass"
+  },
+  "combined_replay_log_sha256": "2f439aed625d38fb17e55af09253c68394b519e6277e93fb8e2114b2a0ef4367",
+  "evidence_sha256": {
+    "FUNCTIONAL.json": "be304fe069b9497f5572617a13a3e0d0e86cf4b2684ec66171db5555780cc3d4",
+    "PRICE.json": "dc58557b766b0125268e761f807e9b1ccb709eaf0b185f2d1f8d9a79e9806ea9"
+  },
+  "not_claimed": [
+    "New kappa or admitted supplier",
+    "Fresh full bit-circuit reconstruction",
+    "Root-wide make verify or remote CI",
+    "Fixed-tape execution or all-size O(p) precision guard",
+    "Formal verification of multiplication theorem"
+  ]
+}
diff --git a/research/dirty-echo-integration/adapter.py b/research/dirty-echo-integration/adapter.py
new file mode 100644
index 0000000000..313150481d
--- /dev/null
+++ b/research/dirty-echo-integration/adapter.py
@@ -0,0 +1,126 @@
+"""All-role adapters for the PR673 echo; mathematical prototypes, not tape code.
+
+Prepared for @androolloyd with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+from fractions import Fraction as F
+import importlib.util
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+spec = importlib.util.spec_from_file_location('integration_echo', HERE.parent/'cyclic-dirty-commutator-audit/echo.py')
+E = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(E)
+ZERO=(F(0),F(0)); ONE=(F(1),F(0)); I=(F(0),F(1))
+A=(F(1,2),F(1,2)); B=(F(1,2),F(-1,2))
+
+
+def need(ok,message):
+    if not ok:
+        raise ValueError(message)
+
+
+def add(x,y): return x[0]+y[0],x[1]+y[1]
+def neg(x): return -x[0],-x[1]
+def scale(x,q): return x[0]*q,x[1]*q
+def mul(x,y): return x[0]*y[0]-x[1]*y[1],x[0]*y[1]+x[1]*y[0]
+def ipow(n): return (ONE,I,neg(ONE),neg(I))[n%4]
+
+
+def role_count(factors,fanout):
+    depth,_=E.resources(factors,fanout)
+    return 2*((depth+3)//2)
+
+
+def echo_shear(arrays,source,target,factors,leaf,plus,times_sign,fanout=8,sign=1,mutant=None):
+    """Translate one target by a composed linear map; restore all other roles.
+
+    A leaf streams its output from a distinct, unchanged source array. The
+    prototype uses indexed reads; their tape routing is not silently free.
+    """
+    need(source!=target and len({id(x) for x in arrays})==len(arrays),'distinct arrays')
+    depth,N=E.resources(len(factors),fanout)
+    scratch=[i for i in range(len(arrays)) if i not in (source,target)][:depth]
+    need(len(scratch)==depth,'insufficient borrowed roles')
+    local=[source,target]+scratch
+    calls=0
+    for s,t,index,q in E.instructions(0,len(factors),0,1,2,fanout,sign):
+        if mutant=='omit_negative_leaf' and q==-1:
+            continue
+        values=leaf(arrays[local[s]],factors[index])
+        dst=arrays[local[t]]
+        seen=0
+        for j,value in enumerate(values):
+            need(j<len(dst),'leaf shape')
+            dst[j]=plus(dst[j],times_sign(value,q))
+            seen+=1
+        need(seen==len(dst),'leaf shape')
+        calls+=1
+    if mutant is None:
+        need(calls==N,'echo leaf accounting')
+    return calls
+
+
+def complex_layer(arrays,selected_bits,record_width,fanout=8,mutant=None):
+    """Apply C tensor selected bits to EVERY role, including borrowed roles."""
+    need(len({id(row) for row in arrays})==len(arrays),'distinct arrays')
+    selected_bits=tuple(selected_bits)
+    need(selected_bits and len(set(selected_bits))==len(selected_bits),'distinct selected bits')
+    need(len(arrays)%2==0 and len(arrays)>=role_count(len(selected_bits),fanout),'even sufficient roles')
+    masks=[1<<bit for bit in selected_bits]
+    n=len(arrays[0]);need(n%record_width==0,'record shape')
+    need(all(len(row)==n for row in arrays) and max(masks)<n//record_width,'layer extent')
+    factors=[(mask,False) for mask in masks]
+    inverse=[(mask,True) for mask in reversed(masks)]
+    def parity(index): return sum(bool((index//record_width)&mask) for mask in masks)%2
+    def leaf(row,factor):
+        mask,inv=factor;a,b=(B,A) if inv else (A,B)
+        return (add(mul(a,row[j]),mul(b,row[((j//record_width)^mask)*record_width+j%record_width])) for j in range(n))
+    calls=0
+    pairs=range(0,len(arrays),2) if mutant!='skip_borrowed_outputs' else (0,)
+    for x in pairs:
+        y=x+1
+        # A^-1 = gamma Z A Z, gamma=(-i)^D. Pre-Z on the second role
+        # and gamma^-1 Z after the block rotation turn both outputs into A.
+        for j,v in enumerate(arrays[y]):
+            arrays[y][j]=scale(v,-1 if parity(j) else 1)
+        calls+=echo_shear(arrays,x,y,factors,leaf,add,scale,fanout,mutant=mutant)
+        calls+=echo_shear(arrays,y,x,inverse,leaf,add,scale,fanout,-1,mutant)
+        calls+=echo_shear(arrays,x,y,factors,leaf,add,scale,fanout,mutant=mutant)
+        if mutant!='omit_role_exchange':
+            for j in range(n):
+                old=arrays[x][j];arrays[x][j]=arrays[y][j];arrays[y][j]=neg(old)
+        gamma_inverse=ipow(len(masks)) if mutant!='omit_inverse_phase' else ONE
+        for j,v in enumerate(arrays[y]):
+            arrays[y][j]=mul(gamma_inverse,scale(v,-1 if parity(j) else 1))
+    return dict(roles=len(arrays),factors=len(masks),leaf_calls=calls,optimistic_child_calls=calls)
+
+
+def boolean_layer(arrays,permutations,fanout=8,mutant=None):
+    """Apply an involutive address permutation product to every bit-data role.
+
+    The given factors must commute and square to identity, as disjoint swaps do.
+    Bit data are Python integers interpreted as independent F2 basis coefficients.
+    """
+    need(len({id(row) for row in arrays})==len(arrays),'distinct arrays')
+    need(len(arrays)%2==0 and len(arrays)>=role_count(len(permutations),fanout),'even sufficient roles')
+    n=len(arrays[0]);need(all(len(row)==n for row in arrays),'bit shape')
+    for p in permutations:
+        need(len(p)==n and sorted(p)==list(range(n)),'permutation')
+        need(all(p[p[j]]==j for j in range(n)),'involutive factor')
+    for p in permutations:
+        for q in permutations:
+            need(all(p[q[j]]==q[p[j]] for j in range(n)),'commuting factors')
+    leaf=lambda row,p:(row[p[j]] for j in range(n))
+    plus=lambda a,b:a^b
+    times_sign=lambda value,sign:value
+    calls=0
+    pairs=range(0,len(arrays),2) if mutant!='skip_borrowed_outputs' else (0,)
+    for x in pairs:
+        y=x+1
+        calls+=echo_shear(arrays,x,y,permutations,leaf,plus,times_sign,fanout,mutant=mutant)
+        calls+=echo_shear(arrays,y,x,permutations,leaf,plus,times_sign,fanout,-1,mutant)
+        calls+=echo_shear(arrays,x,y,permutations,leaf,plus,times_sign,fanout,mutant=mutant)
+        if mutant!='omit_role_exchange':
+            for j in range(n):
+                arrays[x][j],arrays[y][j]=arrays[y][j],arrays[x][j]
+    return dict(roles=len(arrays),factors=len(permutations),leaf_calls=calls,optimistic_child_calls=calls)
diff --git a/research/dirty-echo-integration/boundaries.py b/research/dirty-echo-integration/boundaries.py
new file mode 100644
index 0000000000..599f0ac0b6
--- /dev/null
+++ b/research/dirty-echo-integration/boundaries.py
@@ -0,0 +1,104 @@
+"""Exact counterexamples to two tempting but invalid integration shortcuts."""
+from fractions import Fraction as Q
+import importlib.util
+from pathlib import Path
+
+spec=importlib.util.spec_from_file_location('boundary_oracles',Path(__file__).with_name('oracles.py'))
+O=importlib.util.module_from_spec(spec);spec.loader.exec_module(O)
+ZERO=O.ZERO;ONE=O.ONE
+
+
+def need(ok,message):
+    if not ok:raise ValueError(message)
+
+
+def inv(z):
+    norm=z[0]*z[0]+z[1]*z[1];need(norm!=0,'nonzero Gaussian denominator')
+    return z[0]/norm,-z[1]/norm
+
+
+def matmul(a,b):
+    return [[sum_pairs(O.mul(x,y) for x,y in zip(row,column)) for column in zip(*b)] for row in a]
+
+
+def sum_pairs(values):
+    result=ZERO
+    for value in values:result=O.add(result,value)
+    return result
+
+
+def matrix_rank(a):
+    a=[row[:] for row in a];rank=0
+    for column in range(len(a[0])):
+        pivot=next((i for i in range(rank,len(a)) if a[i][column]!=ZERO),None)
+        if pivot is None:continue
+        a[rank],a[pivot]=a[pivot],a[rank];v=inv(a[rank][column]);a[rank]=[O.mul(v,z) for z in a[rank]]
+        for i in range(len(a)):
+            if i==rank:continue
+            coefficient=a[i][column]
+            a[i]=[O.add(x,O.scale(O.mul(coefficient,y),-1)) for x,y in zip(a[i],a[rank])]
+        rank+=1
+    return rank
+
+
+def newton_boundary():
+    r=4;u=(Q(0),Q(1));powers=[ONE]
+    for _ in range(r):powers.append(O.mul(powers[-1],u))
+    H=[ONE]
+    for j in range(1,r):H.append(O.mul(H[-1],O.add(ONE,O.scale(powers[j],-1))))
+    h=[inv(z) for z in H]
+    triangular=[[h[i-j] if i>=j else ZERO for j in range(r)] for i in range(r)]
+    cyclic=[[h[(i-j)%r] for j in range(r)] for i in range(r)]
+    diagonal=[O.scale(powers[(i*(i-1)//2)%r],(-1)**i) for i in range(r)]
+    def assembled(kernel):
+        N=[[O.mul(O.mul(H[i],kernel[i][j]),diagonal[j]) for j in range(r)] for i in range(r)]
+        Dinv=[[inv(O.mul(H[i],diagonal[i])) if i==j else ZERO for j in range(r)] for i in range(r)]
+        return matmul(matmul(N,Dinv),list(map(list,zip(*N))))
+    fourier=[[powers[(i*j)%r] for j in range(r)] for i in range(r)]
+    correct=assembled(triangular);wrong=assembled(cyclic)
+    difference=[[O.add(c,O.scale(t,-1)) for c,t in zip(crow,trow)] for crow,trow in zip(cyclic,triangular)]
+    need(correct==fourier,'Newton reconstruction')
+    need(wrong!=fourier,'invalid cyclic substitution undetected')
+    need(matrix_rank(difference)==r-1,'wrap boundary rank')
+    witness=next(j for j in range(r) if [row[j] for row in wrong]!=[row[j] for row in fourier])
+    return dict(radix=r,triangular_reconstruction_exact=True,cyclic_replacement_rejected=True,wrap_correction_rank=matrix_rank(difference),
+                witness_basis_column=witness,expected=[row[witness] for row in fourier],invalid_cyclic_output=[row[witness] for row in wrong],
+                general_observation='P(Z_r)-P(J_r) is strictly upper triangular, with every first-superdiagonal entry h_(r-1)=1/r. Its rank is r-1 for every r>=2 in characteristic zero.')
+
+
+def gf4_mul(x,y):
+    result=0
+    for _ in range(2):
+        if y&1:result^=x
+        y>>=1;x<<=1
+        if x&4:x^=7
+    return result
+
+
+def gf4_poly_product(a,b):
+    out=[0]*(len(a)+len(b)-1)
+    for i,x in enumerate(a):
+        for j,y in enumerate(b):out[i+j]^=gf4_mul(x,y)
+    return out
+
+
+def bit_field_boundary():
+    # GF(4)=GF(2)[u]/(u^2+u+1); encodings 0,1,u,u+1 are 0,1,2,3.
+    u=2
+    need(gf4_mul(u,u)==u^1 and gf4_mul(gf4_mul(u,u),u)==1,'primitive cube root')
+    h1=next(x for x in range(1,4) if gf4_mul(1^u,x)==1)
+    denominator=gf4_mul(1^u,1^gf4_mul(u,u))
+    h2=next(x for x in range(1,4) if gf4_mul(denominator,x)==1)
+    P=[1,h1,h2];R=[1,u,u,1]
+    need(P==[1,u,1] and gf4_poly_product(P,R)==[1,0,0,0,0,1],'exact finite-field factor identity')
+    vector=R+[0];image=[0]*5
+    for j,coefficient in enumerate(P):
+        for i,value in enumerate(vector):image[(i+j)%5]^=gf4_mul(coefficient,value)
+    need(any(vector) and not any(image),'singular length-five cyclic inverse')
+    # Expanding every GF(4) value into two F2 coordinates gives a Boolean
+    # singular operator as well. Check that the nonzero witness survives it.
+    binary_vector=[(value>>bit)&1 for value in vector for bit in (0,1)]
+    need(any(binary_vector),'nonzero Boolean encoding')
+    return dict(field='GF(2)[u]/(u^2+u+1)',encoding={'1':1,'u':2,'u+1':3},radix=3,cyclic_length=5,
+                kernel=P,quotient=R,polynomial_product=gf4_poly_product(P,R),nonzero_kernel_vector=vector,image=image,
+                binary_kernel_vector=binary_vector,verdict='P(S_5) is singular despite primitive radix-3 phase and nonzero preparation denominators. Complex unit-circle nonvanishing does not transfer to Boolean arithmetic through this field.')
diff --git a/research/dirty-echo-integration/evidence/FUNCTIONAL.json b/research/dirty-echo-integration/evidence/FUNCTIONAL.json
new file mode 100644
index 0000000000..17cdee335f
--- /dev/null
+++ b/research/dirty-echo-integration/evidence/FUNCTIONAL.json
@@ -0,0 +1,323 @@
+{
+  "status": "PASS_FUNCTIONAL_ECHO_INTEGRATION",
+  "inherited_source_hashes": {
+    "research/cyclic-dirty-commutator-audit/echo.py": "63d44c48801f51720a7cc994d6b5e2e857d1aa4fae4c6b83c0cca032b3d9e13b",
+    "upstream/build/sections/03-motifs.tex": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb",
+    "upstream/build/sections/04-swap.tex": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906",
+    "upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594",
+    "upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c",
+    "research/prime-power-cyclic-inverse/PROOF.md": "2b8056c88e66f692f407450fff0414d41bcd09db8597be22e274a6c3dc20eb9e",
+    "research/prime-power-cyclic-inverse/SOURCE.json": "81217e4ecbb1da767d6a23f043d66e69d53c9001c056176efc641ddadea275f2",
+    "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4",
+    "research/e8-bit-p111-tuned/tune/README.md": "46c7917fb252949f38b7bcd88cf568efc282e3ea065b61d11e457e41673d0b2d",
+    "research/gauge44-notri-fine-grid/evidence/CERTIFICATE.json": "3f9f9b210dffcfdd98eabbb71b9b4ff71d292706d47114364a7b7036a0995c8f",
+    "research/complex-k492-owner-repair/vendor/multicold/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482",
+    "research/complex-k492-owner-repair/vendor/multicold/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c",
+    "certificates/selected-result.json": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53"
+  },
+  "complex": {
+    "basis_cases": 168,
+    "leaf_executions": 5784
+  },
+  "bit": {
+    "symbolic_output_rows": 11616,
+    "cases": [
+      {
+        "radix": 3,
+        "groups": 1,
+        "fanout": 2,
+        "independent_input_bits": 18,
+        "roles": 2,
+        "factors": 1,
+        "leaf_calls": 3,
+        "optimistic_child_calls": 3
+      },
+      {
+        "radix": 3,
+        "groups": 1,
+        "fanout": 8,
+        "independent_input_bits": 18,
+        "roles": 2,
+        "factors": 1,
+        "leaf_calls": 3,
+        "optimistic_child_calls": 3
+      },
+      {
+        "radix": 3,
+        "groups": 2,
+        "fanout": 2,
+        "independent_input_bits": 324,
+        "roles": 4,
+        "factors": 2,
+        "leaf_calls": 24,
+        "optimistic_child_calls": 24
+      },
+      {
+        "radix": 3,
+        "groups": 2,
+        "fanout": 8,
+        "independent_input_bits": 324,
+        "roles": 4,
+        "factors": 2,
+        "leaf_calls": 24,
+        "optimistic_child_calls": 24
+      },
+      {
+        "radix": 3,
+        "groups": 3,
+        "fanout": 2,
+        "independent_input_bits": 2916,
+        "roles": 4,
+        "factors": 3,
+        "leaf_calls": 60,
+        "optimistic_child_calls": 60
+      },
+      {
+        "radix": 3,
+        "groups": 3,
+        "fanout": 8,
+        "independent_input_bits": 2916,
+        "roles": 4,
+        "factors": 3,
+        "leaf_calls": 48,
+        "optimistic_child_calls": 48
+      },
+      {
+        "radix": 5,
+        "groups": 1,
+        "fanout": 2,
+        "independent_input_bits": 50,
+        "roles": 2,
+        "factors": 1,
+        "leaf_calls": 3,
+        "optimistic_child_calls": 3
+      },
+      {
+        "radix": 5,
+        "groups": 1,
+        "fanout": 8,
+        "independent_input_bits": 50,
+        "roles": 2,
+        "factors": 1,
+        "leaf_calls": 3,
+        "optimistic_child_calls": 3
+      },
+      {
+        "radix": 5,
+        "groups": 2,
+        "fanout": 2,
+        "independent_input_bits": 2500,
+        "roles": 4,
+        "factors": 2,
+        "leaf_calls": 24,
+        "optimistic_child_calls": 24
+      },
+      {
+        "radix": 5,
+        "groups": 2,
+        "fanout": 8,
+        "independent_input_bits": 2500,
+        "roles": 4,
+        "factors": 2,
+        "leaf_calls": 24,
+        "optimistic_child_calls": 24
+      }
+    ]
+  },
+  "transforms": {
+    "cases": [
+      {
+        "axes": [
+          2
+        ],
+        "record_width": 2,
+        "opposite": false,
+        "rounds": 1,
+        "all_role_layer_records": [
+          {
+            "roles": 2,
+            "factors": 1,
+            "leaf_calls": 3,
+            "optimistic_child_calls": 3
+          }
+        ],
+        "echo_leaves": 3,
+        "source_component_reads": 24,
+        "target_component_reads": 12,
+        "leaf_component_writes": 12,
+        "adapter_and_butterfly_component_writes": 32,
+        "twiddle_component_writes": 8,
+        "tape_scope": "Indexed-read reference only. Routing, coefficient bit lengths and a fixed-tape implementation are not discharged."
+      },
+      {
+        "axes": [
+          2,
+          2
+        ],
+        "record_width": 2,
+        "opposite": false,
+        "rounds": 1,
+        "all_role_layer_records": [
+          {
+            "roles": 4,
+            "factors": 2,
+            "leaf_calls": 24,
+            "optimistic_child_calls": 24
+          }
+        ],
+        "echo_leaves": 24,
+        "source_component_reads": 384,
+        "target_component_reads": 192,
+        "leaf_component_writes": 192,
+        "adapter_and_butterfly_component_writes": 128,
+        "twiddle_component_writes": 32,
+        "tape_scope": "Indexed-read reference only. Routing, coefficient bit lengths and a fixed-tape implementation are not discharged."
+      },
+      {
+        "axes": [
+          4,
+          2
+        ],
+        "record_width": 2,
+        "opposite": false,
+        "rounds": 2,
+        "all_role_layer_records": [
+          {
+            "roles": 4,
+            "factors": 2,
+            "leaf_calls": 24,
+            "optimistic_child_calls": 24
+          },
+          {
+            "roles": 4,
+            "factors": 1,
+            "leaf_calls": 6,
+            "optimistic_child_calls": 6
+          }
+        ],
+        "echo_leaves": 30,
+        "source_component_reads": 960,
+        "target_component_reads": 480,
+        "leaf_component_writes": 480,
+        "adapter_and_butterfly_component_writes": 512,
+        "twiddle_component_writes": 128,
+        "tape_scope": "Indexed-read reference only. Routing, coefficient bit lengths and a fixed-tape implementation are not discharged."
+      },
+      {
+        "axes": [
+          4,
+          4
+        ],
+        "record_width": 2,
+        "opposite": false,
+        "rounds": 2,
+        "all_role_layer_records": [
+          {
+            "roles": 4,
+            "factors": 2,
+            "leaf_calls": 24,
+            "optimistic_child_calls": 24
+          },
+          {
+            "roles": 4,
+            "factors": 2,
+            "leaf_calls": 24,
+            "optimistic_child_calls": 24
+          }
+        ],
+        "echo_leaves": 48,
+        "source_component_reads": 3072,
+        "target_component_reads": 1536,
+        "leaf_component_writes": 1536,
+        "adapter_and_butterfly_component_writes": 1024,
+        "twiddle_component_writes": 256,
+        "tape_scope": "Indexed-read reference only. Routing, coefficient bit lengths and a fixed-tape implementation are not discharged."
+      },
+      {
+        "axes": [
+          8,
+          2
+        ],
+        "record_width": 4,
+        "opposite": false,
+        "rounds": 3,
+        "all_role_layer_records": [
+          {
+            "roles": 4,
+            "factors": 2,
+            "leaf_calls": 24,
+            "optimistic_child_calls": 24
+          },
+          {
+            "roles": 4,
+            "factors": 1,
+            "leaf_calls": 6,
+            "optimistic_child_calls": 6
+          },
+          {
+            "roles": 4,
+            "factors": 1,
+            "leaf_calls": 6,
+            "optimistic_child_calls": 6
+          }
+        ],
+        "echo_leaves": 36,
+        "source_component_reads": 4608,
+        "target_component_reads": 2304,
+        "leaf_component_writes": 2304,
+        "adapter_and_butterfly_component_writes": 3072,
+        "twiddle_component_writes": 768,
+        "tape_scope": "Indexed-read reference only. Routing, coefficient bit lengths and a fixed-tape implementation are not discharged."
+      },
+      {
+        "axes": [
+          4,
+          2,
+          2
+        ],
+        "record_width": 2,
+        "opposite": false,
+        "rounds": 2,
+        "all_role_layer_records": [
+          {
+            "roles": 4,
+            "factors": 3,
+            "leaf_calls": 48,
+            "optimistic_child_calls": 48
+          },
+          {
+            "roles": 4,
+            "factors": 1,
+            "leaf_calls": 6,
+            "optimistic_child_calls": 6
+          }
+        ],
+        "echo_leaves": 54,
+        "source_component_reads": 3456,
+        "target_component_reads": 1728,
+        "leaf_component_writes": 1728,
+        "adapter_and_butterfly_component_writes": 1024,
+        "twiddle_component_writes": 256,
+        "tape_scope": "Indexed-read reference only. Routing, coefficient bit lengths and a fixed-tape implementation are not discharged."
+      }
+    ],
+    "additional_basis_columns": 40,
+    "signed_rotation_checks": 59,
+    "wrong_convolution_scale_rejected_cases": 6
+  },
+  "negative_controls": [
+    "complex:omit_negative_leaf",
+    "complex:skip_borrowed_outputs",
+    "complex:omit_role_exchange",
+    "complex:omit_inverse_phase",
+    "bit:omit_negative_leaf",
+    "bit:skip_borrowed_outputs",
+    "bit:omit_role_exchange",
+    "transform:omit_normalization",
+    "transform:reverse_twiddle_sign",
+    "complex:role_alias",
+    "bit:role_alias",
+    "full_transform:role_alias"
+  ],
+  "scope": "Exact finite functional adapters and full stored-order synthetic transforms. These are indexed-read prototypes, not admitted fixed-tape suppliers or a new kappa."
+}
diff --git a/research/dirty-echo-integration/evidence/PRICE.json b/research/dirty-echo-integration/evidence/PRICE.json
new file mode 100644
index 0000000000..4856e744ea
--- /dev/null
+++ b/research/dirty-echo-integration/evidence/PRICE.json
@@ -0,0 +1,522 @@
+{
+  "status": "REJECT_DIRECT_ECHO_SUPPLIER_NO_KAPPA_GAIN",
+  "inherited_source_hashes": {
+    "research/cyclic-dirty-commutator-audit/echo.py": "63d44c48801f51720a7cc994d6b5e2e857d1aa4fae4c6b83c0cca032b3d9e13b",
+    "upstream/build/sections/03-motifs.tex": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb",
+    "upstream/build/sections/04-swap.tex": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906",
+    "upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594",
+    "upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c",
+    "research/prime-power-cyclic-inverse/PROOF.md": "2b8056c88e66f692f407450fff0414d41bcd09db8597be22e274a6c3dc20eb9e",
+    "research/prime-power-cyclic-inverse/SOURCE.json": "81217e4ecbb1da767d6a23f043d66e69d53c9001c056176efc641ddadea275f2",
+    "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4",
+    "research/e8-bit-p111-tuned/tune/README.md": "46c7917fb252949f38b7bcd88cf568efc282e3ea065b61d11e457e41673d0b2d",
+    "research/gauge44-notri-fine-grid/evidence/CERTIFICATE.json": "3f9f9b210dffcfdd98eabbb71b9b4ff71d292706d47114364a7b7036a0995c8f",
+    "research/complex-k492-owner-repair/vendor/multicold/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482",
+    "research/complex-k492-owner-repair/vendor/multicold/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c",
+    "certificates/selected-result.json": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53"
+  },
+  "adapter_profiles": [
+    {
+      "factors": 2,
+      "fanout": 2,
+      "roles": 4,
+      "borrowed_depth": 1,
+      "echo_leaves": 4,
+      "optimistic_one_call_leaf_children": 24,
+      "profile": {
+        "1": 24
+      },
+      "rank_mass": 24,
+      "rank_deficit": -16,
+      "moment_at_saving_zero": "3",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 2,
+      "fanout": 8,
+      "roles": 4,
+      "borrowed_depth": 1,
+      "echo_leaves": 4,
+      "optimistic_one_call_leaf_children": 24,
+      "profile": {
+        "1": 24
+      },
+      "rank_mass": 24,
+      "rank_deficit": -16,
+      "moment_at_saving_zero": "3",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 3,
+      "fanout": 2,
+      "roles": 4,
+      "borrowed_depth": 2,
+      "echo_leaves": 10,
+      "optimistic_one_call_leaf_children": 60,
+      "profile": {
+        "1": 60
+      },
+      "rank_mass": 60,
+      "rank_deficit": -48,
+      "moment_at_saving_zero": "5",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 3,
+      "fanout": 3,
+      "roles": 4,
+      "borrowed_depth": 2,
+      "echo_leaves": 8,
+      "optimistic_one_call_leaf_children": 48,
+      "profile": {
+        "1": 48
+      },
+      "rank_mass": 48,
+      "rank_deficit": -36,
+      "moment_at_saving_zero": "4",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 3,
+      "fanout": 8,
+      "roles": 4,
+      "borrowed_depth": 2,
+      "echo_leaves": 8,
+      "optimistic_one_call_leaf_children": 48,
+      "profile": {
+        "1": 48
+      },
+      "rank_mass": 48,
+      "rank_deficit": -36,
+      "moment_at_saving_zero": "4",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 4,
+      "fanout": 2,
+      "roles": 4,
+      "borrowed_depth": 2,
+      "echo_leaves": 16,
+      "optimistic_one_call_leaf_children": 96,
+      "profile": {
+        "1": 96
+      },
+      "rank_mass": 96,
+      "rank_deficit": -80,
+      "moment_at_saving_zero": "6",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 4,
+      "fanout": 4,
+      "roles": 6,
+      "borrowed_depth": 3,
+      "echo_leaves": 12,
+      "optimistic_one_call_leaf_children": 108,
+      "profile": {
+        "1": 108
+      },
+      "rank_mass": 108,
+      "rank_deficit": -84,
+      "moment_at_saving_zero": "9/2",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 4,
+      "fanout": 8,
+      "roles": 6,
+      "borrowed_depth": 3,
+      "echo_leaves": 12,
+      "optimistic_one_call_leaf_children": 108,
+      "profile": {
+        "1": 108
+      },
+      "rank_mass": 108,
+      "rank_deficit": -84,
+      "moment_at_saving_zero": "9/2",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 8,
+      "fanout": 2,
+      "roles": 6,
+      "borrowed_depth": 3,
+      "echo_leaves": 64,
+      "optimistic_one_call_leaf_children": 576,
+      "profile": {
+        "1": 576
+      },
+      "rank_mass": 576,
+      "rank_deficit": -528,
+      "moment_at_saving_zero": "12",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 8,
+      "fanout": 8,
+      "roles": 10,
+      "borrowed_depth": 7,
+      "echo_leaves": 28,
+      "optimistic_one_call_leaf_children": 420,
+      "profile": {
+        "1": 420
+      },
+      "rank_mass": 420,
+      "rank_deficit": -340,
+      "moment_at_saving_zero": "21/4",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 16,
+      "fanout": 2,
+      "roles": 6,
+      "borrowed_depth": 4,
+      "echo_leaves": 256,
+      "optimistic_one_call_leaf_children": 2304,
+      "profile": {
+        "1": 2304
+      },
+      "rank_mass": 2304,
+      "rank_deficit": -2208,
+      "moment_at_saving_zero": "24",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 16,
+      "fanout": 8,
+      "roles": 10,
+      "borrowed_depth": 8,
+      "echo_leaves": 112,
+      "optimistic_one_call_leaf_children": 1680,
+      "profile": {
+        "1": 1680
+      },
+      "rank_mass": 1680,
+      "rank_deficit": -1520,
+      "moment_at_saving_zero": "21/2",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 16,
+      "fanout": 16,
+      "roles": 18,
+      "borrowed_depth": 15,
+      "echo_leaves": 60,
+      "optimistic_one_call_leaf_children": 1620,
+      "profile": {
+        "1": 1620
+      },
+      "rank_mass": 1620,
+      "rank_deficit": -1332,
+      "moment_at_saving_zero": "45/8",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 64,
+      "fanout": 2,
+      "roles": 8,
+      "borrowed_depth": 6,
+      "echo_leaves": 4096,
+      "optimistic_one_call_leaf_children": 49152,
+      "profile": {
+        "1": 49152
+      },
+      "rank_mass": 49152,
+      "rank_deficit": -48640,
+      "moment_at_saving_zero": "96",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 64,
+      "fanout": 8,
+      "roles": 16,
+      "borrowed_depth": 14,
+      "echo_leaves": 784,
+      "optimistic_one_call_leaf_children": 18816,
+      "profile": {
+        "1": 18816
+      },
+      "rank_mass": 18816,
+      "rank_deficit": -17792,
+      "moment_at_saving_zero": "147/8",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 64,
+      "fanout": 64,
+      "roles": 66,
+      "borrowed_depth": 63,
+      "echo_leaves": 252,
+      "optimistic_one_call_leaf_children": 24948,
+      "profile": {
+        "1": 24948
+      },
+      "rank_mass": 24948,
+      "rank_deficit": -20724,
+      "moment_at_saving_zero": "189/32",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 512,
+      "fanout": 2,
+      "roles": 12,
+      "borrowed_depth": 9,
+      "echo_leaves": 262144,
+      "optimistic_one_call_leaf_children": 4718592,
+      "profile": {
+        "1": 4718592
+      },
+      "rank_mass": 4718592,
+      "rank_deficit": -4712448,
+      "moment_at_saving_zero": "768",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 512,
+      "fanout": 8,
+      "roles": 24,
+      "borrowed_depth": 21,
+      "echo_leaves": 21952,
+      "optimistic_one_call_leaf_children": 790272,
+      "profile": {
+        "1": 790272
+      },
+      "rank_mass": 790272,
+      "rank_deficit": -777984,
+      "moment_at_saving_zero": "1029/16",
+      "all_nonnegative_savings_rejected": true
+    },
+    {
+      "factors": 512,
+      "fanout": 512,
+      "roles": 514,
+      "borrowed_depth": 511,
+      "echo_leaves": 2044,
+      "optimistic_one_call_leaf_children": 1575924,
+      "profile": {
+        "1": 1575924
+      },
+      "rank_mass": 1575924,
+      "rank_deficit": -1312756,
+      "moment_at_saving_zero": "1533/256",
+      "all_nonnegative_savings_rejected": true
+    }
+  ],
+  "omission_control": {
+    "false_raw_shear_coefficient": "7/20",
+    "complete_all_role_coefficient": "21/4"
+  },
+  "unchanged_supplier_brackets": {
+    "bit": {
+      "lower": "1733427039589844234749/1000000000000000000000000",
+      "upper": "6933708158359376939/4000000000000000000000",
+      "upper_kappa_ceiling": "6933708158359376939/4006933708158359376939",
+      "upper_kappa_decimal": "0.001730427469823602962148283190583317499948691152327022752094143389558042"
+    },
+    "complex": {
+      "lower": "331788258728880915239/200000000000000000000000",
+      "upper": "414735323411101144049/250000000000000000000000",
+      "upper_kappa_ceiling": "414735323411101144049/250414735323411101144049",
+      "upper_kappa_decimal": "0.001656193765416678434149185542673232841629751760504935267385469380993736"
+    }
+  },
+  "target_budgets": [
+    {
+      "supplier": "bit",
+      "kappa_target": "1/500",
+      "necessary_supplier_saving": "1/499",
+      "current_moment": [
+        "26983797598613761705679949767354893874344135983637166893604515785967/26959946667150639794667015087019630673637144422540572481103610249216",
+        "26983797598613761705679949767354893874344135983637166893604515785969/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "current_moment_decimal": [
+        "1.000884680216826359308863019539125229727313520960313597694002517912012",
+        "1.000884680216826359308863019539125229727313520960313597694002517912087"
+      ],
+      "optimistic_uniform_bill_reduction_lower": "23850931463121911012934680335263200706991561096594412500905536751/26983797598613761705679949767354893874344135983637166893604515785967",
+      "reduction_percent_lower": "0.08838982495313115087521055131667376513875622875836285187655057878959724",
+      "caveat": "Diagnostic uniform scaling of every paid term including fallback, with fixed m and live volume. Not a feasible deletion or an admitted replacement profile."
+    },
+    {
+      "supplier": "bit",
+      "kappa_target": "1/200",
+      "necessary_supplier_saving": "1/199",
+      "current_moment": [
+        "27251599852103113375776094133670184259585823037615873483832204152965/26959946667150639794667015087019630673637144422540572481103610249216",
+        "3406449981512889171972011766708773032448227879701984185479025519121/3369993333393829974333376885877453834204643052817571560137951281152"
+      ],
+      "current_moment_decimal": [
+        "1.010818017874932911013154232885466835529763250846558234896968485046374",
+        "1.010818017874932911013154232885466835529763250846558234896968485046485"
+      ],
+      "optimistic_uniform_bill_reduction_lower": "291653184952473581109079046650553585948678615075301002728593903749/27251599852103113375776094133670184259585823037615873483832204152965",
+      "reduction_percent_lower": "1.070224084220015270931224592767530761327963062448972910001606255382415",
+      "caveat": "Diagnostic uniform scaling of every paid term including fallback, with fixed m and live volume. Not a feasible deletion or an admitted replacement profile."
+    },
+    {
+      "supplier": "bit",
+      "kappa_target": "1/100",
+      "necessary_supplier_saving": "1/99",
+      "current_moment": [
+        "6926950492749541282332066589697465677189712993199929706812103795737/6739986666787659948666753771754907668409286105635143120275902562304",
+        "1731737623187385320583016647424366419297428248299982426703026842047/1684996666696914987166688442938726917102321526408785780068975640576"
+      ],
+      "current_moment_decimal": [
+        "1.027739494928554513629040151746815502763046320670433711212042399721446",
+        "1.027739494928554513629040151746815502763046320670433711212042929759735"
+      ],
+      "optimistic_uniform_bill_reduction_lower": "186963825961881333665312817942558008780426887564786586536201233433/6926950492749541282332066589697465677189712993199929706812103795737",
+      "reduction_percent_lower": "2.699078420692870554151253562092257662001599703304784126474930061491200",
+      "caveat": "Diagnostic uniform scaling of every paid term including fallback, with fixed m and live volume. Not a feasible deletion or an admitted replacement profile."
+    },
+    {
+      "supplier": "complex",
+      "kappa_target": "1/500",
+      "necessary_supplier_saving": "1/499",
+      "current_moment": [
+        "6746870695155741298665062245780316339087370758657247998525606684141/6739986666787659948666753771754907668409286105635143120275902562304",
+        "13493741390311482597330124491560632678174741517314495997051213368283/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "current_moment_decimal": [
+        "1.001021371214575761417369253566363497322800336048790874317674995576480",
+        "1.001021371214575761417369253566363497322800336048790874317674995576554"
+      ],
+      "optimistic_uniform_bill_reduction_lower": "6884028368081349998308474025408670678084653022104878249704121837/6746870695155741298665062245780316339087370758657247998525606684141",
+      "reduction_percent_lower": "0.1020329079824234370086874742378956984758719855573515909715512084709355",
+      "caveat": "Diagnostic uniform scaling of every paid term including fallback, with fixed m and live volume. Not a feasible deletion or an admitted replacement profile."
+    },
+    {
+      "supplier": "complex",
+      "kappa_target": "1/200",
+      "necessary_supplier_saving": "1/199",
+      "current_moment": [
+        "13615028920866410941285184657113183419071796117707769126697810531789/13479973333575319897333507543509815336818572211270286240551805124608",
+        "27230057841732821882570369314226366838143592235415538253395621063581/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "current_moment_decimal": [
+        "1.010018980301296336788038723833522717400716005771470797285851812715545",
+        "1.010018980301296336788038723833522717400716005771470797285851812715657"
+      ],
+      "optimistic_uniform_bill_reduction_lower": "135055587291091043951677113603368082253223906437482886146005407181/13615028920866410941285184657113183419071796117707769126697810531789",
+      "reduction_percent_lower": "0.9919596063736939707427810523729477701380629097997632230996206051574271",
+      "caveat": "Diagnostic uniform scaling of every paid term including fallback, with fixed m and live volume. Not a feasible deletion or an admitted replacement profile."
+    },
+    {
+      "supplier": "complex",
+      "kappa_target": "1/100",
+      "necessary_supplier_saving": "1/99",
+      "current_moment": [
+        "1727731934266592844787140706576860866161026444628316094699860761051/1684996666696914987166688442938726917102321526408785780068975640576",
+        "3455463868533185689574281413153721732322052889256632189399727881831/3369993333393829974333376885877453834204643052817571560137951281152"
+      ],
+      "current_moment_decimal": [
+        "1.025362226771315487977115254583948560277785552404388078098330390716569",
+        "1.025362226771315487977115254583948560277785552404388078098332277880243"
+      ],
+      "optimistic_uniform_bill_reduction_lower": "42735267569677857620452263638133949058704918219530314630885120475/1727731934266592844787140706576860866161026444628316094699860761051",
+      "reduction_percent_lower": "2.473489476121688195904406524467906806837220564549592066029406861567272",
+      "caveat": "Diagnostic uniform scaling of every paid term including fallback, with fixed m and live volume. Not a feasible deletion or an admitted replacement profile."
+    }
+  ],
+  "newton_boundary": {
+    "radix": 4,
+    "triangular_reconstruction_exact": true,
+    "cyclic_replacement_rejected": true,
+    "wrap_correction_rank": 3,
+    "witness_basis_column": 0,
+    "expected": [
+      [
+        "1",
+        "0"
+      ],
+      [
+        "1",
+        "0"
+      ],
+      [
+        "1",
+        "0"
+      ],
+      [
+        "1",
+        "0"
+      ]
+    ],
+    "invalid_cyclic_output": [
+      [
+        "13/16",
+        "-1/16"
+      ],
+      [
+        "21/32",
+        "3/32"
+      ],
+      [
+        "1/2",
+        "1/8"
+      ],
+      [
+        "1/4",
+        "0"
+      ]
+    ],
+    "general_observation": "P(Z_r)-P(J_r) is strictly upper triangular, with every first-superdiagonal entry h_(r-1)=1/r. Its rank is r-1 for every r>=2 in characteristic zero."
+  },
+  "finite_field_boundary": {
+    "field": "GF(2)[u]/(u^2+u+1)",
+    "encoding": {
+      "1": 1,
+      "u": 2,
+      "u+1": 3
+    },
+    "radix": 3,
+    "cyclic_length": 5,
+    "kernel": [
+      1,
+      2,
+      1
+    ],
+    "quotient": [
+      1,
+      2,
+      2,
+      1
+    ],
+    "polynomial_product": [
+      1,
+      0,
+      0,
+      0,
+      0,
+      1
+    ],
+    "nonzero_kernel_vector": [
+      1,
+      2,
+      2,
+      1,
+      0
+    ],
+    "image": [
+      0,
+      0,
+      0,
+      0,
+      0
+    ],
+    "binary_kernel_vector": [
+      1,
+      0,
+      0,
+      1,
+      0,
+      1,
+      1,
+      0,
+      0,
+      0
+    ],
+    "verdict": "P(S_5) is singular despite primitive radix-3 phase and nonzero preparation denominators. Complex unit-circle nonvanishing does not transfer to Boolean arithmetic through this field."
+  },
+  "cost_scope": "Even granting one recursive child per additive leaf and zero scalar, routing, phase, preparation and precision cost, the complete all-role adapter has moment at least 6-6/n>1. Actual lowering can only add costs. This rejects this adapter, not all structural integration routes."
+}
diff --git a/research/dirty-echo-integration/oracles.py b/research/dirty-echo-integration/oracles.py
new file mode 100644
index 0000000000..c823305bbc
--- /dev/null
+++ b/research/dirty-echo-integration/oracles.py
@@ -0,0 +1,88 @@
+"""Direct definitions used independently of the echo and transform schedules."""
+from fractions import Fraction as Q
+from itertools import product
+from math import prod
+
+ZERO=(Q(0),Q(0));ONE=(Q(1),Q(0))
+def add(x,y):return x[0]+y[0],x[1]+y[1]
+def mul(x,y):return x[0]*y[0]-x[1]*y[1],x[0]*y[1]+x[1]*y[0]
+def scale(x,q):return x[0]*q,x[1]*q
+
+
+def rotate(values,exponent):
+    r=len(values);result=[ZERO]*r
+    for j,value in enumerate(values):
+        quotient,index=divmod(j+exponent,r)
+        result[index]=scale(value,(-1)**quotient)
+    return result
+
+
+def polynomial_product(x,y):
+    r=len(x);out=[ZERO]*r
+    for i,a in enumerate(x):
+        for j,b in enumerate(y):
+            q,k=divmod(i+j,r)
+            out[k]=add(out[k],scale(mul(a,b),(-1)**q))
+    return out
+
+
+def coordinates(axes):return list(product(*(range(t) for t in axes)))
+
+
+def fourier(row,axes,r,sign):
+    coords=coordinates(axes);size=prod(axes);result=[]
+    for target in coords:
+        output=[ZERO]*r
+        for i,source in enumerate(coords):
+            exponent=sign*sum((2*r//t)*a*b for t,a,b in zip(axes,target,source))
+            values=rotate(row[i*r:(i+1)*r],exponent)
+            output=[add(a,b) for a,b in zip(output,values)]
+        result.extend(scale(z,Q(1,size)) for z in output)
+    return result
+
+
+def bit_reverse_records(row,axes,r):
+    coords=coordinates(axes);index={value:i for i,value in enumerate(coords)};out=[ZERO]*len(row)
+    for i,coord in enumerate(coords):
+        reverse=tuple(int(format(a,'0%db'%(t.bit_length()-1))[::-1],2) for t,a in zip(axes,coord))
+        j=index[reverse];out[j*r:(j+1)*r]=row[i*r:(i+1)*r]
+    return out
+
+
+def convolution(x,y,axes,r):
+    coords=coordinates(axes);index={value:i for i,value in enumerate(coords)};out=[ZERO]*len(x)
+    for i,a in enumerate(coords):
+        for j,b in enumerate(coords):
+            destination=tuple((aa+bb)%t for aa,bb,t in zip(a,b,axes));k=index[destination]
+            contribution=polynomial_product(x[i*r:(i+1)*r],y[j*r:(j+1)*r])
+            out[k*r:(k+1)*r]=[add(c,d) for c,d in zip(out[k*r:(k+1)*r],contribution)]
+    return out
+
+
+def c_tensor(row,bits):
+    a=(Q(1,2),Q(1,2));b=(Q(1,2),Q(-1,2));mask=sum(1<<j for j in bits)
+    out=[]
+    for i in range(len(row)):
+        value=ZERO
+        for j,input_value in enumerate(row):
+            if (i^j)&~mask:
+                continue
+            coefficient=ONE
+            for bit in bits:
+                coefficient=mul(coefficient,b if (i^j)&(1<<bit) else a)
+            value=add(value,mul(coefficient,input_value))
+        out.append(value)
+    return out
+
+
+def address_swap_permutations(q,groups):
+    coords=coordinates([q]*(2*groups));index={c:i for i,c in enumerate(coords)};result=[]
+    for i in range(groups):
+        permutation=[]
+        for coord in coords:
+            c=list(coord);c[i],c[groups+i]=c[groups+i],c[i]
+            permutation.append(index[tuple(c)])
+        result.append(permutation)
+    # Whole-chunk interchange directly, without composing the factor maps.
+    whole=[index[c[groups:]+c[:groups]] for c in coords]
+    return result,whole
diff --git a/research/dirty-echo-integration/price.py b/research/dirty-echo-integration/price.py
new file mode 100644
index 0000000000..2a2375c298
--- /dev/null
+++ b/research/dirty-echo-integration/price.py
@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""Reject this all-role echo recurrence and quantify unchanged supplier ceilings."""
+import argparse
+from fractions import Fraction as Q
+import importlib.util
+import json
+from pathlib import Path
+
+HERE=Path(__file__).resolve().parent;ROOT=HERE.parents[1]
+
+
+def need(ok,message):
+    if not ok:raise ValueError(message)
+
+
+def load(name,path):
+    s=importlib.util.spec_from_file_location(name,path);m=importlib.util.module_from_spec(s);s.loader.exec_module(m);return m
+
+
+def main():
+    need(__debug__,'Pinned rational moment engine requires assertions; do not use -O')
+    parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--out',type=Path,required=True);args=parser.parse_args()
+    pins=load('price_provenance',HERE/'provenance.py').check()
+    echo=load('priced_echo',HERE.parent/'cyclic-dirty-commutator-audit/echo.py')
+    boundaries=load('exact_boundaries',HERE/'boundaries.py')
+    rows=[]
+    for n in (2,3,4,8,16,64,512):
+        for fanout in sorted({2,8,n}):
+            depth,N=echo.resources(n,fanout);W=2*((depth+3)//2);calls=3*(W//2)*N
+            profile={1:calls};mass=calls;deficit=W*n-mass
+            coefficient=Q(calls,W*n)
+            need(N>=4*n-4 and coefficient>=Q(6*n-6,n)>1 and deficit<0,'noncontractive complete bill')
+            rows.append(dict(factors=n,fanout=fanout,roles=W,borrowed_depth=depth,echo_leaves=N,
+                             optimistic_one_call_leaf_children=calls,profile=profile,rank_mass=mass,rank_deficit=deficit,
+                             moment_at_saving_zero=coefficient,all_nonnegative_savings_rejected=True))
+    # Cost omission: a raw shear appears cheap if restored spectators are
+    # counted as successfully transformed output roles. Functional controls
+    # separately expose their unchanged outputs.
+    n=8;W=10;N=echo.resources(n,8)[1]
+    false_coefficient=Q(N,W*n);correct_coefficient=Q(3*N,2*n)
+    need(false_coefficient<1<correct_coefficient,'missing all-role contract cost control')
+    # The older local quadratic count is not the supplier child histogram.
+    engines=ROOT/'research/complex-k492-owner-repair/vendor/multicold/engines'
+    M=load('integration_moment',engines/'moment.py')
+    bit=json.loads((ROOT/'research/e8-bit-p111-tuned/tune/EXPECTED.json').read_text())['nine']
+    complex_=json.loads((HERE.parent/'gauge44-notri-fine-grid/evidence/CERTIFICATE.json').read_text())
+    profiles={'bit':(64,bit['bit']['live'],{int(k):v for k,v in bit['profile'].items()},True,Q(bit['bit_lower'])),
+              'complex':(73,7168,{int(k):v for k,v in complex_['global_profile'].items()},False,Q(complex_['complex_lower']))}
+    targets=[];brackets={}
+    for name,(m,W,H,bad,lower) in profiles.items():
+        accepted=M.moment(H,m,W,lower,bad);rejected=M.moment(H,m,W,lower+Q(1,10**24),bad)
+        need(accepted[1]<1<rejected[0],'supplier adjacent root bracket '+name)
+        upper=lower+Q(1,10**24)
+        brackets[name]=dict(lower=lower,upper=upper,upper_kappa_ceiling=upper/(1+upper),upper_kappa_decimal=M.decimal(upper/(1+upper)))
+        for kappa in (Q(1,500),Q(1,200),Q(1,100)):
+            required=kappa/(1-kappa);lo,hi=M.moment(H,m,W,required,bad)
+            need(lo>1,'existing supplier unexpectedly reaches target')
+            reduction=(lo-1)/lo
+            targets.append(dict(supplier=name,kappa_target=kappa,necessary_supplier_saving=required,
+                                current_moment=[lo,hi],current_moment_decimal=[M.decimal(lo),M.decimal(hi)],
+                                optimistic_uniform_bill_reduction_lower=reduction,
+                                reduction_percent_lower=M.decimal(100*reduction),
+                                caveat='Diagnostic uniform scaling of every paid term including fallback, with fixed m and live volume. Not a feasible deletion or an admitted replacement profile.'))
+    need(profiles['bit'][4]<Q(1,500)/(1-Q(1,500)),'bit cap control')
+    result=dict(status='REJECT_DIRECT_ECHO_SUPPLIER_NO_KAPPA_GAIN',inherited_source_hashes=pins['files'],adapter_profiles=rows,
+                omission_control=dict(false_raw_shear_coefficient=false_coefficient,complete_all_role_coefficient=correct_coefficient),
+                unchanged_supplier_brackets=brackets,target_budgets=targets,
+                newton_boundary=boundaries.newton_boundary(),finite_field_boundary=boundaries.bit_field_boundary(),
+                cost_scope='Even granting one recursive child per additive leaf and zero scalar, routing, phase, preparation and precision cost, the complete all-role adapter has moment at least 6-6/n>1. Actual lowering can only add costs. This rejects this adapter, not all structural integration routes.')
+    args.out.write_text(json.dumps(result,indent=2,default=str)+'\n')
+    for row in targets:
+        print(row['supplier'],'target',float(row['kappa_target']),'requires >',float(row['optimistic_uniform_bill_reduction_lower']*100),'percent uniform bill reduction')
+    print(result['status'])
+
+
+if __name__=='__main__':main()
diff --git a/research/dirty-echo-integration/provenance.py b/research/dirty-echo-integration/provenance.py
new file mode 100644
index 0000000000..8b9dbf8f25
--- /dev/null
+++ b/research/dirty-echo-integration/provenance.py
@@ -0,0 +1,15 @@
+"""Bind inherited inputs; no network, regeneration, or trust in filenames alone."""
+import hashlib
+import json
+from pathlib import Path
+
+HERE=Path(__file__).resolve().parent
+ROOT=HERE.parents[1]
+
+
+def check():
+    pins=json.loads((HERE/'SOURCES.json').read_text())
+    for name,digest in pins['files'].items():
+        if hashlib.sha256((ROOT/name).read_bytes()).hexdigest()!=digest:
+            raise ValueError('inherited source hash mismatch: '+name)
+    return pins
diff --git a/research/dirty-echo-integration/replay.sh b/research/dirty-echo-integration/replay.sh
new file mode 100644
index 0000000000..0c2aef0034
--- /dev/null
+++ b/research/dirty-echo-integration/replay.sh
@@ -0,0 +1,14 @@
+#!/bin/sh
+set -eu
+if [ "$#" -ne 1 ] || [ -e "$1" ]; then
+    echo "usage: sh research/dirty-echo-integration/replay.sh NEW_OUTPUT_DIRECTORY" >&2
+    exit 2
+fi
+here=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+mkdir -p -- "$1"
+out=$(CDPATH= cd -- "$1" && pwd)
+python3 -I -B "$here/verify.py" --out "$out/FUNCTIONAL.json"
+python3 -I -B "$here/price.py" --out "$out/PRICE.json"
+cmp "$out/FUNCTIONAL.json" "$here/evidence/FUNCTIONAL.json"
+cmp "$out/PRICE.json" "$here/evidence/PRICE.json"
+echo PASS_INTEGRATION_EXPERIMENT_WITH_REJECTED_SUPPLIER_BILL
diff --git a/research/dirty-echo-integration/transform.py b/research/dirty-echo-integration/transform.py
new file mode 100644
index 0000000000..a5f97f6507
--- /dev/null
+++ b/research/dirty-echo-integration/transform.py
@@ -0,0 +1,98 @@
+"""Complete normalized synthetic transforms using the all-role echo adapter.
+
+Matches the stored-order contract of upstream/06-transforms.tex. Exact Fraction
+prototype with indexed address reads; this does not implement a fixed-tape bound.
+"""
+import importlib.util
+from math import gcd,prod
+from pathlib import Path
+
+spec=importlib.util.spec_from_file_location('synthetic_echo_adapter',Path(__file__).with_name('adapter.py'))
+A=importlib.util.module_from_spec(spec);spec.loader.exec_module(A)
+
+
+def axis_data(axes):
+    widths=[]
+    for n in axes:
+        A.need(n>=2 and n&(n-1)==0,'power-of-two axis')
+        widths.append(n.bit_length()-1)
+    return widths,[sum(widths[i+1:]) for i in range(len(widths))]
+
+
+def rounds(axes,record_width):
+    widths,offsets=axis_data(axes)
+    A.need(record_width>=2 and record_width&(record_width-1)==0,'power-of-two record')
+    A.need(all((2*record_width)%t==0 for t in axes),'synthetic root order')
+    result=[]
+    for s in range(max(widths)):
+        active=[(i,width-s-1) for i,width in enumerate(widths) if width>s]
+        bits=[offsets[i]+bit for i,bit in active]
+        exponents=[]
+        for address in range(prod(axes)):
+            exponent=0
+            for i,bit in active:
+                coord=(address>>offsets[i])&(axes[i]-1)
+                exponent-=(2*record_width//(1<<(bit+1)))*((coord>>bit)&1)*(coord&((1<<bit)-1))
+            exponents.append(exponent%(2*record_width))
+        result.append((bits,exponents))
+    return result
+
+
+def rotate_record_in_place(row,start,r,exponent):
+    """Multiply one polynomial by y^exponent mod y^r+1 with one held scalar."""
+    exponent%=2*r
+    for begin in range(gcd(r,exponent)):
+        position=begin;held=row[start+position]
+        while True:
+            quotient,destination=divmod(position+exponent,r)
+            old=row[start+destination]
+            row[start+destination]=A.scale(held,(-1)**quotient)
+            held=old;position=destination
+            if position==begin:
+                break
+
+
+def normalized_layer(arrays,bits,r,fanout,mutant=None):
+    multiplier=A.ONE
+    for _ in bits:
+        multiplier=A.mul(multiplier,A.B)
+    for row in arrays:
+        for j,v in enumerate(row):
+            row[j]=A.mul(A.ipow(sum(((j//r)>>bit)&1 for bit in bits)),v)
+    receipt=A.complex_layer(arrays,bits,r,fanout,mutant)
+    for row in arrays:
+        for j,v in enumerate(row):
+            factor=A.ipow(sum(((j//r)>>bit)&1 for bit in bits))
+            if mutant!='omit_normalization':
+                factor=A.mul(factor,multiplier)
+            row[j]=A.mul(factor,v)
+    return receipt
+
+
+def transform(arrays,axes,r,opposite=False,fanout=8,mutant=None):
+    """Forward B F-minus; opposite F-plus B^-1. Both normalized by 1/M."""
+    A.need(len({id(row) for row in arrays})==len(arrays),'distinct arrays')
+    schedule=rounds(axes,r)
+    A.need(len(arrays)%2==0 and len(arrays)>=A.role_count(len(axes),fanout),'even sufficient roles')
+    A.need(all(len(row)==prod(axes)*r for row in arrays),'array extent')
+    leaves=0;twiddle_writes=0;layer_records=[]
+    for bits,exponents in reversed(schedule) if opposite else schedule:
+        if opposite:
+            for row in arrays:
+                for address,exponent in enumerate(exponents):
+                    rotate_record_in_place(row,address*r,r,-exponent)
+                    twiddle_writes+=r
+        receipt=normalized_layer(arrays,bits,r,fanout,mutant)
+        leaves+=receipt['leaf_calls'];layer_records.append(receipt)
+        if not opposite:
+            for row in arrays:
+                for address,exponent in enumerate(exponents):
+                    rotate_record_in_place(row,address*r,r,exponent if mutant!='reverse_twiddle_sign' else -exponent)
+                    twiddle_writes+=r
+    size=len(arrays[0]);W=len(arrays)
+    return dict(axes=list(axes),record_width=r,opposite=opposite,rounds=len(schedule),
+                all_role_layer_records=layer_records,echo_leaves=leaves,
+                source_component_reads=2*size*leaves,target_component_reads=size*leaves,
+                leaf_component_writes=size*leaves,adapter_and_butterfly_component_writes=4*W*size*len(schedule),
+                twiddle_component_writes=twiddle_writes,
+                tape_scope='Indexed-read reference only. Routing, coefficient bit lengths and a fixed-tape implementation are not discharged.')
diff --git a/research/dirty-echo-integration/verify.py b/research/dirty-echo-integration/verify.py
new file mode 100644
index 0000000000..d3539175cf
--- /dev/null
+++ b/research/dirty-echo-integration/verify.py
@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""Exact functional integration plus rejection of an unprofitable supplier bill."""
+import argparse
+import copy
+from fractions import Fraction as F
+import importlib.util
+import json
+from math import prod
+from pathlib import Path
+
+HERE=Path(__file__).resolve().parent
+ROOT=HERE.parents[1]
+
+
+def load(name,path):
+    s=importlib.util.spec_from_file_location(name,path);m=importlib.util.module_from_spec(s);s.loader.exec_module(m);return m
+
+
+A=load('verified_adapter',HERE/'adapter.py')
+T=load('verified_transform',HERE/'transform.py')
+O=load('direct_oracles',HERE/'oracles.py')
+need=A.need
+
+
+def complex_checks():
+    cases=0;calls=0
+    for bits in ((0,),(0,1),(0,2),(0,1,2)):
+        length=1<<(max(bits)+1)
+        for fanout in (2,8):
+            W=A.role_count(len(bits),fanout)
+            # Full complex basis, including every borrowed role's input column.
+            for column in range(W*length):
+                rows=[[A.ZERO]*length for _ in range(W)]
+                rows[column//length][column%length]=A.ONE
+                expected=[O.c_tensor(row,bits) for row in rows]
+                receipt=A.complex_layer(rows,bits,1,fanout)
+                need(rows==expected,'all-role complex basis')
+                need(receipt['leaf_calls']==3*(W//2)*A.E.resources(len(bits),fanout)[1],'complex child count')
+                cases+=1;calls+=receipt['leaf_calls']
+    return dict(basis_cases=cases,leaf_executions=calls)
+
+
+def bit_checks():
+    rows_checked=0;results=[]
+    for q in (3,5):
+        for groups in ((1,2,3) if q==3 else (1,2)):
+            permutations,whole=O.address_swap_permutations(q,groups);length=len(whole)
+            for fanout in (2,8):
+                W=A.role_count(groups,fanout)
+                # Each integer's bits are formal coefficients of ALL W*length
+                # independent input bits. Equality checks the entire linear map.
+                rows=[[1<<(role*length+j) for j in range(length)] for role in range(W)]
+                expected=[[row[j] for j in whole] for row in rows]
+                receipt=A.boolean_layer(rows,permutations,fanout)
+                need(rows==expected,'all-role Boolean address interchange')
+                need(receipt['leaf_calls']==3*(W//2)*A.E.resources(groups,fanout)[1],'bit child count')
+                rows_checked+=W*length
+                results.append(dict(radix=q,groups=groups,fanout=fanout,independent_input_bits=W*length,**receipt))
+    return dict(symbolic_output_rows=rows_checked,cases=results)
+
+
+def full_transform_checks():
+    results=[];basis_count=0
+    for axes,r in (((2,),2),((2,2),2),((4,2),2),((4,4),2),((8,2),4),((4,2,2),2)):
+        W=A.role_count(len(axes),8);length=prod(axes)*r
+        initial=[[(F(2*j+role+1,16),F(j-3*role-1,16)) for j in range(length)] for role in range(W)]
+        expected=[O.bit_reverse_records(O.fourier(row,axes,r,-1),axes,r) for row in initial]
+        rows=copy.deepcopy(initial);receipt=T.transform(rows,axes,r)
+        need(rows==expected,'complete stored-order forward transform')
+        T.transform(rows,axes,r,opposite=True)
+        need(rows==[[A.scale(z,F(1,prod(axes))) for z in row] for row in initial],'opposite normalization and round trip')
+        left=copy.deepcopy(initial)
+        right=[[(F(3*j-role+2,32),F(role+j+1,32)) for j in range(length)] for role in range(W)]
+        exact=[O.convolution(x,y,axes,r) for x,y in zip(left,right)]
+        T.transform(left,axes,r);T.transform(right,axes,r)
+        product_rows=[]
+        for x,y in zip(left,right):
+            product_row=[]
+            for start in range(0,length,r):
+                product_row.extend(O.polynomial_product(x[start:start+r],y[start:start+r]))
+            product_rows.append(product_row)
+        T.transform(product_rows,axes,r,opposite=True)
+        restored=[[A.scale(z,prod(axes)**2) for z in row] for row in product_rows]
+        need(restored==exact,'complete cyclic/negacyclic convolution normalization')
+        need([[A.scale(z,prod(axes)) for z in row] for row in product_rows]!=exact,'missing convolution normalization control')
+        results.append(receipt)
+        if axes in ((2,),(2,2)):
+            for column in range(W*length):
+                rows=[[A.ZERO]*length for _ in range(W)]
+                rows[column//length][column%length]=A.ONE
+                expected=[O.bit_reverse_records(O.fourier(row,axes,r,-1),axes,r) for row in rows]
+                T.transform(rows,axes,r)
+                need(rows==expected,'complete transform basis column')
+                basis_count+=1
+    rotations=0
+    for r in (2,4,8):
+        row=[(F(i+1),F(2*i-1)) for i in range(r)]
+        for exponent in range(-2*r,2*r+1):
+            result=row[:];T.rotate_record_in_place(result,0,r,exponent)
+            need(result==O.rotate(row,exponent),'signed monomial cycle')
+            rotations+=1
+    return dict(cases=results,additional_basis_columns=basis_count,signed_rotation_checks=rotations,wrong_convolution_scale_rejected_cases=len(results))
+
+
+def mutation_checks():
+    controls=[]
+    d=3;length=1<<d;W=A.role_count(d,8)
+    initial=[[(F(2*j+role+1,16),F(j-3*role-1,16)) for j in range(length)] for role in range(W)]
+    expected=[O.c_tensor(row,range(d)) for row in initial]
+    for mutant in ('omit_negative_leaf','skip_borrowed_outputs','omit_role_exchange','omit_inverse_phase'):
+        rows=copy.deepcopy(initial);A.complex_layer(rows,range(d),1,8,mutant)
+        need(rows!=expected,'complex mutation escaped: '+mutant);controls.append('complex:'+mutant)
+    permutations,whole=O.address_swap_permutations(3,2);length=len(whole);W=A.role_count(2,8)
+    initial=[[1<<(role*length+j) for j in range(length)] for role in range(W)]
+    expected=[[row[j] for j in whole] for row in initial]
+    for mutant in ('omit_negative_leaf','skip_borrowed_outputs','omit_role_exchange'):
+        rows=copy.deepcopy(initial);A.boolean_layer(rows,permutations,8,mutant)
+        need(rows!=expected,'Boolean mutation escaped: '+mutant);controls.append('bit:'+mutant)
+    axes=(4,2);r=2;length=prod(axes)*r;W=A.role_count(2,8)
+    initial=[[(F(j+role+1,8),F(role-j,8)) for j in range(length)] for role in range(W)]
+    expected=[O.bit_reverse_records(O.fourier(row,axes,r,-1),axes,r) for row in initial]
+    for mutant in ('omit_normalization','reverse_twiddle_sign'):
+        rows=copy.deepcopy(initial);T.transform(rows,axes,r,mutant=mutant)
+        need(rows!=expected,'transform mutation escaped: '+mutant);controls.append('transform:'+mutant)
+    # Both interfaces must reject borrowed/input aliases before execution.
+    for label,call in [('complex',lambda arrays:A.complex_layer(arrays,(0,1),1)),
+                       ('bit',lambda arrays:A.boolean_layer(arrays,[list(range(8))]*2)),
+                       ('full_transform',lambda arrays:T.transform(arrays,(2,2),2))]:
+        row=[A.ONE]*8;arrays=[row,row,[A.ZERO]*8,[A.ZERO]*8];saved=copy.deepcopy(arrays)
+        try:call(arrays)
+        except ValueError as error:
+            need(str(error)=='distinct arrays' and arrays==saved,'alias rejection after mutation')
+        else:raise ValueError('alias admitted')
+        controls.append(label+':role_alias')
+    return controls
+
+
+def main():
+    parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--out',type=Path,required=True);args=parser.parse_args()
+    pins=load('functional_provenance',HERE/'provenance.py').check()
+    complex_result=complex_checks();print('PASS complex all-role basis',complex_result['basis_cases'],flush=True)
+    bit_result=bit_checks();print('PASS Boolean full-domain symbolic rows',bit_result['symbolic_output_rows'],flush=True)
+    transforms=full_transform_checks();print('PASS complete transforms and convolution',len(transforms['cases']),flush=True)
+    controls=mutation_checks()
+    report=dict(status='PASS_FUNCTIONAL_ECHO_INTEGRATION',inherited_source_hashes=pins['files'],complex=complex_result,bit=bit_result,transforms=transforms,negative_controls=controls,
+                scope='Exact finite functional adapters and full stored-order synthetic transforms. These are indexed-read prototypes, not admitted fixed-tape suppliers or a new kappa.')
+    args.out.write_text(json.dumps(report,indent=2)+'\n')
+    print(report['status'],len(controls),'negative controls')
+
+
+if __name__=='__main__':main()
diff --git a/research/gauge44-notri-fine-grid/README.md b/research/gauge44-notri-fine-grid/README.md
new file mode 100644
index 0000000000..07199ac813
--- /dev/null
+++ b/research/gauge44-notri-fine-grid/README.md
@@ -0,0 +1,103 @@
+# Final-grid refinement of the pinned PR659 conditional witness
+
+The final κ rounding grid can be refined from 10^-18 to 10^-24 without changing
+PR659's construction, suppliers, bootstrap schedule or outer parameters:
+
+| Quantity | Exact value |
+|---|---:|
+| PR659 κ | 0.001656193765416678 |
+| Refined conditional κ | **0.001656193765416678434092** |
+| Increase | 0.000000000000000000434092 |
+| Refined rational | 414048441354169608523 / 250000000000000000000000 |
+
+This **4.34092 × 10^-19 arithmetic refinement is not a new circuit or supplier**.
+It depends on the pending PR659 construction; the repository's selected result
+is unchanged. The substantially different local-primitive research from the
+same sprint is [the multiway dirty echo](../cyclic-dirty-commutator-audit/ECHO-PROOF.md).
+No κ gain is attributed to that primitive.
+
+The pre-submission refresh found stronger concurrent proposals, including
+[PR671](https://github.com/CrocSwap/integer-mult-bounds/pull/671) at
+`16a27439d4ba1db451b6179c9475793529a485b6`, reporting 0.001658714981837397.
+That construction was not audited here. This is a refinement of the pinned
+PR659 witness, **not a proposed new frontier**; its independent fresh replay
+and exact strict-rounding check remain reviewable evidence.
+
+## Exact change and dependencies
+
+The paid complex profile is
+`{1:182448, 2:24912, 3:32976, 4:12816, 5:4032, 8:576, 48:2364}`,
+with m=73, live width 7168, physical width 7682 and rank deficit 2560.
+The complex lower endpoint is 0.001658941293644404576195; the cited PR589 bit
+lower endpoint is 0.001733427039589844234749, including its surcharge.
+
+Set eta=beta=10^-24 and s=min(c,(1-beta)b)-10^-27. Starting at
+384599/10^10, perform the same seven iterations a <- (1-s)s + sa as PR659,
+checking the same strict gaps and finite cutoffs. With q=a(1-2eta), the binding
+margin is (1-eta)q/(1+q). `certify.py` changes only the final strict floor:
+
+    grid = 10**24                     # formerly 10**18
+    ticks = margin * grid
+    kappa = ((ticks.numerator - 1) // ticks.denominator) / grid
+
+All arithmetic is exact rational arithmetic (the pseudocode's final division
+is implemented with Fraction). Subtracting one from the numerator also handles
+an integral tick strictly. Both independent rational moment engines verify the
+complex lower endpoint and reject the next 10^-24 tick. All 47 assembly
+inequalities remain strict: 40 feasibility inequalities are identical and the
+seven κ gaps decrease by exactly 4.34092 × 10^-19. The next κ tick, equality
+with the margin, eta=0, beta=0 and beta=1 are rejected.
+
+[SOURCES.json](SOURCES.json) pins the main base, PR659, PR635, the cited merged
+PR589 source, the paid profile and all three arithmetic engines. The fresh
+replay reconstructs the base word, removes K triangles, applies the layered
+cold ends, and runs native local, wrapper, phase, independent 728-column linear
+and cone, full global owner/admission, and independent pricing checks. It
+rebuilds the complex construction. It **reprices the cited PR589 bit supplier;
+it does not freshly rebuild that bit circuit**.
+
+## Reproduce
+
+From the repository root (standard Python and Git only):
+
+```sh
+git fetch https://github.com/CrocSwap/integer-mult-bounds.git 4982f0ca66ffe0960b5a6451deb5b66b1039326b a6895a69f8ad98ab45777b03e9e6f48888c39f6f && python3 -B research/gauge44-notri-fine-grid/verify.py --out /tmp/gauge44-fine-grid-replay
+```
+
+Use a new output directory. Do not use `-O`; the inherited engines require
+assertions, and this wrapper explicitly refuses optimized execution. The
+verifier performs no network access or tracked-file writes. Expected final line:
+
+```text
+PASS_FRESH_PR659_AND_FINE_GRID 0.001656193765416678434092
+```
+
+The recorded fresh run completed all eight stages in about 186 seconds on
+Python 3.14.7/macOS arm64. [evidence/CERTIFICATE.json](evidence/CERTIFICATE.json)
+contains exact endpoints, bootstrap cutoffs, all 47 slacks and negative controls;
+[evidence/REPLAY.json](evidence/REPLAY.json) records the full run. Log hashes in
+that receipt identify that run only; timing and paths may differ on replay.
+Regenerated compression bytes are not an equality test for the mathematics.
+The source reconstruction's canonical word-content checks are retained.
+
+## Scope and credit
+
+The all-size compiler, common-label and mutable-source realization, whole-call
+hosting, precision/tape/exact recovery, analytic transfer and bit H1–H5
+assumptions remain inherited and conditional. A certificate is not a formal
+proof of the full multiplication theorem or a practical multiplication speedup.
+The complex endpoint currently binds this witness; eliminating that bottleneck
+alone would still leave the cited bit endpoint near 0.0017334, far short of the
+ambitious κ>0.01 target. Both suppliers need structural advances for that goal.
+
+Credit **jeremykothe2** for PR659 and PR635, **icekylinx** for the PR645 gauge44
+construction, **jaymosley07** and **jeremydiviney** for PR653/658 owner-packing
+methods, **chafreaky** for PR619's prior use of finer outer grids on a different
+fixed family, **DreamingOfClouds** for
+the PR589 bit supplier, and all authors retained by those packages' NOTICE and
+UPSTREAM-NOTICE files. This package does not claim their circuit or proof work.
+The outer engine additionally credits **eumemic**, **icekylinx**, **Zhihao Chen**
+and **hipotures**; their source notices are preserved by using the pinned engine.
+
+This refinement, fresh replay wrapper and audit were prepared for
+**@androolloyd**, with substantial **OpenAI Codex** assistance, under Apache-2.0.
diff --git a/research/gauge44-notri-fine-grid/SOURCES.json b/research/gauge44-notri-fine-grid/SOURCES.json
new file mode 100644
index 0000000000..9078324fc2
--- /dev/null
+++ b/research/gauge44-notri-fine-grid/SOURCES.json
@@ -0,0 +1,23 @@
+{
+  "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "pr659": "4982f0ca66ffe0960b5a6451deb5b66b1039326b",
+  "pr635": "a6895a69f8ad98ab45777b03e9e6f48888c39f6f",
+  "pr589": "a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46",
+  "engines": {
+    "moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482",
+    "base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098",
+    "outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c"
+  },
+  "global_profile": {
+    "1": 182448,
+    "2": 24912,
+    "3": 32976,
+    "4": 12816,
+    "5": 4032,
+    "8": 576,
+    "48": 2364
+  },
+  "complex_lower": "331788258728880915239/200000000000000000000000",
+  "bit_lower": "1733427039589844234749/1000000000000000000000000",
+  "credit": "PR659/635 by jeremykothe2, based on icekylinx PR645; jaymosley07 PR653 and jeremydiviney PR658 owner methods; PR589 bit supplier by DreamingOfClouds and its eumemic lineage. PR619 by chafreaky precedes the final-grid technique on a different fixed family. All inherited source notices remain applicable."
+}
diff --git a/research/gauge44-notri-fine-grid/certify.py b/research/gauge44-notri-fine-grid/certify.py
new file mode 100644
index 0000000000..4f6c26368f
--- /dev/null
+++ b/research/gauge44-notri-fine-grid/certify.py
@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""Refine only final-grid rounding of the fully admitted, pinned PR659 witness."""
+import argparse
+from decimal import Decimal, localcontext
+from fractions import Fraction as Q
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+ENGINE = ROOT/'research/complex-k492-owner-repair/vendor/multicold/engines'
+OLD_K = Q('0.001656193765416678')
+NEW_K = Q('0.001656193765416678434092')
+GRID = 10**24
+BRIDGE = {'semantic': {'C0': {'base': 2, 'exponent': 210000}, 'strict_literal_gap': 1},
+          'rows': {'degree_gap': Q(10**6)-Q(51*20161, 25)}}
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def load(path, name):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def decimal(x):
+    with localcontext() as context:
+        context.prec = 65
+        return str(Decimal(x.numerator)/Decimal(x.denominator))
+
+
+def round_below(margin, grid):
+    ticks = margin*grid
+    return Q((ticks.numerator-1)//ticks.denominator, grid)
+
+
+def certificate(assembly_path):
+    need(__debug__, 'The inherited outer engine requires assertions; do not use -O')
+    pins = json.loads((HERE/'SOURCES.json').read_text())
+    for name, digest in pins['engines'].items():
+        need(hashlib.sha256((ENGINE/name).read_bytes()).hexdigest() == digest, 'engine source pin: '+name)
+    A = load(ENGINE/'outer.py', 'fine_grid_outer')
+    M = load(ENGINE/'moment.py', 'fine_grid_mercator')
+    B = load(ENGINE/'base_two_moment.py', 'fine_grid_base_two')
+    raw = assembly_path.read_bytes()
+    data = json.loads(raw)
+    need(data['status'] == 'PASS_GAUGE44_NATIVE_EXACT_GLOBAL_ASSEMBLY', 'baseline status')
+    need(Q(data['kappa']) == OLD_K, 'baseline kappa')
+    need(data['complex_profile'] == pins['global_profile'], 'baseline paid profile')
+    need(data['surcharge_model'] == {'complex': False, 'bit': True}, 'surcharge model')
+    c, b = Q(data['bit_lower']), Q(data['complex_lower'])
+    need(str(b) == pins['complex_lower'] and str(c) == pins['bit_lower'], 'supplier endpoints')
+    H = {int(k): v for k, v in data['complex_profile'].items()}
+    need(73*7168-sum(k*v for k,v in H.items()) == 2560, 'rank deficit')
+    moments = []
+    for z, accept in [(b, True), (b+Q(1,10**24), False)]:
+        l,u = M.moment(H,73,7168,z,False)
+        ll,uu = B.moment(73,7168,list(H.items()),z)
+        need((u < 1 and uu < 1) if accept else (l > 1 and ll > 1), 'two moment signs')
+        moments.append(dict(endpoint=str(z), admitted=accept, mercator=[str(l-1),str(u-1)], base_two=[str(ll-1),str(uu-1)]))
+    eta = beta = Q(1,10**24)
+    s = min(c,(1-beta)*b)-Q(1,10**27)
+    need(0 < s < c and s < (1-beta)*b, 'common saving')
+    a = Q(384599,10**10)
+    cuts = []
+    for _ in range(7):
+        old = a
+        a = (1-s)*s+s*old
+        gap = min(s-a,1-a-s,1-a-s*(1-old),1-s)
+        need(old < a < s < 1-a and gap > 0, 'bootstrap recurrence')
+        ceil = lambda x: -(-x.numerator//x.denominator)
+        cutoff = max(ceil(36/gap**2),ceil(2*(4+512)/gap))
+        need(cutoff*gap**2 >= 36 and cutoff*gap >= 2*(4+512), 'finite cutoff')
+        cuts.append(dict(exponent=str(a),gap=str(gap),cutoff_log2=str(cutoff)))
+    need(cuts == data['bootstrap'], 'changed bootstrap schedule')
+    q = a*(1-2*eta)
+    margin = (1-eta)*q/(1+q)
+    need(round_below(margin,10**18) == OLD_K, 'original rounding')
+    need(round_below(margin,GRID) == NEW_K > OLD_K, 'fine-grid improvement')
+    baseline = A.assembly(a,b,BRIDGE,OLD_K,eta=eta,beta=beta)
+    need({k:str(v) for k,v in baseline['strict_constraints'].items()} == data['outer'], 'baseline outer binding')
+    refined = A.assembly(a,b,BRIDGE,NEW_K,eta=eta,beta=beta)
+    slacks = refined['strict_constraints']
+    need(len(slacks) == 47 and all(x > 0 for x in slacks.values()), '47 strict inequalities')
+    # All 40 feasibility constraints stay identical. Only seven kappa gaps shrink.
+    for key, value in slacks.items():
+        expected = baseline['strict_constraints'][key] - (NEW_K-OLD_K if key.endswith('_above_kappa') else 0)
+        need(value == expected, 'unexpected constraint change: '+key)
+    controls=[]
+    for name, kk, ee, be in [('next_fine_tick',NEW_K+Q(1,GRID),eta,beta),
+                             ('zero_eta',NEW_K,Q(0),beta),('zero_beta',NEW_K,eta,Q(0)),
+                             ('unit_beta',NEW_K,eta,Q(1)),('equal_margin',margin,eta,beta)]:
+        try:
+            A.assembly(a,b,BRIDGE,kk,eta=ee,beta=be)
+        except AssertionError:
+            controls.append(name)
+        else:
+            raise ValueError('invalid witness accepted: '+name)
+    # Strict floor must also handle an exactly integral number of ticks.
+    need(round_below(Q(3,GRID),GRID) == Q(2,GRID), 'exact-grid strictness')
+    return dict(status='PASS_PR659_FINE_GRID_CONDITIONAL_KAPPA', source_commit=pins['pr659'],
+                baseline_assembly_sha256=hashlib.sha256(raw).hexdigest(),
+                old_kappa=str(OLD_K),kappa=str(NEW_K),kappa_decimal=decimal(NEW_K),
+                increase=str(NEW_K-OLD_K),increase_decimal=decimal(NEW_K-OLD_K),
+                grid=GRID,complex_lower=str(b),bit_lower=str(c),global_profile=H,
+                exact_moments=moments,bootstrap=cuts,
+                outer_parameters=refined['parameters'],strict_constraints=slacks,
+                margin=margin,remaining_margin=margin-NEW_K,negative_controls=controls,
+                exact_grid_control=True,scope='Final-grid refinement only; unchanged PR659 construction, costs, suppliers and conditional assumptions. No new circuit or cheaper recurrence.')
+
+
+def main():
+    parser=argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--assembly',type=Path,required=True)
+    parser.add_argument('--out',type=Path,required=True)
+    args=parser.parse_args()
+    result=certificate(args.assembly)
+    args.out.write_text(json.dumps(result,indent=2,default=str)+'\n')
+    print(result['status'],result['kappa_decimal'],'gain',result['increase_decimal'])
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/gauge44-notri-fine-grid/evidence/CERTIFICATE.json b/research/gauge44-notri-fine-grid/evidence/CERTIFICATE.json
new file mode 100644
index 0000000000..bdfe584b0d
--- /dev/null
+++ b/research/gauge44-notri-fine-grid/evidence/CERTIFICATE.json
@@ -0,0 +1,166 @@
+{
+  "status": "PASS_PR659_FINE_GRID_CONDITIONAL_KAPPA",
+  "source_commit": "4982f0ca66ffe0960b5a6451deb5b66b1039326b",
+  "baseline_assembly_sha256": "697f4795475a29e02728ee5594a4e5726c526be6b7041cc2bb1cef696e80baed",
+  "old_kappa": "828096882708339/500000000000000000",
+  "kappa": "414048441354169608523/250000000000000000000000",
+  "kappa_decimal": "0.001656193765416678434092",
+  "increase": "108523/250000000000000000000000",
+  "increase_decimal": "4.34092E-19",
+  "grid": 1000000000000000000000000,
+  "complex_lower": "331788258728880915239/200000000000000000000000",
+  "bit_lower": "1733427039589844234749/1000000000000000000000000",
+  "global_profile": {
+    "1": 182448,
+    "2": 24912,
+    "3": 32976,
+    "4": 12816,
+    "5": 4032,
+    "8": 576,
+    "48": 2364
+  },
+  "exact_moments": [
+    {
+      "endpoint": "331788258728880915239/200000000000000000000000",
+      "admitted": true,
+      "mercator": [
+        "-107304646380638767712547168163528328537019/6739986666787659948666753771754907668409286105635143120275902562304",
+        "-214609292761277535425094336327056657074037/13479973333575319897333507543509815336818572211270286240551805124608"
+      ],
+      "base_two": [
+        "-15921/1000000000000000000000000000000",
+        "-199/12500000000000000000000000000"
+      ]
+    },
+    {
+      "endpoint": "414735323411101144049/250000000000000000000000",
+      "admitted": false,
+      "mercator": [
+        "39659886201900040914929948774106104475385609/13479973333575319897333507543509815336818572211270286240551805124608",
+        "19829943100950020457464974387053052237692805/6739986666787659948666753771754907668409286105635143120275902562304"
+      ],
+      "base_two": [
+        "2942133/1000000000000000000000000000000",
+        "1471067/500000000000000000000000000000"
+      ]
+    }
+  ],
+  "bootstrap": [
+    {
+      "exponent": "66250120405796217602377839758436308023250465562108265828532482959053059945684076357697572879/40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "gap": "107531339979965445422053883911946200566486637891734171467517040946940054315923642302427121/40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "cutoff_log2": "4981410914775"
+    },
+    {
+      "exponent": "13271494671519185873528440477908126649017302973403540390776241560966991311607735408148008574882521525724139545630362624301576755185575796919/8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "gap": "35677636050736031538250561524195746087466596459609223758439033008688392264591851991425117478474275860454369637375698423244814424203081/8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "cutoff_log2": "1810049004369976122"
+    },
+    {
+      "exponent": "2654306057993626581075540205560314859071059305629515859600769782854035855156609704018104706754344634364519669708211823992373756083109991735245620962795245434527652759012896748472483651359/1600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "gap": "11837420740836455540133615309881618782370484140399230217145964144843390295981895293245655365635480330291788176007626243916890008264754379037204754565472347240987103251527516348641/1600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "cutoff_log2": "657700690481843692381521"
+    },
+    {
+      "exponent": "530861213962281947166955882028580661638119907105118977289704730136876315642465307271158834230599749735793956003299241665864150186566100533565010714860402293278305448519797435181632891060852739381118056458409870879086998367987493840199/320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "gap": "3927517215443267110205372152415710494881022710295269863123684357534692728841165769400250264206043996700758334135849813433899466434989285139597706721694551480202564818367108939147260618881943541590129120913001632012506159801/320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "cutoff_log2": "238982589540916156562994439389"
+    },
+    {
+      "exponent": "106172242793240589772381790203122273808470672503719641798061407511830681441295169084492652572351592262703523595689917589826023484850404769076714589174146757465353889334941180759492594166919812157555199456149770029107481756491208498149087269102827004428235370770819587907878070107439/64000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "gap": "1303104098039624634932949636451016280358201938592488169318558704830915507347427648407737296476404310082410173976515149595230923285410825853242534646110665058819240507405833080187842444800543850229970892518243508791501850912730897172995571764629229180412092121929892561/64000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "cutoff_log2": "86836883296929799274806814976304559"
+    },
+    {
+      "exponent": "21234448558648378142941326334515461122519621401703662556910716255423298613341983587110847044405843218322291116109137132163894092367761063829211740487150641393493079072164617387236797864351743683670621626555386802495772513512221750683662850127377241634377821613765248736994418483104584817474420318426529393720156390410854617637079/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "gap": "432354639631035980229101803302296337443089283744576701386658016412889152955594156781677708883890862867836105907632238936170788259512849358606506920927835382612763202135648256316329378373444613197504227486487778249316337149872622758365622178386234751263005581516895415182525579681573470606279843609589145382362921/12800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "cutoff_log2": "31553111526702130384987335278189276838758"
+    },
+    {
+      "exponent": "4246889711729675714915743000073754034266651515959666182247526228836018099002242503607020570679908122980981535020539843063646313317111414234476783680090784555160146183216355100591416991420104522442863935176119898454751842224108853773050492094979591771550195719057090304339474765387678970266869662769675981564523779491317288113053331396617198315822896591643365438134466937453119/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "gap": "143450193036534236057633424840333817752473771163981900997757496392979429320091877019018464979460156936353686682888585765523216319909215444839853816783644899408583008579895477557136064823880101545248157775891146226949507905020408228449804280942909695660525234612321029733130337230324018435476220508682711886946668603382801684177103408356634561865533062546881/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+      "cutoff_log2": "11465160991696983106189568796383004715165222927"
+    }
+  ],
+  "outer_parameters": {
+    "a_bit": "4246889711729675714915743000073754034266651515959666182247526228836018099002242503607020570679908122980981535020539843063646313317111414234476783680090784555160146183216355100591416991420104522442863935176119898454751842224108853773050492094979591771550195719057090304339474765387678970266869662769675981564523779491317288113053331396617198315822896591643365438134466937453119/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "a_complex": "331788258728880915239/200000000000000000000000",
+    "tau": "2555753110288270324285084256999926245965733348484040333817752473771163981900997757496392979429320091877019018464979460156936353686682888585765523216319909215444839853816783644899408583008579895477557136064823880101545248157775891146226949507905020408228449804280942909695660525234612321029733130337230324018435476220508682711886946668603382801684177103408356634561865533062546881/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "sigma": "199668211741271119084761/200000000000000000000000",
+    "eta": "1/1000000000000000000000000",
+    "beta": "1/1000000000000000000000000",
+    "q": "2123444855864837857457867253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "c": "2123444855864837857458187253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "epsilon": "1279999999999999999999998720000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/1282123444855864837857457867253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881",
+    "lambda_": "2555753110288270324285084261246815957695409063399783333891506508037815497860663939743919208265338190879261522072000030836844476667664423606305366279966222532556254088293567324990193138168726078693912236656240871521649770600639826322346847962656862632337303577331435004675252296784808040086823434676705089406114446487378345481562928233127162293001465216461688031179063848885443472643365438134466937453119/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "lambda_prime": "1277876555144135162142542132746852834712542389157763166982630271152233506910165060995722718550678144940752012839510300758376299824322979313422604671806267924833834161385175502540488846664436130955133668623828931470877146521751880749233373208704352428223078675190963549827422034167501879571956869508089927396896708377124004125619454898825470892159376664757509713898131082354170032143365438134466937453119/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "alpha_squared_power": "4246889711729675714917012382849474710077364226606412887574170237922143942836860638825715132150620283556970043697949161392341103366880883455549032687288473311645099834320801186947140505289123265235203241188801494376662090164862330464724459737816895434591882991281604697584154743671431819636088405854312708086155202621499838688487099057435339685372289939879397674629994668324693222983021862148479263794143365438134466937453119/2564246889711729675714915734506294330574915221684473666034739457695532986179669878008554562898643710118495974320979398483247400351354041373154790656387464150332331677229648994919022306671127738089732662752342137058245706956496238501533253582591295143553842649618072900345155931664996240856086260983820145206206583245751991748761090202349058215681246670484980572203737835291659935713269123731066125093762000000000000000000000000",
+    "delta": "1/8000000000000000000000000",
+    "C0": {
+      "base": 2,
+      "exponent": 210000
+    },
+    "C1": 1,
+    "kappa": "414048441354169608523/250000000000000000000000"
+  },
+  "strict_constraints": {
+    "bit_positive": "4246889711729675714915743000073754034266651515959666182247526228836018099002242503607020570679908122980981535020539843063646313317111414234476783680090784555160146183216355100591416991420104522442863935176119898454751842224108853773050492094979591771550195719057090304339474765387678970266869662769675981564523779491317288113053331396617198315822896591643365438134466937453119/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "complex_above_bit": "143456999926245965733348484040333817752473771163981900997757496392979429320091877019018464979460156936353686682888585765523216319909215444839853816783644899408583008579895477557136064823880101545248157775891146226949507905020408228449804280942909695660525234612321029733130337230324018435476220508682711886946668603382801684177103408356634561865533062546881/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "complex_below_one_over32": "5918211741271119084761/200000000000000000000000",
+    "beta_positive": "1/1000000000000000000000000",
+    "beta_below_one": "999999999999999999999999/1000000000000000000000000",
+    "leaf_saving_above_bit": "143452753036534236057633424840333817752473771163981900997757496392979429320091877019018464979460156936353686682888585765523216319909215444839853816783644899408583008579895477557136064823880101545248157775891146226949507905020408228449804280942909695660525234612321029733130337230324018435476220508682711886946668603382801684177103408356634561865533062546881/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "q_positive": "2123444855864837857457867253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "q_below_internal": "4246889711729675714915743000073754034266651515959666182247526228836018099002242503607020570679908122980981535020539843063646313317111414234476783680090784555160146183216355100591416991420104522442863935176119898454751842224108853773050492094979591771550195719057090304339474765387678970266869662769675981564523779491317288113053331396617198315822896591643365438134466937453119/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "q_below_leaf": "71730623407978847704531628163166982630271152233506910165060995722718550678144940752012839510300758376299824322979313422604671806267924833834161385175502540488846664436130955133668623828931470877146521751880749233373208704352428223078675190963549827422034167501879571956869508089927396896708377124004125619454898825470892159376664757509713898131082354170032143365438134466937453119/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "c_positive": "2123444855864837857458187253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "c_below_one": "1277876555144135162142541812746852834712542389157763166982630271152233506910165060995722718550678144940752012839510300758376299824322979313422604671806267924833834161385175502540488846664436130955133668623828931470877146521751880749233373208704352428223078675190963549827422034167501879571956869508089927396896708377124004125619454898825470892159376664757509713898131082354170032143365438134466937453119/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "q_below_reservations": "1/4000000000000000000000000",
+    "lambda_above_tau": "4246889711729675714915743000073754034266651515959666182247526228836018099002242503607020570679908122980981535020539843063646313317111414234476783680090784555160146183216355100591416991420104522442863935176119898454751842224108853773050492094979591771550195719057090304339474765387678970266869662769675981564523779491317288113053331396617198315822896591643365438134466937453119/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "lambda_above_sigma": "143461246815957695409063399783333891506508037815497860663939743919208265338190879261522072000030836844476667664423606305366279966222532556254088293567324990193138168726078693912236656240871521649770600639826322346847962656862632337303577331435004675252296784808040086823434676705089406114446487378345481562928233127162293001465216461688031179063848885443472643365438134466937453119/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "lambda_above_internal": "4246889711729675714915743000073754034266651515959666182247526228836018099002242503607020570679908122980981535020539843063646313317111414234476783680090784555160146183216355100591416991420104522442863935176119898454751842224108853773050492094979591771550195719057090304339474765387678970266869662769675981564523779491317288113053331396617198315822896591643365438134466937453119/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "lambda_prime_above_lambda": "4246889711729675714915743000073754034266651515959666182247526228836018099002242503607020570679908122980981535020539843063646313317111414234476783680090784555160146183216355100591416991420104522442863935176119898454751842224108853773050492094979591771550195719057090304339474765387678970266869662769675981564523779491317288113053331396617198315822896591643365438134466937453119/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "compact_leaf": "71730623407978847704531628163166982630271152233506910165060995722718550678144940752012839510300758376299824322979313422604671806267924833834161385175502540488846664436130955133668623828931470877146521751880749233373208704352428223078675190963549827422034167501879571956869508089927396896708377124004125619454898825470892159376664757509713898131082354170032143365438134466937453119/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "compact_reservations": "1/4000000000000000000000000",
+    "lambda_prime_below_one": "2123444855864837857457867253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881/1280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "epsilon_positive": "1279999999999999999999998720000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/1282123444855864837857457867253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881",
+    "epsilon_below_one": "2123444855864837857459147253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881/1282123444855864837857457867253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881",
+    "guard_width": "2123444855864837857459147253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881/1282123444855864837857457867253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881",
+    "K_geometry": "962123444855864837857458187253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881/1282123444855864837857457867253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881000000000000000000000000",
+    "K_dominates_log": "2123444855864837857458185129702309422619753384049579870204441390155650853001921634548433682828765224308982883208249919768640927689860196878153704493556398145479261219496303727435987169725254220368871865017732965253808611916743079698097668442169323657670558182245154525006188911173311391592957913944240104982863579745503964307941997882906231844748954697389111572761077022494725366348459996615416716913143365438134466937453119/1282123444855864837857457867253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881000000000000000000000000",
+    "record_suffix": "2123444855864837857459147253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881/1282123444855864837857457867253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881",
+    "phase_local": "16987558846918702859671895901732466434823029280027410991792543324521102481846494664489403828081750639044893006636144611134542157429005002919921001849680924308640131523267785944014060518672337534433191498215212669113782959653577835064485207511702326096119831845500305733051949738660154387894871357314748326705904939877475084971757706104609986729112301394821114285843500543304500362790393055346854545080143365438134466937453119/10256987558846918702859662938025177322299660886737894664138957830782131944718679512034218251594574840473983897283917593932989601405416165492619162625549856601329326708918595979676089226684510952358930651009368548232982827825984954006133014330365180574215370598472291601380623726659984963424345043935280580824826332983007966995044360809396232862724986681939922288814951341166639742853076494924264500375048000000000000000000000000",
+    "phase_boundary": "3397511769383740571933353481590608595094319889711679680626278698815546706902885037114802552421878259857775179502069464742861033096072608824590901409795643245178764388391002203142679171063575647288670690720374082727520698865614630158073743219557866723823353067667024628552968410672183648418836209090283666844838553471101488936269058587623696549122955842883283233882427609992706080329197115935254245041743365438134466937453119/2051397511769383740571932587605035464459932177347578932827791566156426388943735902406843650318914968094796779456783518786597920281083233098523832525109971320265865341783719195935217845336902190471786130201873709646596565565196990801226602866073036114843074119694458320276124745331996992684869008787056116164965266596601593399008872161879246572544997336387984457762990268233327948570615298984852900075009600000000000000000000000",
+    "gamma_sublinear": "1/2000000000000000000000000",
+    "cell_above_band": "2559999999999999999999996157876555144135162142542132746852834712542389157763166982630271152233506910165060995722718550678144940752012839510300758376299824322979313422604671806267924833834161385175502540488846664436130955133668623828931470877146521751880749233373208704352428223078675190963549827422034167501879571956869508089927396896708377124004125619454898825470892159376664757509713898131082354170032143365438134466937453119/5128493779423459351429831469012588661149830443368947332069478915391065972359339756017109125797287420236991948641958796966494800702708082746309581312774928300664663354459297989838044613342255476179465325504684274116491413912992477003066507165182590287107685299236145800690311863329992481712172521967640290412413166491503983497522180404698116431362493340969961144407475670583319871426538247462132250187524000000000000000000000000",
+    "prime_interval_packing": "2123444855864837857459147253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881/1282123444855864837857457867253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881",
+    "alpha_positive": "4246889711729675714917012382849474710077364226606412887574170237922143942836860638825715132150620283556970043697949161392341103366880883455549032687288473311645099834320801186947140505289123265235203241188801494376662090164862330464724459737816895434591882991281604697584154743671431819636088405854312708086155202621499838688487099057435339685372289939879397674629994668324693222983021862148479263794143365438134466937453119/2564246889711729675714915734506294330574915221684473666034739457695532986179669878008554562898643710118495974320979398483247400351354041373154790656387464150332331677229648994919022306671127738089732662752342137058245706956496238501533253582591295143553842649618072900345155931664996240856086260983820145206206583245751991748761090202349058215681246670484980572203737835291659935713269123731066125093762000000000000000000000000",
+    "alpha_below_one": "2559999999999999999999998722123444855864837857457867253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881/2564246889711729675714915734506294330574915221684473666034739457695532986179669878008554562898643710118495974320979398483247400351354041373154790656387464150332331677229648994919022306671127738089732662752342137058245706956496238501533253582591295143553842649618072900345155931664996240856086260983820145206206583245751991748761090202349058215681246670484980572203737835291659935713269123731066125093762000000000000000000000000",
+    "alpha_below_one_fourth": "636814832716202743213811921243724107933651441194512003621110694185961102602080608863312925592510307246067023536546900459419508984471629459833148631409577564271437819473091447542808436162492811257197962446896732770184764648959197294918588935910006890453868779413236620388704828172577628394385476840100723593465490608816498098501785451529829214234939377681365745376304464154590290705334259070618052009646356634561865533062546881/2564246889711729675714915734506294330574915221684473666034739457695532986179669878008554562898643710118495974320979398483247400351354041373154790656387464150332331677229648994919022306671127738089732662752342137058245706956496238501533253582591295143553842649618072900345155931664996240856086260983820145206206583245751991748761090202349058215681246670484980572203737835291659935713269123731066125093762000000000000000000000000",
+    "delta_positive": "1/8000000000000000000000000",
+    "delta_below_one_eighth": "999999999999999999999999/8000000000000000000000000",
+    "short_record_fallback": "3271354963132874217400857763726438264661158943758286272695775680689409542447403963359309898641760408806334712947776706521130330108724943929055697554975465090604218590676036136569966953236063561361474033330886749355292359347328482230625006781210929181952779135324056112920988557740795724768694144502545133525313646598584018111314405734997680874059123018340739418855900385424963198304044267014110649131889536226654730572373341035412455938904408748216890817012957169694387682183022267497151936160469377746382661624630293470551933481425143857316100453095783905244174089183371111856749582488191405271555685492740719517853650933626720578351509085605892722230447768542424559353322930745575476682705713492187879317299512319979357237009722834928331315931059137660747877070265017258322828161/3282236018831013984915092140168056743135891483756126292524466505850282222309977443850949840510263948951674847130853630058556672449733172957638132040175954112425384546853950713496348552539043504754857808322997935434554504904315185281962564585716857783748918591511133312441799592531195188295790414059289785863944426554562549438414195459006794516071995738220775132420784429173324717712984478375764640120015360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "small_field_exposure": "1/1000000000000000000000000",
+    "artificial_boundary": "71815900470775349622877317590571753145991800666276759072553158508629888084459935148382932556056077993296688191103185099429481988987290805410051025875499379841696673403534752418604939311973603463344937586608408392555469757206873760562269702011481879338080717087658706697987705144043854134504110869216142144092971947993455211690572695785044731529787516597154681834106934251203123670295470265000868940490287569903685596599187640643/10256987558846918702859662938025177322299660886737894664138957830782131944718679512034218251594574840473983897283917593932989601405416165492619162625549856601329326708918595979676089226684510952358930651009368548232982827825984954006133014330365180574215370598472291601380623726659984963424345043935280580824826332983007966995044360809396232862724986681939922288814951341166639742853076494924264500375048000000000000000000000000",
+    "literal_scalar_guard": "1",
+    "row_product_gap": "23971789/25",
+    "balanced_prefix_above_kappa": "426775342864062812547937066829359884861050328199671937687202906725836596821362024038186936074027054965501399484799231448455143901631895719830678516249316978960891380679818162818899329990570300564189790251705063730862655242061418744238203492268609144574403130173459163529583013449877385031981228217202218019881943557655170534974440574416049029975245015549493555235488056917684374570963208536882895333237/320530861213966209464364466813286791321864402710559208254342432211941623272458734751069320362330463764811996790122424810405925043919255171644348832048433018791541459653706124364877788333890967261216582844042767132280713369562029812691656697823911892944230331202259112543144491458124530107010782622977518150775822905718998968595136275293632276960155833810622571525467229411457491964158640466383265636720250000000000000000000000",
+    "coordinate_movement_above_kappa": "7033672262978923640223000073754034266651515959666182247526228836018099002242503607020570679908122980981535020539843063646313317111414234476783680090784555160146183216355100591416991420104522442863935176119898454751842224108853773050492094979591771550195719057090304339474765387678970266869662769675981564523779491317288113053331396617198315822896591643365438134466937453119/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "compact_phase_layer_above_kappa": "424977926600386412334290400064292374156743701956450917731441898055579894195613157148470462846786364802757610778707226552196875430850562192745318736803535840677399684104448153816086166626717333211892829630649186394327767489997555726186187177778789006520691195884800203945754087967011419699881782376898799476424482607744686265517217196489667012060356726955483934840083310024907530427218272281998518786067/1282123444855864837857457867253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881000000000000000000000000",
+    "bulk_exposure_above_kappa": "7033672262978923640223000073754034266651515959666182247526228836018099002242503607020570679908122980981535020539843063646313317111414234476783680090784555160146183216355100591416991420104522442863935176119898454751842224108853773050492094979591771550195719057090304339474765387678970266869662769675981564523779491317288113053331396617198315822896591643365438134466937453119/2560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "Gaussian_arithmetic_above_kappa": "7246193747370685812246696802273780489116322448178317840903644370987938632834410074200595547122256483599804847711126910142446103973835559601694735879009482950917694988680058722907222793020430272829741631173706696741990700354724803561789377796117254767496293541505510982083766601233585718883183650490920613620705735730585477747279372875440923420004723821371342337026273233136750146987649863852587337929179/10256987558846918702859662938025177322299660886737894664138957830782131944718679512034218251594574840473983897283917593932989601405416165492619162625549856601329326708918595979676089226684510952358930651009368548232982827825984954006133014330365180574215370598472291601380623726659984963424345043935280580824826332983007966995044360809396232862724986681939922288814951341166639742853076494924264500375048000000000000000000000000",
+    "scalar_work_above_kappa": "12374687526794145163676528271286369150266152891547265172973123286379004605193749830217704672919543903836796796353085707108940904676543642348004317191784411251582358343139356712745267406362685749009206956678390970858482114267717280564855884961299845054603978840741656782774078464563578200595356172458560904033118902222089461244801553280139039851367217162341303481433748903720070018414188111314719588116703/10256987558846918702859662938025177322299660886737894664138957830782131944718679512034218251594574840473983897283917593932989601405416165492619162625549856601329326708918595979676089226684510952358930651009368548232982827825984954006133014330365180574215370598472291601380623726659984963424345043935280580824826332983007966995044360809396232862724986681939922288814951341166639742853076494924264500375048000000000000000000000000",
+    "dimension_above_kappa": "319469138786033790535635319962056072740948145226507621105542428838386576399478952451837405474266357597212041396813649216649040457480229627587099623095468613104178371024810124952101172557489712556946236055287223438019850820228221892372074164831330168474513907001233156066000082945005643352152746960035931726609209075509218233622883606649925378210379140629951844523562745833558057529396595021673652047654320963208536882895333237/320530861213966209464364466813286791321864402710559208254342432211941623272458734751069320362330463764811996790122424810405925043919255171644348832048433018791541459653706124364877788333890967261216582844042767132280713369562029812691656697823911892944230331202259112543144491458124530107010782622977518150775822905718998968595136275293632276960155833810622571525467229411457491964158640466383265636720250000000000000000000000"
+  },
+  "margin": "2123444855864837857457865129702309422619753384369579870204441390155650853001921634548433682828765224308982883208249919768640927689860196878153704493556398145479261219496303727435987169725254220368871865017732965253808611916743079698097668442169323657670558182245154525006188911173311391592957913944240104982863579745503964307941997882906231844748954697389111572761077022494725366348459996615416716913143365438134466937453119/1282123444855864837857457867253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881000000000000000000000000",
+  "remaining_margin": "424977926600386412334290400064292374156743701956450917731441898055579894195613157148470462846786364802757610778707226552196875430850562192745318736803535840677399684104448153816086166626717333211892829630649186394327767489997555726186187177778789006520691195884800203945754087967011419699881782376898799476424482607744686265517217196489667012060356726955483934840083310024907530427218272281998518786067/1282123444855864837857457867253147165287457610842236833017369728847766493089834939004277281449321855059247987160489699241623700175677020686577395328193732075166165838614824497459511153335563869044866331376171068529122853478248119250766626791295647571776921324809036450172577965832498120428043130491910072603103291622875995874380545101174529107840623335242490286101868917645829967856634561865533062546881000000000000000000000000",
+  "negative_controls": [
+    "next_fine_tick",
+    "zero_eta",
+    "zero_beta",
+    "unit_beta",
+    "equal_margin"
+  ],
+  "exact_grid_control": true,
+  "scope": "Final-grid refinement only; unchanged PR659 construction, costs, suppliers and conditional assumptions. No new circuit or cheaper recurrence."
+}
diff --git a/research/gauge44-notri-fine-grid/evidence/INDEPENDENT-LOCAL.json b/research/gauge44-notri-fine-grid/evidence/INDEPENDENT-LOCAL.json
new file mode 100644
index 0000000000..398cb25681
--- /dev/null
+++ b/research/gauge44-notri-fine-grid/evidence/INDEPENDENT-LOCAL.json
@@ -0,0 +1,137 @@
+{
+  "status": "PASS_INDEPENDENT_EXACT_FORWARD_AND_DUAL_ENDPOINT_FRAMES_ENTRANCES_CONES",
+  "input_file": "FULL-WORD.json.gz",
+  "content_sha256": "a9de804f194eeb39f52a4c6e54c14d93e881bec4b632694249733ed410b58113",
+  "compressed_sha256": "99991f33e1dec5511a241283e879edd7e0ccfc680196eb3ea2f20ba9812b5e58",
+  "parent_center_interface": {
+    "parent_path": "research/community-k492-audit/pr622/replay/baseline558/complex-global/base/split-centres/CANONICAL-WORD.json.gz",
+    "parent_file_sha256": "66d3c3c70983224650643a0a05a21ac6c6959f84d0f4528650601016f5a76844",
+    "transport_tau": 43,
+    "ordered_frame_bases_match": true,
+    "all_ports_match": true,
+    "transported_centers": [
+      92,
+      57,
+      81,
+      224,
+      11,
+      240,
+      9,
+      256
+    ],
+    "source_centers": [
+      92,
+      57,
+      81,
+      11,
+      9
+    ],
+    "ordered_frame_bases": [
+      [
+        256,
+        128,
+        64,
+        34,
+        16,
+        10,
+        4,
+        1
+      ],
+      [
+        256,
+        128,
+        64,
+        32,
+        16,
+        8,
+        5,
+        3
+      ],
+      [
+        256,
+        128,
+        64,
+        32,
+        17,
+        9,
+        4,
+        2
+      ],
+      [
+        256,
+        128,
+        64,
+        36,
+        20,
+        8,
+        2,
+        1
+      ],
+      [
+        256,
+        128,
+        66,
+        32,
+        18,
+        8,
+        4,
+        1
+      ],
+      [
+        256,
+        128,
+        65,
+        33,
+        17,
+        9,
+        5,
+        3
+      ],
+      [
+        256,
+        128,
+        65,
+        33,
+        16,
+        8,
+        4,
+        2
+      ],
+      [
+        256,
+        128,
+        68,
+        32,
+        16,
+        12,
+        2,
+        1
+      ]
+    ]
+  },
+  "v": 112,
+  "h": 9,
+  "R": 504,
+  "entering": 216,
+  "lowends": 120,
+  "coldends": 66,
+  "compensation_gates": 6368,
+  "local_profile": {
+    "1": 2534,
+    "2": 346,
+    "3": 458,
+    "4": 178,
+    "5": 56,
+    "8": 8
+  },
+  "width_inventory": {
+    "4": 64,
+    "5": 48,
+    "7": 54,
+    "8": 116,
+    "9": 222
+  },
+  "checked_columns": 728,
+  "elapsed_seconds": 0.6730553340166807,
+  "scope": "Exact rational full scalar map in both orientations; all literal native frame chains, center levels, dyadic units, entrance-zero response, wrapper exclusion and final helper row/column cones. No global owner admission or exponent repricing."
+}
diff --git a/research/gauge44-notri-fine-grid/evidence/INDEPENDENT-PRICE.json b/research/gauge44-notri-fine-grid/evidence/INDEPENDENT-PRICE.json
new file mode 100644
index 0000000000..d9bd535157
--- /dev/null
+++ b/research/gauge44-notri-fine-grid/evidence/INDEPENDENT-PRICE.json
@@ -0,0 +1,154 @@
+{
+  "status": "PASS_FROZEN_PROFILE_TWO_EXACT_ENGINE_AND_OUTER47_CROSSCHECK",
+  "profile_input_file": "PLAN.json",
+  "profile_input_sha256": "48c7f624ea73b317d20a31b23965a374020e6b5473c4c5c4f04f28d1df41976c",
+  "global_profile": {
+    "1": 182448,
+    "2": 24912,
+    "3": 32976,
+    "4": 12816,
+    "5": 4032,
+    "8": 576,
+    "48": 2364
+  },
+  "live": 7168,
+  "m": 73,
+  "rank_mass": 520704,
+  "deficit": 2560,
+  "prices": {
+    "native": {
+      "root": {
+        "lower": "0.001658941293644404576195",
+        "upper": "0.001658941293644404576196",
+        "lower_endpoint_residual_upper": "-1.592060217409616267352935682750038465961443136039918064269057309361224E-26",
+        "upper_endpoint_residual_lower": "2.942133876713016547555656915445881639030727504826993047256057261592897E-24",
+        "strict_rational_signs": true
+      },
+      "exact_moments": [
+        {
+          "endpoint": "331788258728880915239/200000000000000000000000",
+          "accept": true,
+          "mercator_residual": [
+            "-107304646380638767712547168163528328537019/6739986666787659948666753771754907668409286105635143120275902562304",
+            "-214609292761277535425094336327056657074037/13479973333575319897333507543509815336818572211270286240551805124608"
+          ],
+          "base_two_residual": [
+            "-15921/1000000000000000000000000000000",
+            "-199/12500000000000000000000000000"
+          ]
+        },
+        {
+          "endpoint": "414735323411101144049/250000000000000000000000",
+          "accept": false,
+          "mercator_residual": [
+            "39659886201900040914929948774106104475385609/13479973333575319897333507543509815336818572211270286240551805124608",
+            "19829943100950020457464974387053052237692805/6739986666787659948666753771754907668409286105635143120275902562304"
+          ],
+          "base_two_residual": [
+            "2942133/1000000000000000000000000000000",
+            "1471067/500000000000000000000000000000"
+          ]
+        }
+      ],
+      "outer_with_bit": {
+        "complex_b": "331788258728880915239/200000000000000000000000",
+        "bit_c": "1733427039589844234749/1000000000000000000000000",
+        "kappa": "828096882708339/500000000000000000",
+        "kappa_decimal": "0.001656193765416678",
+        "binding": "complex",
+        "strict_constraints_passed": 47,
+        "controls_rejected": [
+          "next_grid",
+          "zero_eta",
+          "zero_beta",
+          "unit_beta"
+        ]
+      }
+    },
+    "conservative": {
+      "root": {
+        "lower": "0.001658941290758112743307",
+        "upper": "0.001658941290758112743308",
+        "lower_endpoint_residual_upper": "-2.117866414490974120305657834935610336072706158972529600443745673301225E-24",
+        "upper_endpoint_residual_lower": "8.401880644015113670932637178030355086324242620983675295990586950796382E-25",
+        "strict_rational_signs": true
+      },
+      "exact_moments": [
+        {
+          "endpoint": "1658941290758112743307/1000000000000000000000000",
+          "accept": true,
+          "mercator_residual": [
+            "-57097565582826213198128864775314569860863661/26959946667150639794667015087019630673637144422540572481103610249216",
+            "-57097565582826213198128864775314569860863659/26959946667150639794667015087019630673637144422540572481103610249216"
+          ],
+          "base_two_residual": [
+            "-847146895258187711753/400000000000000000000000000000000000000000000",
+            "-21178662381454692793683/10000000000000000000000000000000000000000000000"
+          ]
+        },
+        {
+          "endpoint": "414735322689528185827/250000000000000000000000",
+          "accept": false,
+          "mercator_residual": [
+            "1415714087915079593033235572965824532113387/1684996666696914987166688442938726917102321526408785780068975640576",
+            "11325712703320636744265884583726596256907097/13479973333575319897333507543509815336818572211270286240551805124608"
+          ],
+          "base_two_residual": [
+            "8401877618911618416327/10000000000000000000000000000000000000000000000",
+            "8401887618911618416469/10000000000000000000000000000000000000000000000"
+          ]
+        }
+      ],
+      "outer_with_bit": {
+        "complex_b": "1658941290758112743307/1000000000000000000000000",
+        "bit_c": "1733427039589844234749/1000000000000000000000000",
+        "kappa": "1656193762539939/1000000000000000000",
+        "kappa_decimal": "0.001656193762539939",
+        "binding": "complex",
+        "strict_constraints_passed": 47,
+        "controls_rejected": [
+          "next_grid",
+          "zero_eta",
+          "zero_beta",
+          "unit_beta"
+        ]
+      }
+    }
+  },
+  "bit_supplier_pr": 589,
+  "bit_deficit": 10272,
+  "bit_moments_with_surcharge": [
+    {
+      "endpoint": "1733427039589844234749/1000000000000000000000000",
+      "accept": true,
+      "mercator_residual": [
+        "-43100600330766044577088869872467188970742291/26959946667150639794667015087019630673637144422540572481103610249216",
+        "-43100600330766044577088869872467188970742289/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "base_two_residual": [
+        "-799345163337715793503/500000000000000000000000000000000000000000000",
+        "-3197378653350863173989/2000000000000000000000000000000000000000000000"
+      ]
+    },
+    {
+      "endpoint": "6933708158359376939/4000000000000000000000",
+      "accept": false,
+      "mercator_residual": [
+        "22502934905675809315035333485365686073718547/13479973333575319897333507543509815336818572211270286240551805124608",
+        "5625733726418952328758833371341421518429637/3369993333393829974333376885877453834204643052817571560137951281152"
+      ],
+      "base_two_residual": [
+        "8346798366759439729359/5000000000000000000000000000000000000000000000",
+        "16693606733518879458833/10000000000000000000000000000000000000000000000"
+      ]
+    }
+  ],
+  "gain_over_pr635_percent": "1.21939602565193386056679242361768432405495511742713860536434739503117793959",
+  "input_sha256": {
+    "research/complex-k492-owner-repair/vendor/multicold/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482",
+    "research/complex-k492-owner-repair/vendor/multicold/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098",
+    "research/complex-k492-owner-repair/vendor/multicold/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c",
+    "package:inputs/PR589-EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4"
+  },
+  "scope": "Independent arithmetic for the exact nominated all72 profile. Complete local, controller and finite invoice admission are separately replayed by the package driver; this receipt does not replace them. The cited PR589 bit supplier is unchanged and its exceptional-residue surcharge is retained. Any alternative c is only a headroom comparison."
+}
diff --git a/research/gauge44-notri-fine-grid/evidence/REPLAY.json b/research/gauge44-notri-fine-grid/evidence/REPLAY.json
new file mode 100644
index 0000000000..e87bd8c3b6
--- /dev/null
+++ b/research/gauge44-notri-fine-grid/evidence/REPLAY.json
@@ -0,0 +1,63 @@
+{
+  "status": "PASS_FRESH_PR659_AND_FINE_GRID",
+  "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "source_commits": {
+    "pr659": "4982f0ca66ffe0960b5a6451deb5b66b1039326b",
+    "pr635": "a6895a69f8ad98ab45777b03e9e6f48888c39f6f",
+    "pr589": "a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46"
+  },
+  "python": "3.14.7 (main, Aug  5 2026, 10:29:49) [Clang 21.0.0 (clang-2100.1.1.101)]",
+  "kappa": "414048441354169608523/250000000000000000000000",
+  "kappa_decimal": "0.001656193765416678434092",
+  "steps": [
+    {
+      "stage": "manifest",
+      "exit_code": 0,
+      "seconds": 0.036,
+      "log_sha256": "5a9b0882b8e5a06e0b63e99669252aeedbe6b8b33311c7bc7f75f9aa77b2711a"
+    },
+    {
+      "stage": "base-word",
+      "exit_code": 0,
+      "seconds": 3.47,
+      "log_sha256": "44c15c4020dc210b1529da8ebaab214c36fa5d50e9c6dc1e9a4e9ef4e8477caa"
+    },
+    {
+      "stage": "no-triangle-word",
+      "exit_code": 0,
+      "seconds": 2.552,
+      "log_sha256": "5c7292836c01cfb326822cc3cadc8249e69bfea80b0af3bfcdf502d9a2415849"
+    },
+    {
+      "stage": "layers-and-locals",
+      "exit_code": 0,
+      "seconds": 163.449,
+      "log_sha256": "2f0285e1425facc39211ec5d03948ffe7f7edfa9f9eca4532c022f6ca1d05064"
+    },
+    {
+      "stage": "independent-local",
+      "exit_code": 0,
+      "seconds": 0.733,
+      "log_sha256": "40724bc321544c804c1fcce0d5cb0743ed38b7abb76fec02a3c6ebf1c51dc257"
+    },
+    {
+      "stage": "global-admission",
+      "exit_code": 0,
+      "seconds": 14.992,
+      "log_sha256": "b0388791bcd14428e1eaeb8ae0780fa2e99f43539a1eaf5809fdb0dc5fb5af01"
+    },
+    {
+      "stage": "independent-price",
+      "exit_code": 0,
+      "seconds": 0.405,
+      "log_sha256": "b60d3038366f8d8f26befdc9a8525f4443fe006a286eb3f3932e8de5906a1b5f"
+    },
+    {
+      "stage": "fine-grid",
+      "exit_code": 0,
+      "seconds": 0.121,
+      "log_sha256": "fd67ee11e5e02a3897891cc5270206e697603cd77c7539deb3c0826a0be6673a"
+    }
+  ],
+  "scope": "Fresh complex reconstruction, local and global admission; unchanged cited PR589 bit supplier is repriced, not rebuilt. Final-grid change only."
+}
diff --git a/research/gauge44-notri-fine-grid/verify.py b/research/gauge44-notri-fine-grid/verify.py
new file mode 100644
index 0000000000..83851beee5
--- /dev/null
+++ b/research/gauge44-notri-fine-grid/verify.py
@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Fresh PR659 construction/admission replay followed by a final-grid refinement.
+
+Standard library only. Source commits must already be present in the Git object
+database; see README.md. Does not fetch, alter source packages or selected-result.
+"""
+import argparse
+import hashlib
+import io
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tarfile
+import time
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def export(commit, package, destination):
+    result = subprocess.run(['git','archive',commit,package],cwd=ROOT,capture_output=True)
+    need(result.returncode == 0, 'Fetch the pinned source commits in README.md before replaying')
+    with tarfile.open(fileobj=io.BytesIO(result.stdout)) as archive:
+        for entry in archive.getmembers():
+            relative = Path(entry.name)
+            need(not relative.is_absolute() and '..' not in relative.parts, 'unsafe archive path')
+            if entry.isdir():
+                continue
+            need(entry.isfile(), 'unexpected source entry type')
+            target = destination/relative
+            target.parent.mkdir(parents=True,exist_ok=True)
+            target.write_bytes(archive.extractfile(entry).read())
+    return destination/package
+
+
+def main():
+    need(__debug__, 'Inherited verifiers require assertions; do not use -O')
+    ap=argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--out',type=Path,required=True)
+    args=ap.parse_args()
+    out=args.out.resolve()
+    need(not out.exists(), 'Use a new output directory')
+    out.mkdir(parents=True)
+    pins=json.loads((HERE/'SOURCES.json').read_text())
+    package=export(pins['pr659'],'research/gauge44-notri-layered',out/'pr659')
+    export(pins['pr635'],'research/complex-571-cold14-st2',out/'pr635')
+    environment=dict(os.environ,PYTHONDONTWRITEBYTECODE='1',PYTHONUTF8='1',PYTHONINTMAXSTRDIGITS='0')
+    environment.pop('PYTHONOPTIMIZE',None)
+    steps=[]
+    def run(label,script,*arguments):
+        start=time.monotonic()
+        log=out/(label+'.log')
+        with log.open('w') as stream:
+            result=subprocess.run([sys.executable,'-B',str(script),*map(str,arguments)],cwd=ROOT,env=environment,stdout=stream,stderr=subprocess.STDOUT)
+        steps.append(dict(stage=label,exit_code=result.returncode,seconds=round(time.monotonic()-start,3),log_sha256=hashlib.sha256(log.read_bytes()).hexdigest()))
+        (out/'STEPS.json').write_text(json.dumps(steps,indent=2)+'\n')
+        need(result.returncode == 0, label+' failed; see '+str(log))
+        print('PASS',label,flush=True)
+    run('manifest',package/'verify_manifest.py')
+    run('base-word',package/'construction/reproduce.py','--main',ROOT,'--pr635',out/'pr635','--out',out/'base','--until','word')
+    run('no-triangle-word',package/'construction/notri/reproduce_notri.py','--main',ROOT,'--pr635',out/'pr635','--word-dir',out/'base','--out',out/'notri','--word-only')
+    run('layers-and-locals',package/'construction/layers_np/reproduce_np.py','--main',ROOT,'--pr635',out/'pr635','--notri-dir',out/'notri','--hamming',out/'base/hamming','--out',out/'layered')
+    run('independent-local',package/'independent/audit_local.py','--word',out/'layered/layers/FULL-WORD.json.gz','--main',ROOT,'--output',out/'INDEPENDENT-LOCAL.json')
+    run('global-admission',package/'verify_global.py','--main',ROOT,'--local',out/'layered/local','--work',out/'global')
+    run('independent-price',package/'independent/price_profile.py','--main',ROOT,'--output',out/'INDEPENDENT-PRICE.json')
+    run('fine-grid',HERE/'certify.py','--assembly',out/'global/ASSEMBLY.json','--out',out/'CERTIFICATE.json')
+    certificate=json.loads((out/'CERTIFICATE.json').read_text())
+    (out/'REPLAY.json').write_text(json.dumps(dict(status='PASS_FRESH_PR659_AND_FINE_GRID',base_commit=pins['base_commit'],source_commits={k:pins[k] for k in ('pr659','pr635','pr589')},python=sys.version,kappa=certificate['kappa'],kappa_decimal=certificate['kappa_decimal'],steps=steps,scope='Fresh complex reconstruction, local and global admission; unchanged cited PR589 bit supplier is repriced, not rebuilt. Final-grid change only.'),indent=2)+'\n')
+    print('PASS_FRESH_PR659_AND_FINE_GRID',certificate['kappa_decimal'])
+
+
+if __name__=='__main__':
+    main()