diff --git a/research/first-face-reference-join/PROOF.md b/research/first-face-reference-join/PROOF.md
new file mode 100644
index 0000000000..dd35fbaf22
--- /dev/null
+++ b/research/first-face-reference-join/PROOF.md
@@ -0,0 +1,334 @@
+# A complete sparse transport/consumer/return interface
+
+## 1. Result and hypotheses
+
+This note composes the separately pinned
+[first-face tape transport](../sparse-halo-tape-transaction/PROOF.md) and
+[shrinking-reference halo consumer](../shrinking-reference-halo/PROOF.md).
+The composition itself is the result: a sorted saved stream enters the
+consumer without host regrouping; its output returns to exactly the dense
+boundary coordinates; every codec operation and its storage are priced.
+The retained #4100 first-face geometry and #6880 numerical splice are
+predecessor mechanisms, not new claims here.
+
+Let `L=2^ell`, `N_i=2^(k_i+ell)`, `k_i>=1`, `L>4A`, and `0<=b<A`.
+There are `g` active axes and an optional complete binary spectator prefix.
+For each axis fix one real periodic reference matrix `H_i=I-E_i`, where
+`E_i` has cyclic half-bandwidth `W_i` and `||E_i||_infty<=1-delta_i`, with
+`0<delta_i<=1`. All numerical pages and comparisons refer to this same
+matrix; independently rounded windows are not permitted. Identity-hole
+rows and period cuts are allowed.
+
+The numerical plans have `J_i>=1`, `b_i=(J_i-1)W_i<=b`, a common grid
+`2^-q`, radius `R`, and dyadic normalizers `a_i=2^u_i` satisfying
+`a_i delta_i>=1` and `q>=u_i`. The incoming dense values are exactly on that
+grid and have component-l1 radius at most R. Their two sign-magnitude
+components have the consumer's exact width `q+R.bit_length()+1`; the
+transport payload is their concatenation, of width P. There is no free
+precision conversion at the interface. A finer common grid may be supplied
+before entry, with that caller work and radius accounted separately.
+
+For target intervals of lengths `m_i`, each consumer rectangle is the
+expansion by `b_i`. The transport may save the larger common-b expansion.
+Both expanded lengths are below `N_i`, because `L+2b<2L<=N_i`.
+Thus each local offset has one unambiguous periodic coordinate. The
+canonical input layout and dyadic descriptor remain transport premises.
+
+**Composed interface theorem.** Under these hypotheses and the two pinned
+component theorems, the sequential codec in `join.py` preserves the exact
+saved incoming numerical values and gives every discarded target exactly
+the value produced by the consumer's global-reference rounded recurrence.
+It preserves the current dense core value at every kept coordinate. The
+complete movement and scalar-macro bill is the one in Section 5. This is
+not an unconditional multiplication theorem: an actual same-reference
+numerical core and the outer caller still require their own admission.
+
+## 2. Rectangle grouping, crop, and exact input identity
+
+For core c, first face f and side s, let the target local intervals be
+
+```text
+i < f: [A,L-A)
+i = f: [0,A) or [L-A,L)
+i > f: [0,L).
+```
+
+Write their lower endpoints and lengths as `lo_i,m_i`, and absolute target
+lower endpoints as `t_i=c_i L+lo_i`. The transport sorts complete keys
+
+```text
+spectator || core fields || one-hot face || side
+          || common-b expanded local offsets || canonical source address.
+```
+
+All fields have fixed declared widths. Hence a rectangle is a contiguous
+stream block, ordered lexicographically by its local offsets. A source
+address is redundant after the full offset tuple because the expanded
+intervals have no periodic aliases. One-hot binary ordering may place
+larger face indices earlier; the codec requires contiguous grouping, not
+increasing numerical face index.
+
+`Codec.run` reads the next prefix through actual transport tape reads and
+unit moves. If it differs from the current prefix, the previous rectangle
+is consumed and cleared before the new descriptor is constructed. Strictly
+increasing prefixes are checked. No dictionary, indexed payload lookup,
+array of rectangle bodies, or host sort performs the grouping. Live tuples
+hold only the current encoded geometry/control fields. In particular,
+payloads are never stored in a host container by the codec.
+
+For a common-b offset `u_i`, keep the record precisely when
+
+```text
+b-b_i <= u_i < m_i+b+b_i,
+```
+
+then recode it as `v_i=u_i-(b-b_i)`. This selects exactly the smaller
+consumer domain and preserves lexicographic order. The coordinate identity
+
+```text
+(t_i-b_i)+v_i = (t_i-b)+u_i
+```
+
+holds over the integers, including when either side is outside the chosen
+canonical period. The codec additionally checks the supplied canonical
+source suffix against the right-hand side reduced modulo `N_i`.
+
+An odometer validates every full common-b offset exactly once before the
+optional crop. The declared rectangle volume must match the observed
+record count. The cropped count must match the consumer's volume. These
+checks reject a missing/duplicated offset, a malformed prefix, or a foreign
+source suffix on the admitted fixed-width schema. They are executable
+boundary checks; the transport theorem already guarantees completeness
+for its own output.
+
+The consumer's shorter offset fields receive the recoded unsigned key.
+Each of the P payload bits is read from its current transport head and
+written to the current consumer head with an explicit unit step. The codec
+does not decode/re-encode the numeric payload. Therefore it neither changes
+rounding nor silently normalizes a noncanonical negative zero. The
+consumer's existing signed-word reader rejects that representation.
+
+## 3. Consumer chronology and exact return identity
+
+The transport saves the entire common-b input before core mutation. Its
+saved role remains unchanged throughout consumer execution. One
+`TensorWorkspace` is allocated before the first rectangle and reused for
+all rectangles. Its eight physical roles return blank after each output
+has been consumed; the same protected reference archive supplies every
+local page. The generic proof charges the whole archive scan, including
+other axes, and does not substitute a unit-cost coefficient oracle.
+
+The consumer retains the immutable input of each tensor axis until all
+lines of that axis finish. Its shrinking-domain theorem establishes exact
+agreement with the corresponding restriction of the full-period rounded
+recurrence. This full dense recurrence is a proof/oracle device; the
+production composition evaluates only the saved rectangles.
+
+An output key contains offsets relative to the consumer's original
+expanded lower endpoints. A target coordinate has offset `b_i+r_i`, with
+`0<=r_i<m_i`, so its lifted coordinate is
+
+```text
+(t_i-b_i)+(b_i+r_i) = t_i+r_i.
+```
+
+The codec checks target membership, reduces each coordinate modulo the
+dyadic period, prefixes the spectator bits, and emits the canonical global
+key. It copies the returned payload cells unchanged. Output order is
+irrelevant because the transport supplies a complete sparse sort before
+the dense merge.
+
+The first-face rectangles partition the discarded output coordinates:
+choose the first local coordinate outside `[A,L-A)`, then its unique side.
+Thus returns from different rectangles are disjoint and exhaustive. The
+transport's merge independently checks that semantic target set, rejecting
+missing, duplicate, or kept-row returns. It uses the *current* core stream
+only for kept interiors. No original input is substituted for a current
+core value, and no mutated core value is used as a saved halo input.
+
+## 4. Numerical implication and the retained core premise
+
+Use the component-l1 norm for each complex payload and the maximum of that
+norm over coordinates. Let `s_i=2W_i+1`. The pinned consumer theorem gives
+the per-axis numerical and tail allowances
+
+\[
+ \nu_i=\frac{(s_iR+2)2^{-q}}{\delta_i},\qquad
+ R\tau_i=\frac{R(1-\delta_i)^{J_i}}{a_i\delta_i}.
+\]
+
+Since the codec preserves exact grid values and keys, it adds no numerical
+error. Every returned target differs from
+`[product_i (H_i^-1/a_i)] x` by at most
+
+\[
+ E_{\rm halo}=\sum_i\nu_i+R\sum_i\tau_i.
+\]
+
+This bound uses actual intermediate radii. It does not assume additivity
+or nonexpansiveness of rounded programs. The same-reference consumer
+contract and all its precision/normalization premises remain in force.
+
+If an independently admitted core algorithm produces the kept coordinates
+with error `E_keep` against the same `H_i`, normalizers, input and output
+grid, then the complete splice has error at most
+`max(E_keep,E_halo)`, because kept and discarded outputs have disjoint
+ownership. That conditional implication is the splice used in #6880.
+The test core here complements opaque payload bits and may produce invalid
+numeric words at interiors; it is only a destructive ownership test.
+Neither its output nor the successful return tests establish `E_keep`.
+
+## 5. Complete generic time and retained backing
+
+Distinguish two models. The transport program has finite local control and
+executes 14-symbol tape reads/writes/unit moves. Its four-bit block
+simulation costs at most ten binary tape primitives per reported action,
+up to a further fixed control compilation factor. The numerical consumer
+and joined codec execute binary data movement but use explicitly priced
+scalar/control macros for bounded integers. They are not claimed to be a
+fully lowered transition table. Combining raw symbol and binary counts as
+one exact bit-step count would be incorrect.
+
+Let `M` be dense records, `C_B` all common-b copies, `Q` returned targets,
+and `R_rect` rectangles. Let `C_r` be the cropped input volume of rectangle
+r, `K_r` its consumer key width, and `G=sum_i N_i s_i` the complete
+reference archive's coefficient count. Let w bound the **entire encoded
+control block**, including full keys/payloads, absolute origins, all axis
+plans, periods, exact gap data, loop counters and cumulative record
+counters. In particular, `log J_i` cannot be inferred from halo size when
+`W_i=0` and is included explicitly.
+
+The codec costs
+
+\[
+ O((C_B+Q+R_{\rm rect})w^2)
+ \tag{1}
+\]
+
+bit work, in addition to the numerical consumer. Copies use actual tape
+primitives; comparisons, shifts, additions, modulo powers of two, field
+encoding/decoding and descriptor construction admit the conservative
+ordinary binary macro bound in (1). Aggregate axis work does not introduce
+an unexplained extra g factor: fields are sequential parts of one encoded
+block whose lengths sum to O(w). Coordinatewise operations cost their own
+field widths. If the dimension-factor widths are `ell_i`, successive
+prefix products cost at most a constant times
+`sum_i (sum_{j<i} ell_j) ell_i <= (sum_i ell_i)^2/2 = O(w²)`.
+Per-product additions and rewinds add `O(gw)<=O(w²)`; prefix operand
+lengths are not incorrectly counted as occurring only once.
+Cumulative counter widths are also included. A fixed number of scratch
+control tapes suffices.
+
+The receipt reports record width, plan-descriptor bits and counter bits
+separately, then their summed carrier units and the corresponding quadratic
+tariff units. These are an argument for an O(1) multiple, **not measured
+binary transitions for the scalar macros**. Source-production macros and
+the numerical consumer's arithmetic bill are separate.
+
+The reference archive is prepared once per group and reused. Write
+`T_ref` for its complete separately priced source production and
+quantization. The whole joined generic transaction has the bill
+
+\[
+ T_{\rm ref}+O\!\left(M(P+B)+w^2\left[
+ C_B+R_{\rm rect}gG+
+ \sum_r C_r\sum_i(J_is_i+K_r+1)\right]\right).
+ \tag{2}
+\]
+
+The first term inside brackets includes full-key transport sort, sparse
+codec, return sort, and cleanup, using `K_B=2B+3g+1=O(w)` and `Q<=C_B`.
+Every rectangle has at least one saved record, so `R_rect<=C_B`. The term
+`R_rect g G` keeps the full one/two archive scans per rectangle/axis; it is
+not silently treated as a local polynomial. For unequal halos do not
+replace `C_B` by the smaller `sum C_r`: their ratio can grow with dimension.
+
+The retained space includes both dense input/output roles, all common-b
+saved/return bodies, historical bucket extents, the largest consumer
+rectangle/page, the archive, and source-production scratch. One bound is
+
+\[
+ O(MP+C_Bw+G(q+2)+\max_{r,i} d_{r,i}s_i(q+2)+w)
+   +S_{\rm ref}.
+ \tag{3}
+\]
+
+There are 30 transport roles, eight local consumer roles, one archive and
+one reusable temporary table role, plus a fixed number of scalar/control
+roles. Their count does not grow with axes or rectangles. Historical blank
+backing remains paid after erasure. Clears traverse current live bodies,
+so a long rectangle does not impose its old extent on every later short
+face. The actual fixture explicitly clears the archive after its final
+use; source-cache erasure has the separately proved producer tariff.
+
+## 6. Conditional source-budget substitution
+
+For #4100's retained balanced-group regime, the pinned consumer proof
+establishes eventual `w=O(p)`, `J_i=16p^4`, `W_i<p`, and
+`b_i<16p^5`. Keep `A=ceil(p^48)` and
+`L=2^ceil(400 log2 p)` and choose a common `max b_i<=b<A`.
+The known copy bound is
+
+\[
+ C_B\le6M(gA/L)(1+2A/L)^{g-1}=O(MgA/L)
+\]
+
+when `gA/L` is bounded. It controls the full common-b volume independently
+of how much is later cropped.
+
+The consumer proof uses balanced groups of size between `floor(g/2)` and
+g, with `g=Theta(p^beta)`, `d=Theta(p^epsilon)`,
+`beta>1-epsilon`, and the other retained strict inequalities. The many
+long sides of a rectangle then absorb repeated full archive scans. That
+absorption is conditional on those growing-group inequalities; generic
+fixed-dimensional calls retain the term in (2). Offline source production
+is separately `2^o(p)=o(V)` for full bit volume `V=MP`.
+
+Across `O(d/g)` balanced groups, dense gather/return costs `O(Vd/g)`.
+Transport and codec's sparse charge is `O(VdAp/L)`, while the complete
+consumer charge is `O(VdgAp^6/L)`. Thus the combined additional charge is
+
+\[
+ O(Vd/g+VdgAp^6/L)+2^{o(p)},
+\]
+
+inside the inherited conservative sparse halo allowance. With `A=p^48`
+and `L>=p^400`, the second exponent is at most
+`epsilon+beta+54-400<0`. This does not improve κ or establish the core,
+all-column maps, full precision interface, compiler or outer recovery.
+It replaces two named sparse-interface implementation premises with a
+concrete composition and a complete conditional bill.
+
+## 7. Executed evidence and its limits
+
+The source-bound fixture is the retained original
+`Reference(61,3,2,1,8,32)`, with period 64. The separate oracle checks all
+4,096 original H entries, a certified gap `6255/8192`, cyclic bandwidth 4,
+identity-hole rows 11/32/53, and nonzero across-period entries `(0,63)` and
+`(63,0)`. Plans use `J=2`, `q=28`, `R=1`, and normalizer 2. Transport uses
+`L=32`, `A=5`, `b=4`: four rectangles, 52 saved inputs, 20 targets.
+
+Three distinct numerical checks are retained. The streamed codec output
+matches a separately loaded rectangle consumer bit for bit. A separately
+written whole-grid recurrence, with independent toward-zero arithmetic and
+global axis indexing, matches all target bits. Finally, exact Gaussian
+elimination solves the original `Hy=x/2` with both complex components and
+checks every residual; the actual target error is below the consumer bound.
+The bound is deliberately loose for J=2, so it alone would not be an adequate
+codec corruption control; exact bit equality is also required.
+
+Independent signed fixtures additionally cover a spectator coordinate,
+two axes with unequal halos `(1,0)` and `(1,2)`, partial crops, irregular
+identity holes and real wrap interactions. During codec/merge/erase the
+independent review disables tape constructors and diagnostic `inspect`/
+`snapshot` calls. It checks the same fixed roles, current and historical
+erasure invariants, and the unchanged protected archive. Raw negative
+zero and a changed canonical source suffix are rejected.
+
+The joined controls also reject offset corruption, omitted wrap handling,
+a missing saved input and a wrong return key. A payload-magnitude mutation
+that remains within the fixture's radius is detected by exact delivery
+comparison. Source pins, normal/optimized replays and the independent
+review are reproducibility evidence. They do not constitute independent
+human or formal proof-kernel acceptance. All five selected assumptions
+remain; **No new κ**.
diff --git a/research/first-face-reference-join/README.md b/research/first-face-reference-join/README.md
new file mode 100644
index 0000000000..4f9830826e
--- /dev/null
+++ b/research/first-face-reference-join/README.md
@@ -0,0 +1,179 @@
+# Source-bound first-face halo transaction
+
+**Result:** a complete, explicitly priced interface joining the new physical
+first-face transport to the new shrinking-reference numerical consumer.
+Original halo values are copied before core mutation, streamed into the
+consumer through a checked coordinate codec, and returned exactly once to
+the discarded dense coordinates. An actual retained Gaussian reference
+exercises the whole interface, including identity holes and a period cut.
+
+**No new κ.** This supplies the sparse transport/consumer/return implication
+that the component proofs require. An actual same-reference core and the
+full outer multiplication proof remain separate obligations; all five
+selected assumptions remain.
+
+## What the integrated contribution adds
+
+The two component packages are retained intact:
+
+- [Sparse halo tape transaction](../sparse-halo-tape-transaction/README.md)
+  supplies the 30-role finite-alphabet enumerator, complete sparse-key sort,
+  pre-copy chronology and unique return left open by #4870.
+- [Shrinking reference halo](../shrinking-reference-halo/README.md) supplies
+  the numerical rectangle consumer from global reference band entries,
+  with shrinking domains, actual-input rounding bounds, paid page exposure,
+  eight reused local roles, and explicitly priced scalar/source arithmetic.
+
+The composition in [PROOF.md](PROOF.md) verifies their exact common
+contract. A sorted rectangle prefix is consumed as one contiguous block;
+there is no host dictionary or payload-array regrouping. A common saved
+radius may be cropped to unequal numerical radii in one sparse pass. The
+codec checks complete offsets and their canonical source suffixes, copies
+payload cells unchanged, and converts only target keys back to canonical
+global coordinates. The numerical payload grid, signed-word convention,
+periodic coordinates, reference identity and dyadic normalizers agree.
+
+The inherited first-face combinatorics and copy-volume formula are not
+reproved as new discoveries. The direct-Neumann degree `16p^4` was already
+available in #6880. The new result is the implemented, proved and tested
+composition, including its full physical and scalar-macro accounting.
+
+## Complete cost and scientific scope
+
+Let M be dense scalars, P their bit width, B their full coordinate width,
+`C_B` all common-radius copies, `C_r` a cropped consumer rectangle's volume,
+`R_rect` the number of rectangles, `G=sum_i N_i(2W_i+1)` the group archive
+size, and w the complete encoded data/control width. The generic bound is
+
+```text
+T_ref + O(M(P+B) + w^2 [C_B + R_rect g G
+                     + sum_r C_r sum_i(J_i(2W_i+1)+K_r+1)]).
+```
+
+It retains source production `T_ref`, every repeated archive scan, all
+common-radius copies, descriptor/key conversion, radix work, output copies,
+returns and erasures. It does not charge a dense scan per numerical axis.
+All retained backing, including erased temporary tables and bucket tails,
+stays in the space bill. A fixed number of physical data/control roles
+suffices; no role is allocated per rectangle or tensor dimension.
+
+The transport's reported tape actions use a 14-symbol alphabet and have a
+constant-factor binary simulation. The consumer's reported data moves are
+binary; its bounded integer arithmetic and the codec's sparse metadata
+arithmetic use a separate ordinary quadratic bit tariff. The complete
+composition is not advertised as a fully emitted binary transition table.
+The descriptor width includes `log J` even when bandwidth is zero, and
+includes cumulative record counters.
+
+Under the pinned balanced-group caller hypotheses, the complete additional
+charge is `O(V d/g + V d g A p^6/L) + 2^o(p)`. This fits the inherited
+conservative sparse halo allowance. It is a conditional implementation
+substitution, not a stronger selected exponent or proof of the missing
+core/outer premises. The generic formula remains necessary when a finite
+instance does not satisfy the archive-amortization conditions.
+
+## Reproduce the complete contribution
+
+Canonical upstream base:
+`7c49fe32c55de02c2c873655c804b16e4c3fef0a`.
+The exact remote component tree parents are
+`a2f3ce7358e8103f6eccd404e594276e9ccc04d8` (consumer) and
+`630c9c2a5d6373ca103c55108bb606b4868bc6fd` (both components).
+`SOURCES.json` pins live imported files by Git blob, SHA256 and these
+heads; the final contribution descends from the combined parent.
+
+With Python 3.12 and the standard library, from the repository root:
+
+```sh
+python3 -B research/first-face-reference-join/replay_all.py
+```
+
+Expected final line: `PASS_COMPLETE_FIRST_FACE_HALO_PACKAGE`.
+The wrapper sequentially runs the registered checks for transport,
+consumer, and join. It does not run unrelated repository suites. For only
+the join, use:
+
+```sh
+python3 -B scripts/research_package.py --package research/first-face-reference-join
+```
+
+Expected: `PASS_REGISTERED_RESEARCH_PACKAGE`. The join registers normal
+and optimized (`-O`) runs of the actual-reference transaction and the
+independent whole-grid review. Failures use explicit exceptions, not
+assertions. No third-party dependencies are required.
+
+## Evidence
+
+The actual source is `Reference(61,3,2,1,8,32)`, period 64. Its 4,096
+original entries give a certified row gap `6255/8192`, identity-hole rows
+11, 32 and 53, and nonzero coefficients across `0 <-> 63`. The fixture uses
+`L=32`, `A=5`, saved radius 4, numerical half-bandwidth 4, two terms,
+28-bit grid, radius one and normalizer two.
+
+Four rectangles save 52 inputs and return 20 targets. Three complementary
+checks establish what those outputs mean:
+
+1. The streamed codec matches a separately loaded rectangle consumer
+   bit for bit, detecting changes too small for a loose error bound.
+2. A separately written whole-period recurrence with independent arithmetic
+   and global indexing matches every returned bit.
+3. Exact rational elimination solves the original `H y=x/2` and checks
+   every residual. Maximum target error is about `0.0003996004385`, below
+   the proved `0.036611087107` bound. These decimals summarize exact
+   rational comparisons; two terms are a finite interface fixture, not an
+   asymptotic precision allocation.
+
+The positive transaction executes 3,753,372 transport symbol actions and
+1,055,928 consumer binary actions. The displayed conservative binary-tape
+primitive bound is `10*B_actions+C_actions=38,589,648`, before scalar/control
+macros and their fixed control compilation factor. It retains 21,740
+transport symbol cells and 41,978 consumer binary cells, including blank
+backing after cleanup. Source production and coefficient arithmetic have
+their separate retained bills; these figures are not a Python memory or
+runtime benchmark.
+
+The separately assigned whole-grid review also checks a spectator fixture
+and two signed two-axis fixtures with unequal numerical radii `(1,0)` and
+`(1,2)`. The two-axis cases return 448 and 624 targets and crop 288 and 432
+saved records respectively. During codec, return and erase, it disables
+tape constructors and diagnostic `inspect`/`snapshot` access, checks the
+same eight consumer roles and unchanged archive, and checks full blank
+backing afterward. The 1D and 2D numerical oracle does not use the codec's
+grouping, local layouts or shrinking implementation.
+
+Controls reject a changed offset, omitted period wrap, missing saved
+record, wrong return key, foreign source suffix and raw negative zero.
+An in-radius payload magnitude mutation is detected by exact comparison.
+The core in these fixtures is a bit-complementing test double. Kept
+interior values are checked as opaque current-core bits and are never
+interpreted as a validated Gaussian numerical output.
+
+`RESULT.json` records the exact actual-reference receipt. The component
+receipts and full independently reviewable programs remain in their own
+directories. Separate source-aware AI review is disclosed; independent
+human or proof-kernel acceptance is not claimed.
+
+## Open next questions
+
+1. Admit a concrete rounded core on the same global reference, input grid
+   and dyadic normalizers. The splice then gives error
+   `max(E_keep,E_halo)` with no new codec defect. Start with one actual
+   caller core and its complete all-input contract.
+2. Bind canonical group-layout production, ordinary child calls, source
+   transforms and all recovery scales into the selected outer proof.
+   The local time substitution and finite actual-reference fixture do not
+   discharge these global assumptions. Preserve the generic repeated-page
+   bill whenever the balanced-group absorption cannot yet be applied.
+
+Structured questions, first steps and blockers are in `TASK.json`.
+
+## Attribution
+
+Prepared for **@CubeJerry** with substantial OpenAI Codex assistance in
+the transport, source-bound numerical consumer, composition, exact oracles
+and separately assigned adversarial AI review. Credit Cinna Davis (#4100),
+@codyw912's Astra/OpenAI-assisted #4870 enumeration package, Nick Petalas (#4217),
+Jose Manuel (#4205/#4253), Ryanson Jonathan (#4517), JoyboyBrian (#5081),
+the #6880 splice contribution, and their retained Gaussian/tape lineage.
+The predecessor claims and attributions remain in both component packages.
+Apache-2.0.
diff --git a/research/first-face-reference-join/RESULT.json b/research/first-face-reference-join/RESULT.json
new file mode 100644
index 0000000000..08a275465d
--- /dev/null
+++ b/research/first-face-reference-join/RESULT.json
@@ -0,0 +1,107 @@
+{
+  "binary_tape_primitive_upper_bound_before_scalar_macros": 38589648,
+  "codec": {
+    "control_carrier_units": 197,
+    "cropped_records": 0,
+    "cumulative_counter_bits": 20,
+    "encoded_plan_descriptor_bits": 93,
+    "quadratic_codec_tariff_units": 2949484,
+    "rectangles": 4,
+    "returned_records": 20,
+    "saved_records": 52,
+    "tariff_scope": "The complete encoded control block is O(control_carrier_units); an O(1) multiple of reported quadratic units covers sparse geometry/key macros. These are not measured binary transitions. Numeric source/consumer scalar macros remain separately charged.",
+    "transport_record_width": 84
+  },
+  "consumer_bill": {
+    "additions": 360,
+    "control_steps": 5868,
+    "maximum_single_tape_extent": 17280,
+    "moves": 707472,
+    "page_scans": 6,
+    "peak_scalar_bits": 54,
+    "products": 360,
+    "reads": 173912,
+    "roundings": 144,
+    "setup_divisions": 576,
+    "setup_entries": 576,
+    "source_shifts": 144,
+    "writes": 174544
+  },
+  "consumer_binary_actions": 1055928,
+  "consumer_data_roles_including_prepared_table": 10,
+  "consumer_retained_binary_cells": 41978,
+  "controls": [
+    "offset",
+    "omit_wrap",
+    "drop_saved",
+    "return_key",
+    "payload_magnitude_exact_mismatch"
+  ],
+  "exact_delivery_match": true,
+  "final_sha256": "7b30e970a161bde5c7e35b8caba1b42063a8f5deef83628dceda6d8177da3dcf",
+  "maximum_original_inverse_error": [
+    827359109817392248798678000910818035802286303493738330288378207692097799147777735211442634813028519979204257177757246669511377410209076815399891254027152423134087507837884515052517038982214728551165310534364969914074521173026695476712503771487214898184159032862954708861356024875381268435011841407439204583226756030661807804434986984797968102285497033537378927825790801801771008272279354331434529334879098338757982379609320609009897816405177970743021044384254694603568495233063550319579917349615143207430285493734412545214764554721618974345354908406745879634498904338764910507698162301327263393284279638423381184148102797031456262660119385165587186079208489650916496382060254548520035648467444108509028369850513811325607206912378529871509919181918922470094398386252033537015059373761755542318366132336495714184767781577135628947871135788644502998205270021119514242922845428080390878453472650466265026071870366959914516240073750386789495645204649057799109550944010363343422012340525836624507048832315952477321646801679020355095245575486055091815439803801911905090641526213972660533346548585181007206680398842501464764892200323779539265634617404770188481324305076554143209531,
+    2070465970912148396618734812346158841642385406471591226562308769346667041090487190222986810756111086506156570768230328898561059679572819345812740368548765689157482405953612075441566751926603568716532235718295868452717076124609132830801721762067740436730461226543322059734001755774653573312886732956556867023523524043696457494313825744305190122422625202506313669133947400847097839395532241493700337406441878004419970734927538613332775587531096410499109785713930409441290199790152373002455603497125910955473346928848316669893441586396046031512559015012073434526228438979101199896912638965270294174607960962283459128017626139200078924751309626030413466820883976848931162897588718349273994268940422287966510054153877835859072297965920198296507433084632314139788324946985658215429336415473999621806458236204495442257770137201423755547411206898172378391949242434053553964595646701546353222439458627406341020109150982102036154019869024771763748687804661904002962539875093064180694639492815103484657289952910558565335885287037093782783775888796410821760035118446815987040634071446317207797338295879693258223031474520244163383451873187288559732281800960678865739318194852711148803850240
+  ],
+  "proved_error_bound": [
+    7503949,
+    204963840
+  ],
+  "returned_targets": 20,
+  "scope": "Actual-reference sparse codec/consumer/return; core is destructive test double, source/consumer scalar macros explicitly priced; no new kappa",
+  "source": {
+    "gap": [
+      6255,
+      8192
+    ],
+    "identity_holes": [
+      11,
+      32,
+      53
+    ],
+    "original_entries": 4096,
+    "parameters": [
+      61,
+      3,
+      2,
+      1,
+      8,
+      32
+    ],
+    "period": 64,
+    "periodic_nonzero_coordinates": [
+      [
+        0,
+        63
+      ],
+      [
+        63,
+        0
+      ]
+    ],
+    "source_sha256": "1ed3587347dc841604ce67dac8090d5a4f403e71a0037fe453835649886a1b7a"
+  },
+  "source_height": 268,
+  "source_setup": {
+    "kernel_error_bits": 68,
+    "maximum_rational_height": 437,
+    "parameters": [
+      61,
+      3,
+      2,
+      1,
+      8,
+      32
+    ],
+    "reference_sha256": "1ed3587347dc841604ce67dac8090d5a4f403e71a0037fe453835649886a1b7a",
+    "stored_entries": 576,
+    "stored_kernels": 1,
+    "stored_weights": 61,
+    "weight_precision": 202
+  },
+  "transport": {
+    "finite_alphabet_actions": 3753372,
+    "retained_finite_alphabet_cells": 21740,
+    "roles": 30
+  }
+}
diff --git a/research/first-face-reference-join/REVIEW.md b/research/first-face-reference-join/REVIEW.md
new file mode 100644
index 0000000000..163902f47e
--- /dev/null
+++ b/research/first-face-reference-join/REVIEW.md
@@ -0,0 +1,64 @@
+# Independent first-face Reference join review
+
+Separately assigned source-aware OpenAI Codex review for @CubeJerry. Read-only component and composition review; not human or proof-kernel certification.
+
+## Source pins and verdict
+
+No blocking composition error found in the tested version. SHA256 pins:
+
+| Source under research/ | SHA256 |
+|---|---|
+| first-face-reference-join/join.py | 2631e4c41bd923230a57d723e4f903b1f38b1a3d9772ff87b76d5e1d7f2dc1e8 |
+| shrinking-reference-halo/engine.py | 38ca22b213a0291cc7ba821baf513db289c1c3e7c24c579c5eff3349280484b2 |
+| shrinking-reference-halo/tensor.py | b3cfe3c18988a89d4a639e8104db7a87f7029d556c74c2e0f60d687ec6be5e80 |
+| sparse-halo-tape-transaction/tapes.py | 80b246fafae0adf53af7561e1be59f4374e6294d66bb7a12ef9524b9ef4f2a78 |
+
+Final receipt revision: `join.py` SHA256 `8a9c2796207a03bda3881494c5b87d8076831a070ca05f9c492b7e6d0c60c1bf`. The numerical path is unchanged. The new receipt explicitly includes encoded plan parameters (including arbitrarily large J at W=0 and gap numerator/denominator) and monotone counters in its control carrier. Reviewed the changed receipt and reran the complete1D spectator fixture successfully against this hash. A zero-band descriptor with J=2^400 produced459metadata bits and517carrier units, confirming J is not bounded accidentally by the halo. Full two-axis replays were against the earlier positive-path hash; B separately reruns both modes of the portable oracle on the final package.
+
+## All-size compatibility
+
+For target interval [t,t+m), common saved halo b, and consumer halo b_i<=b, the codec keeps offsets b-b_i<=u<m+b+b_i and recodes v=u-(b-b_i). Thus (t-b_i)+v=t-b+u exactly before periodic reduction. This binds the consumer input to the canonical original-source suffix without translating or rephasing the reference. Coordinatewise interval filtering preserves lexicographic order, including when consumer packed field widths differ from the transport's ell+2 widths.
+
+The consumer returns offsets b_i+r, 0<=r<m, hence canonical target t+r. The first boundary coordinate and its side uniquely determine the rectangle; prior axes are interior and subsequent axes unrestricted. These rectangles partition boundary targets. Each saved axis length is below its period, so local offsets are injective modulo the period. The actual one-hot face field sorts in reverse face-index order; `g-onehot.bit_length()` correctly decodes that order. Entirely missing rectangles can be caught by the complete dense return merge even when the local codec sees no record from them.
+
+Payload bits pass physically and unchanged from the already-gathered source copies through the codec. The dense source is destroyed by the core test before the consumer runs. Negative zero is rejected by consumer numeric decoding, not silently normalized. Current interior words are kept as opaque bits. One fixed eight-role consumer pool is reused and cleared between rectangles.
+
+All live codec metadata describes one rectangle, counters, and packed fields. The product counters have O(B) bits, and all coordinate fields together have O(B) bits. Sparse arithmetic can be charged O(w^2) per saved/returned record or rectangle. This is a macro tariff, not a measured finite transition count. The exact receipt width must include both grid precision and packed-coordinate widths; numerical and source-preparation costs are additional inherited charges. A subsequent receipt-only revision needs its own pin.
+
+## Executed independent checks
+
+Reproduce from the repository root (portable loader adapted for isolated mode):
+
+    python3 -I -B research/first-face-reference-join/independent_review.py
+
+Expected marker: `PASS_INDEPENDENT_JOIN_FULL_GRID`.
+
+The oracle uses a dense full torus and its own signed quotient/coefficient rounding, applying the fixed-source recurrence axis by axis. It does not use consumer Layout, local rectangle assembly, apply_line, apply_tensor, or the author's standalone-consumer oracle for expected values. Host arrays are external test data only.
+
+| Fixture | Saved | Returned | Cropped | Rectangles | Exact returned bits |
+|---|---:|---:|---:|---:|---:|
+| 1D32, spectator bit, common b1, consumer b_i=(1) | 32 | 16 | 0 | 8 | 352 |
+| 2D32x32, common b1, consumer b_i=(1,0) | 1024 | 448 | 288 | 16 | 9856 |
+| 2D32x32, common b2, consumer b_i=(1,2) | 1904 | 624 | 432 | 16 | 13728 |
+
+Synthetic operators use signed nonstationary band entries, irregular identity holes and nonzero wrap entries. Both real and imaginary source components have both signs. The two-axis cases exercise zero consumer halo and nontrivial iterations on both axes. Transport action counts:1294652,77497511,137199151. Consumer read/write/move counts including archive cleanup:118624,4743360,13502688. Runtime about70seconds for these three cases.
+
+Both Tape constructors and diagnostics inspect/snapshot throw throughout codec+merge+erase. External observers invoke saved originals outside production calls. Every case preserved the same eight role identities; all local roles ended at origin, zero live bits, with all retained backing zero. Archive bytes and origin were preserved; old prepared tables erased; saved bytes preserved before erase; all30transport roles except final erased.
+
+Actually executed controls: raw negative-zero source rejected with `noncanonical negative zero`; a canonical source-suffix bit flipped through tape movement/read/write rejected with `canonical source suffix binds saved offset`.
+
+Actual Reference(61,3,2,1,8,32): all20boundary target values exactly match the full-grid rounded recurrence. Source holes are11,32,53; hole32 is returned. Two nonzero periodic wrap entries are present. Source coefficients come from the authenticated service; expected evaluation uses the independent dense recurrence. Parent separately checked original inverse solves.
+
+## Limits
+
+Finite checks supplement the universal identity and partition proof; they are not a proof of all parameter instances. Arbitrary dimensions and unequal core-index widths were checked in the predecessor transport review, not exhaustively through this numerical join. General composition inherits the source band/gap/common-grid/radius contract and the consumer theorem. The entire composed numerical program still uses explicitly priced scalar/control macros. The core remains a destructive test double. No proof assumption is removed globally, and no new kappa is claimed.
+
+## Integration replay addendum
+
+The complete registered normal and optimized replays were subsequently run on
+the final `join.py` hash `8a9c2796207a03bda3881494c5b87d8076831a070ca05f9c492b7e6d0c60c1bf`.
+Both full two-axis runs and the actual-reference case passed. After excluding
+only measured wall time, the independent semantic receipts agree exactly.
+The portable review loader uses an exact path for `full_grid_oracle.py`, so
+`-I` isolation is supported. This addendum records integration replay of the
+independent oracle; it is not an additional independently written algorithm.
diff --git a/research/first-face-reference-join/SOURCES.json b/research/first-face-reference-join/SOURCES.json
new file mode 100644
index 0000000000..31bca8bfcf
--- /dev/null
+++ b/research/first-face-reference-join/SOURCES.json
@@ -0,0 +1,121 @@
+{
+  "schema_version": 1,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "files": [
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "path": "research/sparse-halo-tape-transaction/tapes.py",
+      "usage": "input",
+      "git_blob": "b3dfa43ba0d08c6393731ac3cd2857a92e4c8aa2",
+      "sha256": "80b246fafae0adf53af7561e1be59f4374e6294d66bb7a12ef9524b9ef4f2a78",
+      "pin": "head:630c9c2a5d6373ca103c55108bb606b4868bc6fd:research/sparse-halo-tape-transaction/tapes.py"
+    },
+    {
+      "path": "research/sparse-halo-tape-transaction/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "2f69b5b0829aca2871a2e68977ae109692581011",
+      "sha256": "a2982006e3c176d01f7920072b66f347a4e42ced774d487273f3908a67793335",
+      "pin": "head:630c9c2a5d6373ca103c55108bb606b4868bc6fd:research/sparse-halo-tape-transaction/PROOF.md"
+    },
+    {
+      "path": "research/shrinking-reference-halo/engine.py",
+      "usage": "input",
+      "git_blob": "984dffee3fb1d5723f5bfbfcfb1d4befefe9a767",
+      "sha256": "38ca22b213a0291cc7ba821baf513db289c1c3e7c24c579c5eff3349280484b2",
+      "pin": "head:a2f3ce7358e8103f6eccd404e594276e9ccc04d8:research/shrinking-reference-halo/engine.py"
+    },
+    {
+      "path": "research/shrinking-reference-halo/tensor.py",
+      "usage": "input",
+      "git_blob": "40e84c41bf709930bbaacc40b0cf1704fc568540",
+      "sha256": "b3cfe3c18988a89d4a639e8104db7a87f7029d556c74c2e0f60d687ec6be5e80",
+      "pin": "head:a2f3ce7358e8103f6eccd404e594276e9ccc04d8:research/shrinking-reference-halo/tensor.py"
+    },
+    {
+      "path": "research/shrinking-reference-halo/source.py",
+      "usage": "input",
+      "git_blob": "b78551e46194d031c4ee826ab7123cf3e2f63c92",
+      "sha256": "20c0fb2e4aa95de976ef6ce74ded4bf1cb9073732eca7eda8f61e45d239afa2c",
+      "pin": "head:a2f3ce7358e8103f6eccd404e594276e9ccc04d8:research/shrinking-reference-halo/source.py"
+    },
+    {
+      "path": "research/shrinking-reference-halo/SOURCES.json",
+      "usage": "input",
+      "git_blob": "2e7ea79daecbd623b201184988e54c8b446276e7",
+      "sha256": "211c8989270de2666651a43e8bf0b0145ee7878edd5a1ec1a3ed2e318b6c6dbe",
+      "pin": "head:a2f3ce7358e8103f6eccd404e594276e9ccc04d8:research/shrinking-reference-halo/SOURCES.json"
+    },
+    {
+      "path": "research/shrinking-reference-halo/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "c47fc7013bfb814428a94ecc2984d2a75c92c300",
+      "sha256": "1f49c8289e05ff99673f83c810ccd9c310faee9ecebee96e5b1f20db2b7a6061",
+      "pin": "head:a2f3ce7358e8103f6eccd404e594276e9ccc04d8:research/shrinking-reference-halo/PROOF.md"
+    },
+    {
+      "path": "research/rational-unitary-fft/exact.py",
+      "usage": "input",
+      "git_blob": "aae41e6acfb2e5a4fafdd85727891eb746b57b42",
+      "sha256": "c9b89d7357210af69865690ba12e695366961f8b501a8fab9d0fefe3fb30c479"
+    },
+    {
+      "path": "research/rational-unitary-fft/gaussian.py",
+      "usage": "input",
+      "git_blob": "52ad2e1d605f5f7d669234567c25bc087306dd44",
+      "sha256": "08155357fd39b5fd7959f51f1d205b6511b8577b51520d793c89f92368b399ab"
+    },
+    {
+      "path": "research/rational-unitary-fft/gaussian_reference.py",
+      "usage": "input",
+      "git_blob": "92addfabde50655cea7ad5a84cca9cff5457adee",
+      "sha256": "ed4d0908646e391d4a0ea32c988a0301a1793a72294ac7058a664ed3283ca3c3"
+    },
+    {
+      "path": "research/rational-unitary-fft/RAW-GAUSSIAN-PROOF.md",
+      "usage": "input",
+      "git_blob": "1fb549d24a419abb50f5b772437d87e48c65fe06",
+      "sha256": "3f683643a0c0b45d58ec09ebe511e4006cd103e38753f82a4ce21a8570383358"
+    },
+    {
+      "path": "research/certified-gaussian-recovery/intervals.py",
+      "usage": "input",
+      "git_blob": "91d458865aa026bdf0d59653a4ecbfe3a178ecbc",
+      "sha256": "159d2a7d32a8cc7c8f56632a8ef127308b984a0a6753c9d6bdccacc6e7d6d4df"
+    },
+    {
+      "path": "research/certified-gaussian-recovery/NOTICE.md",
+      "usage": "input",
+      "git_blob": "5e3269b5afe5e11f044ffae45216c4731b42c7af",
+      "sha256": "10acae9e78402ca70c6afd0e8d6da8fefc0da519c646cf43d93f923aba85b86d"
+    },
+    {
+      "path": "research/unconditional-batched-crt/HALO.md",
+      "usage": "input",
+      "git_blob": "5f601b3c8ac368aa79aa1007effe5933a360237b",
+      "sha256": "a2adcf18614983e9255def6d3f5e59be0018a392e418d65e94323722838289cc"
+    },
+    {
+      "path": "research/unconditional-batched-crt/PROOF.md",
+      "usage": "input",
+      "git_blob": "406eb561cc8d6041ea3fba1a849653b654f2198c",
+      "sha256": "689fc7b01c5f04f77019ff02d1b79cb4f7020bd98e05b1052020bad295dec060"
+    },
+    {
+      "path": "research/unconditional-batched-crt/GAUSSIAN.md",
+      "usage": "input",
+      "git_blob": "adfb28c93e6b06178c901caaac39ede41a9e541b",
+      "sha256": "2f63c91c58f2d1cf31294812c75970ea390c61866a8da7ed700d4316a033a242"
+    }
+  ]
+}
diff --git a/research/first-face-reference-join/TASK.json b/research/first-face-reference-join/TASK.json
new file mode 100644
index 0000000000..eade364e30
--- /dev/null
+++ b/research/first-face-reference-join/TASK.json
@@ -0,0 +1,89 @@
+{
+  "schema_version": 1,
+  "task_id": "uniform-transfer-audit",
+  "priority_revision": 8,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "original_card": {
+    "id": "uniform-transfer-audit",
+    "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?",
+    "starting_points": [
+      "docs/research/current-priorities.md",
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md"
+    ],
+    "methods": [
+      "Construct and independently check one source-bound instance of the stated first experiment.",
+      "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+    ],
+    "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_selected_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+      "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+    },
+    "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.",
+    "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+    "allowed_variations": [
+      "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+    ],
+    "scope_change_triggers": [
+      "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+      "Treating an archived proposal or local numerical pass as complete supplier admission."
+    ],
+    "overlap_terms": [
+      "native_all_columns",
+      "owned_erasure",
+      "compiler",
+      "precision_tape",
+      "analytic_recovery"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.",
+        "evidence": "research/unconditional-batched-crt/README.md",
+        "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.",
+        "status": "author-checked",
+        "source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+        "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+        "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+        "status": "reviewed",
+        "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+        "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+      }
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "Prove and execute the source-bound composition of first-face sparse transport, common-to-unequal halo codec, fixed-reference shrinking numerical consumer and unique canonical target return; retain the actual same-reference core and complete outer proof as explicit premises.",
+  "scope_change_reason": "The two complementary assigned components produced compatible contracts. They form one integrated research contribution only after the codec identities, complete physical/scalar bill and actual-reference join are independently checked. Existing first-face combinatorics, locality and direct-Neumann degree are not new results.",
+  "bottleneck_link": "Eliminates named sparse-interface implementation gaps in precision_tape and analytic_recovery without claiming either entire retained assumption or a new exponent.",
+  "budget_minutes": 150,
+  "stop_rule": "Complete the actual Reference64 seam, independent one/two-axis rounded full-grid checks, negative controls, universal composition/cost proof and full three-package replay; stop optional fixture expansion after this evidence.",
+  "outcome": "completed",
+  "evidence": "PROOF.md; join.py actual streamed codec; oracle.py exact original-reference inverse solve; independent_review.py/full_grid_oracle.py separate global rounded recurrence and sealed-constructor/observer tests; exact RESULT.json; pinned component proofs and registered replays.",
+  "author": "CubeJerry",
+  "ai_assistance": "Substantial OpenAI Codex assistance in complementary construction, exact source integration, proof, implementation and separately assigned source-aware adversarial review. No independent human or proof-kernel acceptance claimed.",
+  "open_questions": [
+    {
+      "question": "Can the actual rounded core be admitted on the same global reference, input grid and dyadic normalizers?",
+      "why_it_matters": "The completed sparse interface supplies target values, but the complete inverse splice still needs a proved kept-coordinate core error.",
+      "first_step": "Pin one production core invocation and check its all-input numerical contract, source identity, normalizers, errors and physical tariff.",
+      "blocked_by": "The destructive core test double is only an ownership control; this package does not execute or prove the accelerated core."
+    },
+    {
+      "question": "Can the selected outer caller bind group layout production, ordinary children, source transforms and final recovery to this local bill?",
+      "why_it_matters": "All five selected assumptions remain and no unconditional sub-n-log-n multiplication theorem follows from a local interface alone.",
+      "first_step": "Retain generic full-archive/source terms until the balanced-group inequalities hold and trace all grid/radius/normalizer scales through the actual caller.",
+      "blocked_by": "Full source identity, ordinary caller and outer recovery admission are separate from this source-bound sparse composition."
+    }
+  ]
+}
diff --git a/research/first-face-reference-join/VALIDATION.json b/research/first-face-reference-join/VALIDATION.json
new file mode 100644
index 0000000000..5fb31d912c
--- /dev/null
+++ b/research/first-face-reference-join/VALIDATION.json
@@ -0,0 +1,26 @@
+{
+  "status": "PASS",
+  "canonical_base": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "command": [
+    "python3",
+    "-B",
+    "research/first-face-reference-join/replay_all.py"
+  ],
+  "expected_final_marker": "PASS_COMPLETE_FIRST_FACE_HALO_PACKAGE",
+  "registered_command_count": 14,
+  "registered_components": [
+    "research/sparse-halo-tape-transaction",
+    "research/shrinking-reference-halo",
+    "research/first-face-reference-join"
+  ],
+  "normal_optimized_actual_source_receipts_equal": true,
+  "normal_optimized_independent_semantic_receipts_equal": true,
+  "excluded_from_semantic_comparison": [
+    "seconds (wall-time observation)"
+  ],
+  "join_source_sha256": "8a9c2796207a03bda3881494c5b87d8076831a070ca05f9c492b7e6d0c60c1bf",
+  "python": "3.12.14",
+  "metadata_gates": "All three component/composition metadata-and-pin checks passed after documentation dispositions.",
+  "source_history_gate": "Unavailable on shared shallow canonical Git history; no full-history ancestry certification claimed. Exact remote C/CB commit objects and source blobs were independently installed and matched.",
+  "scope": "Finite execution corroborates written all-size component/composition proofs. Numerical core is a test double; source and scalar macro tariffs remain explicit; no human/kernel acceptance or new kappa."
+}
diff --git a/research/first-face-reference-join/VERIFY.json b/research/first-face-reference-join/VERIFY.json
new file mode 100644
index 0000000000..d53c1f6c6d
--- /dev/null
+++ b/research/first-face-reference-join/VERIFY.json
@@ -0,0 +1,66 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/sparse-halo-tape-transaction/tapes.py",
+    "research/shrinking-reference-halo/engine.py",
+    "research/shrinking-reference-halo/tensor.py",
+    "research/shrinking-reference-halo/source.py",
+    "research/shrinking-reference-halo/SOURCES.json",
+    "research/rational-unitary-fft/exact.py",
+    "research/rational-unitary-fft/gaussian.py",
+    "research/rational-unitary-fft/gaussian_reference.py",
+    "research/rational-unitary-fft/RAW-GAUSSIAN-PROOF.md",
+    "research/certified-gaussian-recovery/intervals.py",
+    "research/certified-gaussian-recovery/NOTICE.md",
+    "research/unconditional-batched-crt/HALO.md",
+    "research/unconditional-batched-crt/PROOF.md",
+    "research/unconditional-batched-crt/GAUSSIAN.md"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/join.py"
+      ],
+      "timeout_seconds": 240,
+      "checks": "Actual source-reference streamed transaction, exact independent delivery and original-H inverse oracle, movement/retained-space bills and corruption controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/join.py"
+      ],
+      "timeout_seconds": 240,
+      "checks": "Actual source-reference streamed transaction, exact independent delivery and original-H inverse oracle, movement/retained-space bills and corruption controls with assertions disabled."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/independent_review.py"
+      ],
+      "timeout_seconds": 240,
+      "checks": "Independent global rounded recurrence on one/two-axis signed/unequal-halo/spectator fixtures, constructor/diagnostic exclusion, raw representation and source-suffix controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/independent_review.py"
+      ],
+      "timeout_seconds": 240,
+      "checks": "Independent global rounded recurrence on one/two-axis signed/unequal-halo/spectator fixtures, constructor/diagnostic exclusion, raw representation and source-suffix controls with assertions disabled."
+    }
+  ]
+}
diff --git a/research/first-face-reference-join/full_grid_oracle.py b/research/first-face-reference-join/full_grid_oracle.py
new file mode 100644
index 0000000000..2bdb132e55
--- /dev/null
+++ b/research/first-face-reference-join/full_grid_oracle.py
@@ -0,0 +1,83 @@
+"""Independent whole-grid rounded oracle, outside the production algorithm."""
+from fractions import Fraction
+from math import prod
+
+
+def need(ok,why):
+    if not ok: raise ValueError(why)
+
+
+def trunc(n,d):
+    need(type(n) is int and type(d) is int and d>0,'signed quotient')
+    q=abs(n)//d
+    return -q if n<0 else q
+
+
+def coefficient(x,bits):
+    x=Fraction(x)
+    return trunc(x.numerator*(2**bits),x.denominator)
+
+
+def full_grid(matrices,plans,original):
+    periods=tuple(p.period for p in plans)
+    need(len(original)==prod(periods),'full-grid cardinality')
+    current=tuple(original)
+    for axis,p in enumerate(plans):
+        n=periods[axis];stride=prod(periods[axis+1:]);block=n*stride
+        a=tuple(tuple(coefficient(x,p.bits) for x in row) for row in matrices[axis])
+        need(len(a)==n and all(len(row)==n for row in a),'dense matrix')
+        result=[None]*len(current)
+        for prefix in range(len(current)//block):
+            base=prefix*block
+            for remainder in range(stride):
+                source=tuple(current[base+r*stride+remainder] for r in range(n))
+                iterate=((0,0),)*n
+                for _ in range(p.terms):
+                    following=[]
+                    for row in range(n):
+                        pair=[]
+                        for component in (0,1):
+                            total=source[row][component]*(2**(p.bits-p.normalizer_shift))
+                            total+=sum(a[row][column]*iterate[column][component] for column in range(n))
+                            pair.append(trunc(total,2**p.bits))
+                        following.append(tuple(pair))
+                    iterate=tuple(following)
+                for row,value in enumerate(iterate):
+                    result[base+row*stride+remainder]=value
+        need(all(value is not None for value in result),'all global rows filled')
+        current=tuple(result)
+    return current
+
+
+def decode_global(address,periods):
+    result=[]
+    for period in reversed(periods):
+        result.append(address%period);address//=period
+    need(address==0,'address range')
+    return tuple(reversed(result))
+
+
+def sigmag(value,width):
+    need(type(value) is int and abs(value)<2**(width-1),'word carrier')
+    return str(int(value<0))+format(abs(value),'0'+str(width-1)+'b')
+
+
+def encoded(pair,width):
+    return ''.join(sigmag(value,width) for value in pair)
+
+
+def expected_after_core(matrices,plans,original,ell,boundary,spectators=1):
+    periods=tuple(p.period for p in plans);size=prod(periods)
+    need(len(original)==spectators*size,'spectator source cardinality')
+    width=plans[0].data_width;side=2**ell;result=[];targets=0
+    for spectator in range(spectators):
+        source=original[spectator*size:(spectator+1)*size]
+        rounded=full_grid(matrices,plans,source)
+        for address,pair in enumerate(source):
+            point=decode_global(address,periods)
+            boundary_point=any(x%side<boundary or x%side>=side-boundary for x in point)
+            if boundary_point:
+                result.append(encoded(rounded[address],width));targets+=1
+            else:
+                result.append(''.join('1' if bit=='0' else '0' for bit in encoded(pair,width)))
+    return ''.join(value+'#' for value in result),targets
diff --git a/research/first-face-reference-join/independent_review.py b/research/first-face-reference-join/independent_review.py
new file mode 100644
index 0000000000..a9c6dbe21a
--- /dev/null
+++ b/research/first-face-reference-join/independent_review.py
@@ -0,0 +1,178 @@
+"""Independent global-grid review of the streamed B/C codec.
+
+External test fixture/oracle only; no production payload regrouping is used.
+Prepared for @CubeJerry with separate source-aware OpenAI Codex assistance.
+"""
+from fractions import Fraction as Q
+from hashlib import sha256
+import importlib.util
+import json
+from math import prod
+from pathlib import Path
+import sys
+from time import perf_counter
+
+ROOT = Path(sys.argv[1]).resolve() if len(sys.argv) > 1 else Path(__file__).resolve().parent
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+O = load('independent_join_full_grid_oracle', ROOT / 'full_grid_oracle.py')
+encoded, expected_after_core, full_grid, need = O.encoded, O.expected_after_core, O.full_grid, O.need
+J = load('independent_join_under_review', ROOT / 'join.py')
+B, M, T = J.B, J.M, J.T
+
+
+def synthetic_matrix(n, axis):
+    holes = {4, 11, n - 10}
+    rows = [[Q(0) for _ in range(n)] for _ in range(n)]
+    for r in range(n):
+        for offset, value in (
+            (-1, Q(1 if (r + axis) % 2 else -1, 10)),
+            (0, Q((r + axis) % 3 - 1, 16)),
+            (1, Q(-1 if (r + axis) % 3 else 1, 11)),
+        ):
+            c = (r + offset) % n
+            if r not in holes and c not in holes:
+                rows[r][c] = value
+    need(rows[0][n - 1] and rows[n - 1][0], 'genuine wrap interaction')
+    return tuple(tuple(row) for row in rows)
+
+
+def original_words(size, bits):
+    unit = 2 ** max(0, bits - 9)
+    return tuple((((17 * r + 3) % 201 - 100) * unit,
+                  ((29 * r + 7) % 151 - 75) * unit) for r in range(size))
+
+
+def forbidden(*args, **kwargs):
+    raise RuntimeError('production used forbidden diagnostic or allocated a new tape')
+
+
+def fixture(ell, ks, spectator_width, boundary, halo, terms, *, fault=None):
+    start = perf_counter()
+    plans = tuple(M.Plan(2 ** (ell + k), 1, 9, j, 1, Q(1, 2), 1)
+                  for k, j in zip(ks, terms))
+    need(len(plans) == len(ks), 'complete plan fixture')
+    matrices = tuple(synthetic_matrix(p.period, axis) for axis, p in enumerate(plans))
+    size = (2 ** spectator_width) * prod(p.period for p in plans)
+    words = original_words(size, plans[0].bits)
+    if fault == 'negative_zero':
+        words = ((0, words[0][1]),) + words[1:]
+    expected, target_count = expected_after_core(matrices, plans, words, ell, boundary, 2 ** spectator_width)
+    source = ''.join(encoded(pair, plans[0].data_width) + '#' for pair in words)
+    if fault == 'negative_zero':
+        source = '1' + source[1:]
+    coordinate_tape = '0' * spectator_width + '&' + ''.join('@' + '0' * k + '#' + '0' * ell + ';' for k in ks)
+    width = ell + 2
+    transport = B.Program(source, coordinate_tape,
+                          format(2 ** ell, '0' + str(width) + 'b'),
+                          format(boundary, '0' + str(width) + 'b'),
+                          format(halo, '0' + str(width) + 'b'))
+    transport.gather(); transport.sort(transport.saved)
+    shape = J.Shape(ell, ks, spectator_width, boundary, halo, 2 * plans[0].data_width)
+    if fault == 'source_suffix':
+        B.home(transport.saved)
+        for _ in range(shape.prefix_width + shape.g * (ell + 2) + shape.coordinate_width - 1):
+            transport.saved.move(1)
+        bit = transport.saved.read()
+        need(bit in '01', 'source suffix mutation site')
+        transport.saved.write('1' if bit == '0' else '0')
+        B.home(transport.saved)
+    saved_before = transport.saved.inspect()
+    transport.core_complement_test_double()
+    need(transport.source.inspect() == ''.join('#' if x == '#' else ('1' if x == '0' else '0') for x in source), 'core really destroyed original payloads')
+    bill = M.Bill()
+    old_tables = []
+    def tables():
+        for axis, plan in enumerate(plans):
+            table, _ = M.prepare_table(plan, lambda r, c, axis=axis: matrices[axis][r][c], 'independent synthetic axis ' + str(axis), bill)
+            old_tables.append(table)
+            yield table
+    archive = T.pack_tables(tables(), bill)
+    archive_before = archive.tape.snapshot()
+    pool = T.TensorWorkspace.create(bill)
+    ids_before = tuple(map(id, pool.roles))
+    codec = J.Codec(transport, shape, archive, pool, bill)
+    old = B.Tape.__init__, B.Tape.inspect, M.Tape.__init__, M.Tape.snapshot
+    B.Tape.__init__ = B.Tape.inspect = M.Tape.__init__ = M.Tape.snapshot = forbidden
+    try:
+        codec.run()
+        need(old[1](transport.saved) == saved_before, 'saved payloads and keys preserved by codec')
+        transport.merge_returns()
+        transport.erase_work()
+    finally:
+        B.Tape.__init__, B.Tape.inspect, M.Tape.__init__, M.Tape.snapshot = old
+    need(transport.final.inspect() == expected, 'whole-grid rounded oracle differs')
+    need(codec.returned_records == target_count, 'boundary target cardinality')
+    need(codec.rectangles == (2 ** (spectator_width + sum(ks))) * 2 * len(ks), 'all first-face rectangles consumed exactly once')
+    need(tuple(map(id, pool.roles)) == ids_before, 'fixed pool identity')
+    need(all(t.head == 0 and t.live_bits == 0 and not t.readonly and not any(t.snapshot()) for t in pool.roles), 'all eight local roles erased at origin')
+    need(archive.tape.head == 0 and archive.tape.readonly and archive.tape.snapshot() == archive_before, 'archive preserved at origin')
+    need(all(t.tape.head == 0 and t.tape.live_bits == 0 and not any(t.tape.snapshot()) for t in old_tables), 'prepared table erasure')
+    need(all(t is transport.final or t.inspect() == '' for t in transport.roles), 'all nonoutput transport roles erased')
+    archive.tape.readonly = False; archive.tape.clear()
+    need(not any(archive.tape.snapshot()), 'archive erasure')
+    receipt = codec.receipt()
+    receipt.update(periods=[p.period for p in plans], terms=list(terms), halo=halo,
+                   consumer_halos=[p.halo for p in plans], spectator_width=spectator_width,
+                   source_records=size, checked_returned_bits=target_count * shape.payload_width,
+                   exact_full_grid_match=True, constructors_and_observers_disabled=True,
+                   consumer_bit_actions=bill.reads + bill.writes + bill.moves,
+                   transport_finite_alphabet_actions=sum(t.actions[k] for t in transport.roles for k in ('read', 'write', 'move')),
+                   seconds=round(perf_counter() - start, 3))
+    return receipt
+
+
+def actual_reference():
+    oracle = load('independent_source_fixture', ROOT / 'oracle.py')
+    _, raw, h, gap, source_receipt = oracle.source_fixture()
+    matrix = tuple(tuple(Q(int(r == c)) - h[r][c] for c in range(64)) for r in range(64))
+    words = oracle.fixture_words(64, 28)
+    actual, plan, receipt = J.execute(raw, gap, words)
+    expected = full_grid((matrix,), (plan,), words)
+    need(all(actual[row] == expected[row] for row in actual), 'actual reference exact full-grid rounding mismatch')
+    need(set(actual) == {r for r in range(64) if r % 32 < 5 or r % 32 >= 27}, 'actual target set')
+    holes = source_receipt['identity_holes']
+    need(holes and source_receipt['periodic_nonzero_coordinates'], 'actual holes and wrap')
+    return dict(actual_reference=True, checked_targets=len(actual), holes=holes,
+                periodic_nonzeros=len(source_receipt['periodic_nonzero_coordinates']),
+                exact_full_grid_match=True, codec=receipt['codec'])
+
+
+def main():
+    cases = []
+    for parameters in ((4, (1,), 1, 2, 1, (2,)),
+                       (4, (1, 1), 0, 2, 1, (2, 1)),
+                       (4, (1, 1), 0, 3, 2, (2, 3))):
+        result = fixture(*parameters)
+        cases.append(result)
+        print(json.dumps(result, sort_keys=True), flush=True)
+    controls = []
+    for fault, message in (('negative_zero', 'noncanonical negative zero'),
+                           ('source_suffix', 'canonical source suffix binds saved offset')):
+        try:
+            fixture(4, (1,), 0, 2, 1, (2,), fault=fault)
+        except ValueError as e:
+            need(str(e) == message, 'wrong control failure: ' + str(e))
+            controls.append(fault)
+        else:
+            raise ValueError('mutation escaped: ' + fault)
+    actual = actual_reference()
+    print(json.dumps(actual, sort_keys=True), flush=True)
+    print('PASS_INDEPENDENT_JOIN_FULL_GRID')
+    print(json.dumps(dict(cases=len(cases), controls=controls,
+                         files={str(path.relative_to(ROOT.parent)): sha256(path.read_bytes()).hexdigest()
+                                for path in (ROOT / 'join.py', ROOT.parent / 'shrinking-reference-halo/engine.py',
+                                             ROOT.parent / 'shrinking-reference-halo/tensor.py',
+                                             ROOT.parent / 'sparse-halo-tape-transaction/tapes.py')}), sort_keys=True))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/first-face-reference-join/join.py b/research/first-face-reference-join/join.py
new file mode 100644
index 0000000000..356d595298
--- /dev/null
+++ b/research/first-face-reference-join/join.py
@@ -0,0 +1,423 @@
+#!/usr/bin/env python3
+"""Stream first-face transport through a source-bound shrinking halo consumer.
+
+Actual reads/writes/unit moves are executed across both tape representations.
+Sparse control-word arithmetic is an explicit O(w^2) macro tariff, as in the
+consumer; this composed program does NOT claim transport's finite-local-only
+control boundary. There is no host regrouping of saved payloads.
+"""
+
+from dataclasses import dataclass
+from fractions import Fraction as Q
+from hashlib import sha256
+import importlib.util
+import json
+from pathlib import Path
+import sys
+
+
+PACKAGE = Path(__file__).resolve().parent
+RESEARCH = PACKAGE.parent
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+B = load("join_transport", RESEARCH / "sparse-halo-tape-transaction/tapes.py")
+M = load("shrinking_halo_engine", RESEARCH / "shrinking-reference-halo/engine.py")
+T = load("join_tensor", RESEARCH / "shrinking-reference-halo/tensor.py")
+S = load("join_source", RESEARCH / "shrinking-reference-halo/source.py")
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+@dataclass(frozen=True)
+class Shape:
+    ell: int
+    ks: tuple
+    spectator_width: int
+    boundary: int
+    halo: int
+    payload_width: int
+
+    def __post_init__(self):
+        need(self.ell >= 1 and self.ks and all(k >= 1 for k in self.ks), "dyadic shape")
+        need(0 <= self.halo < self.boundary and self.length > 4 * self.boundary, "first-face geometry")
+
+    @property
+    def length(self):
+        return 1 << self.ell
+
+    @property
+    def g(self):
+        return len(self.ks)
+
+    @property
+    def coordinate_width(self):
+        return self.spectator_width + sum(k + self.ell for k in self.ks)
+
+    @property
+    def prefix_width(self):
+        return self.spectator_width + sum(self.ks) + self.g + 1
+
+    @property
+    def saved_key_width(self):
+        return 2 * self.coordinate_width + 3 * self.g + 1
+
+
+def read_unsigned(tape, width):
+    """Read each B cell; reconstruct one bounded scalar control field."""
+    value = 0
+    for _ in range(width):
+        bit = tape.read()
+        need(bit in "01", "truncated or nonbinary saved key")
+        value = 2 * value + (bit == "1")
+        tape.move(1)
+    return value
+
+
+def write_unsigned(tape, value, width):
+    need(0 <= value < 1 << width, "canonical return carrier")
+    for shift in range(width - 1, -1, -1):
+        B.append(tape, "1" if (value >> shift) & 1 else "0")
+
+
+def delimiter(tape):
+    need(tape.read() == "#", "saved field delimiter")
+    tape.move(1)
+
+
+class Codec:
+    """One current rectangle, one pending prefix, no host payload container.
+
+    Tuples here contain only encoded geometry/control words, total O(w) bits.
+    Their arithmetic is priced separately from executed tape primitives.
+    """
+
+    def __init__(self, transport, shape, archive, pool, bill, fault=None):
+        self.transport = transport
+        self.shape = shape
+        self.archive = archive
+        self.pool = pool
+        self.bill = bill
+        self.fault = fault
+        self.prefix = None
+        self.previous_prefix = -1
+        self.copied_records = 0
+        self.returned_records = 0
+        self.rectangles = 0
+        self.cropped_records = 0
+        self._fault_used = False
+        need(len(archive.plans) == shape.g, "one reference plan per active axis")
+        need(all(p.period == 1 << (k + shape.ell) for p, k in zip(archive.plans, shape.ks)), "shared periodic coordinates")
+        need(all(p.halo <= shape.halo for p in archive.plans), "saved domain covers every consumer halo")
+        need(all(2 * p.data_width == shape.payload_width for p in archive.plans), "common exact payload codec")
+        B.home(transport.saved)
+        B.end(transport.returns)
+
+    def begin_rectangle(self, prefix):
+        s = self.shape
+        need(prefix > self.previous_prefix, "strictly ordered unique rectangle prefixes")
+        self.prefix = self.previous_prefix = prefix
+        side = prefix & 1
+        onehot = (prefix >> 1) & ((1 << s.g) - 1)
+        need(onehot != 0 and onehot & (onehot - 1) == 0, "one-hot first face")
+        face = s.g - onehot.bit_length()
+        prefix >>= s.g + 1
+        core = [0] * s.g
+        for i in range(s.g - 1, -1, -1):
+            core[i] = prefix & ((1 << s.ks[i]) - 1)
+            prefix >>= s.ks[i]
+        self.spectator = prefix
+        need(prefix < 1 << s.spectator_width, "spectator prefix width")
+        targets = []
+        for i, c in enumerate(core):
+            if i < face:
+                lo, length = s.boundary, s.length - 2 * s.boundary
+            elif i == face:
+                lo, length = (0 if side == 0 else s.length - s.boundary), s.boundary
+            else:
+                lo, length = 0, s.length
+            targets.append((c * s.length + lo, length))
+        self.targets = tuple(targets)
+        self.full_lengths = tuple(length + 2 * s.halo for _, length in targets)
+        self.expected_offsets = [0] * s.g
+        self.full_count = 1
+        for length in self.full_lengths:
+            self.full_count *= length
+        self.read_count = self.kept_count = 0
+        self.layout = T.Layout.make(self.archive.plans, self.targets)
+        self.input = self.pool.rectangles[0]
+        need(all(t.head == 0 and t.live_bits == 0 and not t.readonly for t in self.pool.roles), "one reused blank consumer workspace")
+
+    def advance_offsets(self):
+        axis = self.shape.g - 1
+        while axis >= 0:
+            self.expected_offsets[axis] += 1
+            if self.expected_offsets[axis] < self.full_lengths[axis]:
+                break
+            self.expected_offsets[axis] = 0
+            axis -= 1
+
+    def canonical_key(self, coordinates):
+        key = self.spectator
+        for x, k in zip(coordinates, self.shape.ks):
+            axis_width = k + self.shape.ell
+            key = (key << axis_width) | (x & ((1 << axis_width) - 1))
+        return key
+
+    def accept_record(self):
+        s = self.shape
+        tape = self.transport.saved
+        offsets = tuple(read_unsigned(tape, s.ell + 2) for _ in s.ks)
+        if self.fault == "offset" and not self._fault_used:
+            offsets = (offsets[0] + 1,) + offsets[1:]
+            self._fault_used = True
+        need(self.read_count < self.full_count and offsets == tuple(self.expected_offsets), "complete ordered saved offsets")
+        source_key = read_unsigned(tape, s.coordinate_width)
+        coordinates = tuple(lo - s.halo + off for (lo, _), off in zip(self.targets, offsets))
+        expected_source = self.canonical_key(coordinates)
+        if self.fault == "omit_wrap" and not self._fault_used and any(x < 0 for x in coordinates):
+            expected_source = self.canonical_key(tuple(max(0, x) for x in coordinates))
+            self._fault_used = True
+        need(source_key == expected_source, "canonical source suffix binds saved offset")
+        delimiter(tape)
+        delta = tuple(s.halo - p.halo for p in self.archive.plans)
+        keep = all(d <= off < length - d for off, d, length in zip(offsets, delta, self.full_lengths))
+        if keep:
+            recoded = tuple(off - d for off, d in zip(offsets, delta))
+            key = self.layout.key(recoded)
+            dropping = self.fault == "drop_saved" and not self._fault_used
+            if dropping:
+                self._fault_used = True
+            else:
+                T.put_unsigned(self.input, key, self.layout.key_width)
+        else:
+            dropping = False
+        for place in range(s.payload_width):
+            bit = tape.read()
+            need(bit in "01", "complete saved payload")
+            tape.move(1)
+            if self.fault == "payload_magnitude" and place == 2:
+                bit = "0" if bit == "1" else "1"
+                self._fault_used = True
+            if keep and not dropping:
+                self.input.write(1 if bit == "1" else 0)
+                self.input.step(1)
+        delimiter(tape)
+        self.read_count += 1
+        self.copied_records += 1
+        if keep and not dropping:
+            self.kept_count += 1
+        else:
+            self.cropped_records += 1
+        self.advance_offsets()
+
+    def finish_rectangle(self):
+        if self.prefix is None:
+            return
+        need(self.read_count == self.full_count, "complete common-halo rectangle")
+        need(self.kept_count == self.layout.volume, "complete consumer-halo rectangle")
+        self.input.rewind()
+        output = T.apply_tensor(self.archive, self.targets, self.input, self.bill, workspace=self.pool)
+        prior = -1
+        for _ in range(output.count):
+            local_key = T.get_unsigned(output.tape, output.layout.key_width)
+            need(local_key > prior, "ordered unique consumer targets")
+            prior = local_key
+            coordinates = tuple(output.layout.lowers[i] + output.layout.coordinate(local_key, i) for i in range(self.shape.g))
+            need(all(lo <= x < lo + length for x, (lo, length) in zip(coordinates, self.targets)), "consumer target-only coordinate")
+            key = self.canonical_key(coordinates)
+            if self.fault == "return_key" and not self._fault_used:
+                key ^= 1
+                self._fault_used = True
+            write_unsigned(self.transport.returns, key, self.shape.coordinate_width)
+            B.append(self.transport.returns, "#")
+            # Copy the exact C payload cells. No host decoded numeric word is
+            # substituted into the production return stream.
+            for _ in range(self.shape.payload_width):
+                bit = output.tape.read()
+                output.tape.step(1)
+                B.append(self.transport.returns, "1" if bit else "0")
+            B.append(self.transport.returns, "#")
+            self.returned_records += 1
+        output.tape.clear()
+        need(all(t.live_bits == 0 and t.head == 0 for t in self.pool.roles), "consumer roles cleaned between rectangles")
+        self.rectangles += 1
+
+    def run(self):
+        tape = self.transport.saved
+        while tape.read() != "!":
+            prefix = read_unsigned(tape, self.shape.prefix_width)
+            if prefix != self.prefix:
+                self.finish_rectangle()
+                self.begin_rectangle(prefix)
+            self.accept_record()
+        self.finish_rectangle()
+        self.prefix = None
+
+    def receipt(self):
+        # Observer-only tariff description. Include the full encoded plan,
+        # especially arbitrary J when W=0, and monotone history counters.
+        record_width = self.shape.saved_key_width + self.shape.payload_width + self.shape.coordinate_width + 2
+        metadata = [self.shape.ell, self.shape.spectator_width,
+                    self.shape.boundary, self.shape.halo, self.shape.payload_width,
+                    self.shape.g, *self.shape.ks]
+        for plan in self.archive.plans:
+            metadata.extend((plan.period, plan.halfwidth, plan.bits, plan.terms,
+                             plan.normalizer_shift, plan.radius,
+                             Q(plan.gap).numerator, Q(plan.gap).denominator))
+        metadata_bits = sum(abs(value).bit_length() + 2 for value in metadata)
+        counter_bits = sum(value.bit_length() + 2 for value in
+                           (self.copied_records, self.returned_records, self.rectangles))
+        carrier_units = record_width + metadata_bits + counter_bits
+        return {
+            "saved_records": self.copied_records, "returned_records": self.returned_records,
+            "rectangles": self.rectangles, "cropped_records": self.cropped_records,
+            "transport_record_width": record_width,
+            "encoded_plan_descriptor_bits": metadata_bits,
+            "cumulative_counter_bits": counter_bits,
+            "control_carrier_units": carrier_units,
+            "quadratic_codec_tariff_units": (self.copied_records + self.returned_records + self.rectangles) * carrier_units * carrier_units,
+            "tariff_scope": "The complete encoded control block is O(control_carrier_units); an O(1) multiple of reported quadratic units covers sparse geometry/key macros. These are not measured binary transitions. Numeric source/consumer scalar macros remain separately charged.",
+        }
+
+
+def sigmag(n, width):
+    need(abs(n) < 1 << (width - 1), "fixture sign-magnitude carrier")
+    return str(int(n < 0)) + format(abs(n), f"0{width - 1}b")
+
+
+def decode_word(word, width):
+    need(len(word) == 2 * width, "observer payload width")
+    pair = []
+    for part in (word[:width], word[width:]):
+        magnitude = int(part[1:], 2)
+        need(part[0] == "0" or magnitude, "observer negative zero")
+        pair.append(-magnitude if part[0] == "1" else magnitude)
+    return tuple(pair)
+
+
+def literal_totals(transport):
+    rows = transport.ledger().values()
+    return {"finite_alphabet_actions": sum(row.get(k, 0) for row in rows for k in ("read", "write", "move")),
+            "retained_finite_alphabet_cells": sum(row["retained_cells"] for row in transport.ledger().values()),
+            "roles": len(transport.roles)}
+
+
+def execute(raw, gap, words, *, saved_halo=4, fault=None):
+    """Execute one complete actual-reference transaction; observers come last."""
+    plan = M.Plan(64, 4, 28, 2, 1, gap, 1)
+    shape = Shape(5, (1,), 0, 5, saved_halo, 2 * plan.data_width)
+    source = "".join("".join(sigmag(value, plan.data_width) for value in pair) + "#" for pair in words)
+    transport = B.Program(source, "&@0#00000;", "0100000", "0000101", format(saved_halo, "07b"))
+    transport.gather()
+    transport.sort(transport.saved)
+    saved_before = transport.saved.inspect()  # Passive ownership observer.
+    transport.core_complement_test_double()
+    bill = M.Bill()
+    producer = S.make_reference(raw, (61, 3, 2, 1, 8, 32))
+    producer.require_narrow_gap()
+    table, height = M.prepare_table(plan, lambda r, c: S.source_entry(producer, r, c), producer.description_hash, bill)
+    archive = T.pack_tables((table,), bill)
+    pool = T.TensorWorkspace.create(bill)
+    codec = Codec(transport, shape, archive, pool, bill, fault=fault)
+    codec.run()
+    need(transport.saved.inspect() == saved_before, "numeric consumer changed original saved copies")
+    source_setup = S.source_receipt(producer)
+    S.clear_reference(producer)
+    archive.tape.readonly = False
+    archive.tape.clear()
+    transport.merge_returns()
+    final = transport.final.inspect().split("#")[:-1]
+    targets = {r for r in range(64) if r % 32 < 5 or r % 32 >= 27}
+    actual = {r: decode_word(final[r], plan.data_width) for r in targets}
+    for row in range(64):
+        if row not in targets:
+            original = source.split("#")[row]
+            need(final[row] == "".join("0" if bit == "1" else "1" for bit in original), "current opaque core interior preserved")
+    before_erase = literal_totals(transport)
+    transport.erase_work()
+    after_erase = literal_totals(transport)
+    need(after_erase["retained_finite_alphabet_cells"] >= before_erase["retained_finite_alphabet_cells"], "retained B backing after erase")
+    need(all(t.live_bits == 0 and t.head == 0 for t in pool.roles), "all local consumer roles blank")
+    c_roles = pool.roles + (archive.tape, table.tape)
+    receipt = {
+        "codec": codec.receipt(), "transport": after_erase,
+        "consumer_binary_actions": bill.reads + bill.writes + bill.moves,
+        "consumer_bill": bill.record(),
+        "consumer_retained_binary_cells": sum(t.extent for t in c_roles),
+        "consumer_data_roles_including_prepared_table": len(c_roles),
+        "binary_tape_primitive_upper_bound_before_scalar_macros": 10 * after_erase["finite_alphabet_actions"] + bill.reads + bill.writes + bill.moves,
+        "source_setup": source_setup, "source_height": height,
+        "final_sha256": sha256(transport.final.inspect().encode()).hexdigest(),
+    }
+    return actual, plan, receipt
+
+
+def standalone_consumer(raw, gap, words):
+    """Independent delivery oracle, explicitly outside the production codec."""
+    plan = M.Plan(64, 4, 28, 2, 1, gap, 1)
+    bill = M.Bill()
+    source = S.make_reference(raw, (61, 3, 2, 1, 8, 32))
+    table, _ = M.prepare_table(plan, lambda r, c: S.source_entry(source, r, c), source.description_hash, bill)
+    archive = T.pack_tables((table,), bill)
+    pool = T.TensorWorkspace.create(bill)
+    answers = {}
+    for lower in (0, 27, 32, 59):
+        targets = ((lower, 5),)
+        layout = T.Layout.make(archive.plans, targets)
+        external_values = (words[x % 64] for x in range(layout.lowers[0], layout.lowers[0] + layout.lengths[0]))
+        input_tape = T.rectangle_input(layout, external_values, bill, tape=pool.rectangles[0])
+        output = T.apply_tensor(archive, targets, input_tape, bill, workspace=pool)
+        for _ in range(output.count):
+            key, value = T.get_record(output.tape, output.layout)
+            canonical = (output.layout.lowers[0] + output.layout.coordinate(key, 0)) % 64
+            need(canonical not in answers, "oracle target uniqueness")
+            answers[canonical] = value
+        output.tape.clear()
+    return answers
+
+
+def main():
+    oracle = load("join_independent_source_oracle", PACKAGE / "oracle.py")
+    _, raw, matrix, gap, source_receipt = oracle.source_fixture()
+    words = oracle.fixture_words(64, 28)
+    expected_bits = standalone_consumer(raw, gap, words)
+    expected_inverse = oracle.exact_inverse_action(matrix, words, 28, 2)
+    actual, plan, receipt = execute(raw, gap, words)
+    need(actual == expected_bits, "streamed codec differs bitwise from independent rectangle delivery")
+    maximum = max(sum(abs(Q(actual[row][j], 1 << plan.bits) - expected_inverse[row][j]) for j in range(2)) for row in actual)
+    bound = plan.numeric_error + plan.tail_error
+    need(maximum <= bound, "actual original-reference inverse error")
+    controls = []
+    for fault in ("offset", "omit_wrap", "drop_saved", "return_key"):
+        try:
+            execute(raw, gap, words, fault=fault)
+        except (ValueError, B.Reject):
+            controls.append(fault)
+        else:
+            raise ValueError("joined control failed to reject: " + fault)
+    wrong, _, _ = execute(raw, gap, words, fault="payload_magnitude")
+    need(wrong != expected_bits, "wrong saved payload magnitude escaped exact delivery oracle")
+    controls.append("payload_magnitude_exact_mismatch")
+    receipt.update(source=source_receipt, returned_targets=len(actual),
+                   exact_delivery_match=True,
+                   maximum_original_inverse_error=[maximum.numerator, maximum.denominator],
+                   proved_error_bound=[bound.numerator, bound.denominator],
+                   controls=controls,
+                   scope="Actual-reference sparse codec/consumer/return; core is destructive test double, source/consumer scalar macros explicitly priced; no new kappa")
+    print("PASS_FIRST_FACE_REFERENCE_JOIN")
+    print(json.dumps(receipt, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/first-face-reference-join/oracle.py b/research/first-face-reference-join/oracle.py
new file mode 100644
index 0000000000..5f8049bcbe
--- /dev/null
+++ b/research/first-face-reference-join/oracle.py
@@ -0,0 +1,149 @@
+"""Independent dense original-reference solve for the B/C join fixture.
+
+Fixture/oracle helper, not a physical tape codec or production cost claim.
+Prepared for @CubeJerry with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+from fractions import Fraction as Q
+from hashlib import sha256
+import importlib.util
+import json
+from pathlib import Path
+import sys
+
+PACKAGE = Path(__file__).resolve().parent.parent / 'shrinking-reference-halo'
+PARAMETERS = (61, 3, 2, 1, 8, 32)
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def fixture_words(n, q):
+    """Actual grid integers, component-l1 norm below1/2 at every row."""
+    if q < 9:
+        raise ValueError('fixture grid')
+    unit = 1 << (q - 9)
+    return tuple((((37 * r + 11) % 241 - 120) * unit,
+                  ((53 * r + 7) % 181 - 90) * unit) for r in range(n))
+
+
+def exact_inverse_action(matrix, words, bits, normalizer):
+    """Solve original H y=x/a by exact rational elimination, two RHS."""
+    n = len(matrix)
+    if len(words) != n or any(len(row) != n for row in matrix):
+        raise ValueError('exact solve dimensions')
+    scale = (1 << bits) * normalizer
+    augmented = [list(row) + [Q(words[i][j], scale) for j in range(2)]
+                 for i, row in enumerate(matrix)]
+    for column in range(n):
+        pivot = next((r for r in range(column, n) if augmented[r][column]), None)
+        if pivot is None:
+            raise ValueError('singular original reference')
+        augmented[column], augmented[pivot] = augmented[pivot], augmented[column]
+        value = augmented[column][column]
+        augmented[column] = [entry / value for entry in augmented[column]]
+        for r in range(column + 1, n):
+            value = augmented[r][column]
+            if value:
+                augmented[r] = [x - value * y
+                                for x, y in zip(augmented[r], augmented[column])]
+    result = [[Q(0), Q(0)] for _ in range(n)]
+    for row in range(n - 1, -1, -1):
+        for part in range(2):
+            result[row][part] = augmented[row][n + part] - sum(
+                augmented[row][column] * result[column][part]
+                for column in range(row + 1, n))
+    for row in range(n):
+        for part in range(2):
+            if sum(matrix[row][c] * result[c][part] for c in range(n)) != Q(words[row][part], scale):
+                raise ValueError('exact original-reference solve residual')
+    return tuple(tuple(pair) for pair in result)
+
+
+def source_fixture(package=PACKAGE):
+    source = load('join_source_oracle', package / 'source.py')
+    raw = source.authenticated_inputs(package)
+    reference = source.make_reference(raw, PARAMETERS)
+    reference.require_narrow_gap()
+    n = reference.target_size
+    matrix = tuple(tuple(reference.entry('narrow', r, c).value for c in range(n))
+                   for r in range(n))
+    E = tuple(tuple(Q(int(r == c)) - matrix[r][c] for c in range(n))
+              for r in range(n))
+    rho = max(sum(map(abs, row)) for row in E)
+    gap = Q(int((1 - rho) * (1 << 16)), 1 << 16)
+    if gap <= Q(1, 2):
+        raise ValueError('fixture normalizer not funded')
+    if any(E[r][c] for r in range(n) for c in range(n)
+           if min((r-c) % n, (c-r) % n) > 4):
+        raise ValueError('actual reference not W4 banded')
+    holes = [r for r in range(n) if not any(E[r])]
+    wraps = [(r, c) for r in range(n) for c in range(n)
+             if E[r][c] and abs(r-c) > 4]
+    return source, raw, matrix, gap, dict(
+        parameters=PARAMETERS, period=n, original_entries=n*n,
+        source_sha256=reference.description_hash,
+        gap=[gap.numerator, gap.denominator], identity_holes=holes,
+        periodic_nonzero_coordinates=wraps)
+
+
+def main():
+    source, raw, matrix, gap, receipt = source_fixture()
+    engine = load('shrinking_halo_engine', PACKAGE / 'engine.py')
+    tensor = load('join_tensor_oracle', PACKAGE / 'tensor.py')
+    plan = engine.Plan(64, 4, 28, 2, 1, gap, 1)
+    words = fixture_words(64, plan.bits)
+    expected = exact_inverse_action(matrix, words, plan.bits, 2)
+    bill = engine.Bill()
+    producer = source.make_reference(raw, PARAMETERS)
+    table, height = engine.prepare_table(
+        plan, lambda r,c: source.source_entry(producer,r,c),
+        producer.description_hash, bill)
+    archive = tensor.pack_tables((table,), bill)
+    pool = tensor.TensorWorkspace.create(bill)
+    actual = {}
+    rectangles = []
+    for lower in (0, 27, 32, 59):
+        targets = ((lower, 5),)
+        layout = tensor.Layout.make(archive.plans, targets)
+        # External fixture load only; B's streamed physical codec replaces it.
+        data = (words[x % 64] for x in range(layout.lowers[0],
+                                           layout.lowers[0] + layout.lengths[0]))
+        tape = tensor.rectangle_input(layout, data, bill, tape=pool.rectangles[0])
+        output = tensor.apply_tensor(archive, targets, tape, bill, workspace=pool)
+        for _ in range(output.count):
+            key, pair = tensor.get_record(output.tape, output.layout)
+            coordinate = (output.layout.lowers[0] + output.layout.coordinate(key,0)) % 64
+            if coordinate in actual:
+                raise ValueError('overlapping first-face return')
+            actual[coordinate] = pair
+        output.tape.clear()
+        rectangles.append(dict(lower=lower, copies=layout.volume, targets=output.count))
+    if set(actual) != {r for r in range(64) if r % 32 < 5 or r % 32 >= 27}:
+        raise ValueError('incomplete first-face return')
+    maximum = max(sum(abs(Q(actual[r][j],1 << plan.bits) - expected[r][j])
+                      for j in range(2)) for r in actual)
+    bound = plan.numeric_error + plan.tail_error
+    if maximum > bound:
+        raise ValueError('original inverse error exceeds proved bound')
+    shifted = max(sum(abs(Q(actual[r][j],1 << plan.bits) - expected[(r+1)%64][j])
+                      for j in range(2)) for r in actual)
+    if shifted <= bound:
+        raise ValueError('wrong-return control not separated')
+    receipt.update(rectangles=rectangles, checked_targets=len(actual),
+                   maximum_inverse_error=float(maximum), proved_error_bound=float(bound),
+                   wrong_return_error=float(shifted), source_height=height,
+                   setup_source=source.source_receipt(producer),
+                   physical_bit_actions=bill.reads+bill.writes+bill.moves,
+                   program_sha256={name:sha256((PACKAGE/name).read_bytes()).hexdigest()
+                                   for name in ('engine.py','tensor.py','source.py')})
+    print('PASS_PRIME_REFERENCE64_DIRECT_SOLVE')
+    print(json.dumps(receipt,sort_keys=True))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/first-face-reference-join/replay_all.py b/research/first-face-reference-join/replay_all.py
new file mode 100644
index 0000000000..baaab33974
--- /dev/null
+++ b/research/first-face-reference-join/replay_all.py
@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+"""Run the three registered component/composition packages sequentially."""
+from pathlib import Path
+import subprocess
+import sys
+
+ROOT = Path(__file__).resolve().parents[2]
+PACKAGES = (
+    "research/sparse-halo-tape-transaction",
+    "research/shrinking-reference-halo",
+    "research/first-face-reference-join",
+)
+
+for package in PACKAGES:
+    subprocess.run(
+        [sys.executable, "-B", str(ROOT / "scripts/research_package.py"),
+         "--package", package], cwd=ROOT, check=True, timeout=1200,
+    )
+print("PASS_COMPLETE_FIRST_FACE_HALO_PACKAGE")
diff --git a/research/shrinking-reference-halo/OVERLAP.json b/research/shrinking-reference-halo/OVERLAP.json
new file mode 100644
index 0000000000..aabbd93b28
--- /dev/null
+++ b/research/shrinking-reference-halo/OVERLAP.json
@@ -0,0 +1,292 @@
+{
+  "schema_version": 1,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "checked_utc": "2026-11-08 16:11:04 UTC",
+  "scope": "Original-reference band production and sequential shrinking-domain local tensor consumer; direct degree specialization, generic Horner stability, whole-period host service and outer recovery joins excluded.",
+  "queries": [
+    {
+      "query": "\"shrinking\" \"halo\"",
+      "topn": 30,
+      "results": []
+    },
+    {
+      "query": "\"Horner\" \"halo\"",
+      "topn": 30,
+      "results": []
+    },
+    {
+      "query": "\"periodic\" \"inverse\" \"tape\"",
+      "topn": 30,
+      "results": [
+        {
+          "number": 6788,
+          "title": "Prove the sharp inverse envelope under a column cap (no κ)",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6788"
+        },
+        {
+          "number": 6542,
+          "title": "Realize the sparse correction as a reversible nearest-grid map",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6542"
+        },
+        {
+          "number": 6438,
+          "title": "Construct optimal unbiased reversible phase rounding (no κ)",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6438"
+        },
+        {
+          "number": 6426,
+          "title": "Prove necessary square-root degree growth for cyclic inverses (no κ)",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6426"
+        },
+        {
+          "number": 6072,
+          "title": "Joint denominator-13 decisions need fewer expected fair bits than separate calls",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6072"
+        },
+        {
+          "number": 5859,
+          "title": "Prove the sharp inverse envelope with forbidden diagonals (no new κ)",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5859"
+        },
+        {
+          "number": 5260,
+          "title": "Replace 119 periodic inverse updates with a certified direct solve",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5260"
+        },
+        {
+          "number": 5255,
+          "title": "Prove the sharp graph-support inverse norm envelope",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5255"
+        },
+        {
+          "number": 5284,
+          "title": "Prove variable-gap precision and linear storage for cyclic band solves",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5284"
+        },
+        {
+          "number": 5207,
+          "title": "Prove exact real Gaussian Schur fill signs for t <= 1/3 (no new κ)",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5207"
+        },
+        {
+          "number": 5216,
+          "title": "Prove weighted periodic Gaussian power bound and reduce complete inverse to120 terms",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5216"
+        },
+        {
+          "number": 5159,
+          "title": "Complete the same-reference periodic rounded inverse service",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5159"
+        },
+        {
+          "number": 4959,
+          "title": "Prove routing and Fourier component results with exact checks",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4959"
+        },
+        {
+          "number": 4870,
+          "title": "Audit source-driven Gaussian halo copy enumeration (no new kappa)",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4870"
+        },
+        {
+          "number": 4217,
+          "title": "Audit #4100's HALO locality witness: exact error identity and sharp (2J-1)W radius (no new κ)",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4217"
+        },
+        {
+          "number": 1038,
+          "title": "Construction: reversible quadratic phases for the dirty stride solver (no new kappa)",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1038"
+        },
+        {
+          "number": 2313,
+          "title": "Research: execute certified Gaussian resampling through exact integer recovery",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2313"
+        },
+        {
+          "number": 486,
+          "title": "Build binary compression halo boxes with fused streaming and sparse repair",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/486"
+        },
+        {
+          "number": 929,
+          "title": "Research: four grouped cyclic inverse calls with one dirty connector (no new kappa)",
+          "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/929"
+        }
+      ]
+    }
+  ],
+  "verified_pr_metadata": [
+    {
+      "number": 1430,
+      "title": "Audit: quadratic rounding accumulation and linear-error Neumann evaluation (no new kappa)",
+      "state": "closed",
+      "merged": true,
+      "head": "1655c721a1c2aa92f584523afc93a192137cf910",
+      "base": "410026dc5513b87db92ae98571d1d5984c69a983",
+      "user": "bbMisk",
+      "updated_at": "2026-10-14T06:48:19Z",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1430"
+    },
+    {
+      "number": 3851,
+      "title": "Implement normalized Gaussian compression cores on fixed tapes",
+      "state": "closed",
+      "merged": true,
+      "head": "7ab67b4a84d28cd562b9711aa315ca5b47822b37",
+      "base": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+      "user": "jmbarrancoml",
+      "updated_at": "2026-10-20T05:22:44Z",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3851"
+    },
+    {
+      "number": 4100,
+      "title": "Propose unconditional κ = 0.00173097911567079247276057 via batched CRT",
+      "state": "closed",
+      "merged": true,
+      "head": "337d04939571a637aeab54a0f58f54fde811663a",
+      "base": "bb4bccbf42844d2801487450727c2f63e10d1d0f",
+      "user": "1337isnot1337",
+      "updated_at": "2026-10-20T11:36:03Z",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4100"
+    },
+    {
+      "number": 4205,
+      "title": "Execute rounded Gaussian words against shared finite-core references",
+      "state": "closed",
+      "merged": true,
+      "head": "78c72e563173f3822fcb4efed9ceeccf05630258",
+      "base": "12fa8c5c844be21bfefb38a19503fbd867a11244",
+      "user": "jmbarrancoml",
+      "updated_at": "2026-10-21T19:22:10Z",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4205"
+    },
+    {
+      "number": 4253,
+      "title": "Lower rational FFT and conditioned Toeplitz programs to fixed Hadamard stages",
+      "state": "closed",
+      "merged": true,
+      "head": "ac14c1409c261d64d9856a5a473d8b7f2be8c302",
+      "base": "12fa8c5c844be21bfefb38a19503fbd867a11244",
+      "user": "jmbarrancoml",
+      "updated_at": "2026-10-21T19:24:13Z",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4253"
+    },
+    {
+      "number": 4415,
+      "title": "Answer #4371's open question 1: one coefficient's error path through #4100's transforms carries one factor of T (m = 1), so C = 5 suffices for b >= 13 (no new κ)",
+      "state": "closed",
+      "merged": true,
+      "head": "ebfa9588f5a1ca4c595b3ff837f24917d5dd7caf",
+      "base": "12fa8c5c844be21bfefb38a19503fbd867a11244",
+      "user": "pinterbanget",
+      "updated_at": "2026-10-21T19:27:52Z",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4415"
+    },
+    {
+      "number": 4870,
+      "title": "Audit source-driven Gaussian halo copy enumeration (no new kappa)",
+      "state": "closed",
+      "merged": true,
+      "head": "43a87adb92a25da168073280b206e15b70fbe42c",
+      "base": "624de9dc66858af0945e5f8a0942488d62280d43",
+      "user": "codyw912",
+      "updated_at": "2026-10-23T01:45:56Z",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4870"
+    },
+    {
+      "number": 5159,
+      "title": "Complete the same-reference periodic rounded inverse service",
+      "state": "closed",
+      "merged": true,
+      "head": "ba435a39f69436f2f7ce5cc02f18879c8d8790f5",
+      "base": "a5df48c55ea806d7952b65acc9c76d878ff09b13",
+      "user": "JoyboyBrian",
+      "updated_at": "2026-10-23T11:56:46Z",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5159"
+    },
+    {
+      "number": 5216,
+      "title": "Prove weighted periodic Gaussian power bound and reduce complete inverse to120 terms",
+      "state": "closed",
+      "merged": true,
+      "head": "1ea9efdc1d1d36757a5491bf7fdaa93597dcea67",
+      "base": "ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c",
+      "user": "JoyboyBrian",
+      "updated_at": "2026-10-23T13:09:35Z",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5216"
+    },
+    {
+      "number": 5260,
+      "title": "Replace 119 periodic inverse updates with a certified direct solve",
+      "state": "closed",
+      "merged": true,
+      "head": "65cdd6b36e002ce9d13bd96dbc504da90f77f2c9",
+      "base": "ff3cc58e370d0f678e529246f8c73e8094e18fcf",
+      "user": "aliromman",
+      "updated_at": "2026-10-23T18:37:53Z",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5260"
+    },
+    {
+      "number": 5284,
+      "title": "Prove variable-gap precision and linear storage for cyclic band solves",
+      "state": "closed",
+      "merged": true,
+      "head": "72269696a9c5ae5b1c0b469afdd3db08080635cf",
+      "base": "ff3cc58e370d0f678e529246f8c73e8094e18fcf",
+      "user": "aliromman",
+      "updated_at": "2026-10-23T18:37:53Z",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5284"
+    },
+    {
+      "number": 5325,
+      "title": "Join Tensor error bounds through compression and final restoration",
+      "state": "closed",
+      "merged": true,
+      "head": "bea42af24ee9850949a4b48d329a7dc85de72b11",
+      "base": "ff3cc58e370d0f678e529246f8c73e8094e18fcf",
+      "user": "aliromman",
+      "updated_at": "2026-10-23T18:37:52Z",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5325"
+    },
+    {
+      "number": 5986,
+      "title": "Reduce Gaussian inverse locality degree from p^42 to p^22 (no new κ)",
+      "state": "closed",
+      "merged": true,
+      "head": "31bbc7b22ea697437660a0af4c006e114b90710b",
+      "base": "19fdb086ea96af9a9f87936a2b888e10af4ed810",
+      "user": "petalas",
+      "updated_at": "2026-10-28T00:24:32Z",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5986"
+    },
+    {
+      "number": 6490,
+      "title": "Reduce Horner oracle precision volume with increasing grids (no κ)",
+      "state": "open",
+      "merged": false,
+      "head": "4307d3a0cb8921b58ec2f229fdad41db25849932",
+      "base": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+      "user": "petalas",
+      "updated_at": "2026-11-03T01:01:48Z",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6490"
+    },
+    {
+      "number": 6880,
+      "title": "Prove a rounded finite-core and sparse-halo composition bound (no new κ)",
+      "state": "open",
+      "merged": false,
+      "head": "e212af981b49c299de515f8c23dfb0e5b73e2e95",
+      "base": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+      "user": "CubeJerry",
+      "updated_at": "2026-11-08T15:01:00Z",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6880"
+    }
+  ],
+  "coverage_limits": [
+    "Focused live title/body queries and cited predecessor source packages; not all historical diffs or unpublished work.",
+    "Search results omit status fields; cited status/head metadata were separately fetched by PR endpoint.",
+    "Lead surveyed canonical research-directory metadata and broader dependency landscape. This worker did not repeat a repository-wide archive survey.",
+    "Discussion posting unavailable to the lead; scope is recorded in the lead's local allocation manifest. No public advance reservation is asserted."
+  ]
+}
diff --git a/research/shrinking-reference-halo/PROOF.md b/research/shrinking-reference-halo/PROOF.md
new file mode 100644
index 0000000000..c47fc7013b
--- /dev/null
+++ b/research/shrinking-reference-halo/PROOF.md
@@ -0,0 +1,578 @@
+# A source-bound shrinking-domain Gaussian halo consumer
+
+Prepared for @CubeJerry with substantial OpenAI Codex assistance. Apache-2.0.
+
+## 1. Result, scope and predecessor boundary
+
+This is a constructive local tensor result under a certified fixed-reference
+row gap. It supplies the numerical consumer and its sequential data/page
+protocol on one saved sparse rectangle. It does not prove the complete outer
+Gaussian construction, admit the selected suppliers, or change kappa.
+
+The fixed-source Horner identity is classical. In this repository, #1430 already
+uses it to control rounding under a fixed approximate oracle with norm at most
+0.42; #6490 allocates precision across that oracle's calls. #5159 implements a
+rounded whole-period action on one actual rational Gaussian Reference, with
+coefficient error, data error and storage charged at a host-array interface.
+#5216 improves its tail and #5260/#5284 supply direct-solve alternatives, also
+without a complete physical sparse caller. #3851 implements a different
+principal-core/Schur interface, with its own source parameters and gap.
+
+#6880 already proves direct row-gap locality, normalized nonlinear core/halo
+composition, inward-rounded polynomial rows, and the specialization J=16p^4.
+Those are not new claims here. That package leaves production of the global
+polynomial coefficient pages and their physical access unpriced. #4100's HALO
+argument permits a polynomial-time local correction but does not implement
+the present recurrence, shrinking domains, or table/line schedule.
+
+The contribution is an explicit replacement for that remaining polynomial-row
+interface: store only the original reference band, shrink the dependency
+interval after every iteration, expose axes by sorting only sparse records,
+reuse one page across every spectator line, and use eight fixed local tape
+roles plus one protected coefficient archive. Its quantified all-size bill
+includes reference production, repeated full archive scans, encoded controls,
+scalar arithmetic, copies, head returns and retained blank backing. A full-axis
+scan is retained explicitly in the generic theorem; it is absorbed only in the
+specified balanced growing-group regime.
+
+The universal argument below is a written proof. The executable fixtures
+corroborate it; neither finite traces nor separate AI review are formal-kernel
+or independent human acceptance.
+
+## 2. Exact input contract
+
+For axis i, let H_i=I-E_i be a real rational matrix of period N_i. Let W_i be a
+nonnegative integer with 2W_i<N_i. A matrix entry E_i[r,c] is zero unless c is
+congruent to r+v for a unique integer v in [-W_i,W_i]. Require
+
+    ||E_i||_infinity <= rho_i = 1-delta_i,   0 < delta_i <= 1.
+
+The finite producer checks the mass of every stored row. In the generic
+theorem, zero outside the stated band is a separate hypothesis: checking a
+row's stored entries cannot certify unstored entries. For the source binding
+in Section 7, the original Reference support rule proves this hypothesis;
+the finite checker also enumerates the entire matrix independently of the
+producer's band enumeration.
+
+Let s_i=2W_i+1, J_i>=1, and choose an integer u_i>=0 with
+a_i=2^u_i and a_i delta_i>=1. Choose one data/coefficient grid h=2^-q with
+q>=max_i u_i. The incoming complex array has components on this grid and
+
+    ||x||_* = max_r (|Re x_r| + |Im x_r|) <= R,
+
+where the executable interface takes an integer R>=1. A complex-modulus unit
+disk input fits this interface with R=2. Every actual incoming line is checked
+against its stated bound. The theorem does not infer an outer caller's input
+radius merely from an exact ideal map.
+
+An output interval T_i=[t_i,t_i+m_i) is interpreted on the integer lift of the
+physical circle. Set b_i=(J_i-1)W_i and
+
+    D_i = [t_i-b_i, t_i+m_i+b_i),     d_i = m_i+2b_i.
+
+Require d_i<N_i. Thus even a wrapping interval contains each canonical
+coordinate at most once. The saved input rectangle is D=product_i D_i, and
+the target is T=product_i T_i. Coordinates are reduced modulo N_i only when
+addressing the fixed global reference or the original global array. A page
+is never redefined as a translated Reference and does not merge the original
+period's first and last phase cells.
+
+The saved rectangle must already contain the original pre-core-mutation values.
+Its construction and the final unique dense return belong to the enclosing
+caller. This consumer owns and may consume the saved copy. Its per-axis source
+line is immutable until that line's complete polynomial output has been made.
+It returns only T, in increasing lifted lexicographic order.
+
+## 3. Normalized fixed-source recurrence and actual numerical states
+
+Truncate each real coefficient of E_i toward zero to the q grid, obtaining
+Ehat_i. This is truncation of the fixed rational reference, not an assertion
+that one can determine the exact floor of an irrational Gaussian coefficient.
+Then
+
+    ||Ehat_i||_infinity <= rho_i,
+    ||Ehat_i-E_i||_infinity < s_i h.
+
+All s_i slots, including zero slots at holes and the zero diagonal, are stored
+and paid for. Let Q_q truncate both real and imaginary components toward zero.
+Its error in the component-l1 norm is less than 2h and it does not increase
+that norm.
+
+For a fixed incoming line x, use
+
+    z_0=0,
+    z_(k+1)=Q_q(x/a_i + Ehat_i z_k),       0 <= k < J_i.       (1)
+
+Every z_k remains on exactly the same q grid. If ||z_k||_*<=R, then
+
+    ||x/a_i + Ehat_i z_k||_* <= R/a_i + rho_i R <= R.
+
+Truncation preserves the bound, so induction proves that every *computed*
+state has radius at most R. The input to a later tensor axis consequently
+fits the same contract. No unproved rounded-map Lipschitz property is used.
+
+The program forms each dot product and its fixed-source summand exactly, then
+rounds the completed real and imaginary sums once. If input/data numerators
+are X and Z and a stored coefficient numerator is C, its accumulator is
+
+    X * 2^(q-u_i) + sum C Z,
+
+at scale 2^(2q). This is why q>=u_i is required. The absolute component-l1 sum
+of any partial accumulator is at most R*2^(2q): it is bounded by the source
+term plus a partial sum of coefficient absolute values times R. A signed
+carrier of 2q+ceil(log2(R+1))+2 bits is ample. Coefficient and data carriers
+have q+O(log(R+1)) bits. The code checks the actual partial accumulator bound,
+not just the final rounded result.
+
+Write y_k=(1/a_i) sum_(j=0)^(k-1) E_i^j x. Its norm is also at most R.
+Subtract its recurrence from (1), evaluating the perturbation at the *actual*
+z_k. If e_k=||z_k-y_k||_*, then
+
+    e_(k+1) <= rho_i e_k + s_i h R + 2h,    e_0=0.
+
+Therefore
+
+    ||z_(J_i) - P_i x/a_i||_* <= nu_i,
+    P_i=sum_(j=0)^(J_i-1) E_i^j,
+    nu_i=(s_i R+2) h/delta_i.                              (2)
+
+The sharper finite geometric factor could be retained; (2) is sufficient.
+The exact normalized polynomial and inverse both have induced norm at most
+one, and the tail is
+
+    ||P_i/a_i-H_i^-1/a_i||_infinity
+        <= tau_i = rho_i^J_i/(a_i delta_i).                 (3)
+
+These numerical estimates retain standard Neumann/Horner reasoning and the
+whole-period predecessor's coefficient/data accounting. Their role here is
+to certify the actual finite-precision sequential local program.
+
+## 4. The shrinking domain is exactly sufficient
+
+Define
+
+    D_i^(k) = T_i + [-(J_i-k)W_i, (J_i-k)W_i],
+                         1 <= k <= J_i,
+
+where the notation denotes the corresponding half-open integer interval.
+Compute z_1=Q_q(x/a_i) on D_i^(1)=D_i. To compute z_(k+1) on D_i^(k+1),
+read its source x there and every previous neighbor within distance W_i.
+Those neighbors lie in D_i^(k). The global coefficient for the corresponding
+canonical row and offset is obtained from the already fixed band page.
+
+Induction on k now proves equality, bit for bit, with the restriction of the
+full-period rounded recurrence (1). This statement does not require linearity
+of rounding. It follows because each local update sees exactly the same
+coefficient numerators, source numerator and prior neighbor numerators as the
+global update. At k=J_i the returned interval is precisely T_i.
+
+This is not the polynomial of E restricted to T_i or to the eventual returned
+rectangle. Such a restriction loses paths that leave and reenter it. The
+program retains D_i^(k) until its use at the next step, then discards only the
+two already unnecessary boundary strips. The initial padding is exactly the
+maximum dependency distance of the degree J_i-1 polynomial.
+
+For h_axes axes processed in order, after completing axis i the maintained
+rectangle is
+
+    S_i = T_0 x ... x T_i x D_(i+1) x ... x D_(h_axes-1).     (4)
+
+At the next axis, every needed neighbor differs only in that next coordinate.
+The earlier coordinates therefore need no padding after their axes have
+completed. The later coordinates must retain their complete original D_j.
+Applying the one-axis induction to every spectator line proves exact agreement
+with the corresponding restriction of the full-period nonlinear tensor
+recurrence. That full-period recurrence is an analysis device, not an executed
+dense algorithm.
+
+Compare this global rounded composition first with the product of P_i/a_i.
+Each local error bound (2) holds at the actual incoming state, which has radius
+R. Each exact P_i/a_i is a contraction. Telescoping against these exact maps
+gives numerical error at most sum_i nu_i. Telescoping (3), using contraction
+of both factors, then gives the complete inverse-tensor guarantee
+
+    ||returned - [product_i (H_i^-1/a_i)] x |_T||_*
+        <= sum_i nu_i + R sum_i tau_i.                     (5)
+
+No factor depending on the global tensor dimension occurs in (5). No
+assumption that the rounded program itself is additive or nonexpansive is
+made. The proof applies to every global extension of the saved input with
+radius at most R, since all omitted inverse dependence is explicitly funded
+by (3).
+
+## 5. One sequential line and its exact invoice
+
+The global band table is ordered by canonical row, then by offsets -W_i to
+W_i. A local page is ordered by lifted row, then by the same offsets. If D_i
+wraps, one complete table scan emits its final-period part, and a second
+complete scan emits its initial-period part. All skipped coefficients are
+read and both complete scans return to the origin. No constant-cost global
+row query, arbitrary seek or hidden page cache is assumed.
+
+`apply_line` uses the immutable source, immutable page, and two owned iterate
+tapes. It forms z_1 by one source scan. During an update, a row reads the
+2W_i+1 adjacent previous records in increasing order. Before the next output
+row, the previous-state head walks back exactly 2W_i records. Thus the next
+window advances by one. At the final row the head is at the end of the prior
+live body. The source and page also make explicit forward skips and complete
+returns. Before reusing an iterate role, the program clears its complete
+previous live body, including all rows that existed before the next shrink.
+It never substitutes the smaller newly produced length for that old length.
+
+Each role maintains a live-body length and a separate historical extent. All
+cells at or beyond the live length are already zero. The invariant is true
+on a fresh blank tape. A write extends the live length through its position;
+the formerly unoccupied gap and remaining suffix were already blank. Clearing
+the complete previous live body makes the live length zero and leaves the
+invariant true. Thus a historical blank suffix remains paid in space without
+being rescanned at every later reuse. Program transitions use this invariant
+and encoded lengths, not an uncharged host inspection of the backing array.
+
+This distinction is necessary for the claimed tariff. A long L-sized line
+followed by an A-sized face line must not pay L cells per clear on each short
+line. That alternative adds a factor L/A and can consume the sparse volume
+saving. The verifier executes a long-line/short-face/long-line history on the
+same roles, checks actual blank suffixes independently, and compares an
+executed counterfactual that clears the historical extent on every reuse.
+
+For target length m, the live lengths after k terms are
+n_k=m+2(J_i-k)W_i. A complex line performs exactly
+
+    2s_i sum_(k=2)^J_i n_k
+      = 2s_i[(J_i-1)m + W_i(J_i-1)(J_i-2)]
+
+integer products and the same number of accumulator additions. It performs
+
+    2 sum_(k=1)^J_i n_k = 2[J_i m + W_i J_i(J_i-1)]
+
+component roundings. The fixed-source shifts, reads, output writes,
+initialization, complete old-live-body erasure and all head motion are separately
+counted. J_i=1 and W_i=0 are allowed by these formulas.
+
+Let w bound the numerical carriers and the entire encoded descriptor/control
+block, including signed absolute origins, lengths, periods, iteration counts,
+loop counters and local keys. A decoded scalar integer addition, shift,
+comparison, multiplication or division is implemented by ordinary fixed-tape
+binary arithmetic. Schoolbook multiplication/division costs O(w^2). Even
+charging O(w^2) for each scalar encode/decode, rather than treating a host
+integer shift as unit time, a line costs
+
+    O(J_i d_i s_i w^2) bit operations.                     (6)
+
+Its source plus two iterate roles occupy at most 6d_i times the component
+carrier width; its page occupies d_i s_i(q+2) bits. Add O(w) scalar/control
+storage and the separately retained global archive. A returned output occupies
+one of those two iterate roles, so it is not omitted from the space count.
+Unused suffixes can remain allocated but are blank and are included in this
+bound. `maximum_single_tape_extent` is only the largest individual tape;
+the verifier separately sums every retained local role.
+
+The Python program executes every binary tape read/write and one-cell head
+move. Its integer operations implement scalar-macro semantics; its elapsed
+Python time is not asserted to equal the asymptotic bit bound (6). The proof
+supplies the fixed-tape implementation and cost of those scalar macros.
+
+## 6. Complete local rectangle schedule and generic cost
+
+The payload has a fixed-width key comprising the nonnegative offsets within
+the original D_i, followed by signed fixed-width real/imaginary numerators.
+Let K=sum_i max(1,ceil(log2 d_i)); unused field encodings are not valid
+coordinates. An initial lexicographic stream is encoded in one charged pass.
+The same fixed key fields remain valid after an axis shrinks. Return converts
+offsets back to lifted coordinates; the outer caller may reduce them modulo
+the periods in another explicitly charged pass.
+
+To expose axis i, perform stable least-significant-bit distribution into two
+fixed buckets. Process the bits of field i first, then the bits of the other
+fields in reverse natural order. Concatenation of the zero and one buckets
+after each pass leaves the other fields in natural lexicographic order, with
+axis i innermost. Each pass scans and clears the entire live owned sparse body
+and both live buckets; already blank retained tails obey the same invariant.
+It never scans the dense
+global data array. There are exactly K passes per axis. The conservative
+scalar encode/decode convention above charges O(K C_i w^2) bit work for a
+body with C_i records, rather than hiding key operations in a unit-cost word.
+
+After exposure, each complete spectator line is copied into one reusable
+immutable line role, evaluated by Section 5, and emitted with target-only
+keys into the alternate rectangle role. The local band page is produced
+once per rectangle/axis, before its first line, and reused across all of those
+lines. Only after the entire axis output is complete is the previous rectangle
+cleared. Equation (4) gives the next live shape. After the final axis, natural
+lexicographic order is already restored.
+
+There are eight local roles: current/next rectangles, two radix buckets,
+one line source, two iterates and one local page. Their count is independent
+of J_i, the number of lines, rectangles and axes. `tensor.py` creates the pool
+once in `TensorWorkspace`, passes the same iterate roles to every line, and
+clears every nonreturn role. After the caller consumes and clears the returned
+rectangle, the same workspace accepts the next rectangle through the explicit
+`rectangle_input(..., tape=...)` and `apply_tensor(..., workspace=...)` interfaces.
+The verifier seals all tape constructors across a long/short/long sequence of
+complete rectangle calls and checks that the identical eight role objects
+return blank. Across such a history, space is the sum of the eight historical
+extents, bounded by the largest admitted body for each role; time depends on
+the currently occupied lengths, by the invariant in Section 5.
+The global tables are concatenated in one protected archive; `pack_tables`
+consumes and clears one temporary table before requesting the next from its
+generator. Thus a growing number of axes does not require a growing number of
+physical tapes. Descriptor tuples in the Python reference represent one
+encoded control block. Scan/selection costs on that block are bounded by w
+and included in the w^2 allowances; indexed metadata is not free access to
+payload or coefficients.
+
+Let C=product_i d_i and G=sum_i N_i s_i be the total band coefficient count in
+the current group's archive. The executable scans the *entire concatenated
+archive* once or twice for each axis page, including other axes' coefficients.
+If T_ref denotes reference production and quantization, the complete generic
+local bill is
+
+    T_ref + O(w^2 [h_axes G + C sum_i (J_i s_i + K + 1)]).   (7)
+
+Input codec, all source/data/page transfers, output copying, sorting,
+arithmetic, head returns and erasure are included. T_ref is a separately
+amortized group setup if the archive is reused for several rectangles. The
+term h_axes G remains present for each rectangle; it is not automatically a
+local polynomial merely because d_i is polynomial.
+
+With eight local roles, their total retained extent is
+
+    O(Cw + max_i d_i s_i q),
+
+plus O(w) control/scalar storage and the protected archive G(q+2). At most a
+constant number of old/new rectangle bodies coexist. The producer's setup
+scratch is additional, as quantified next. The code's physical action counts
+and full retained extents are evidence for this schedule, not a byte-exact
+claim about Python's object allocator or secure memory zeroization.
+
+## 7. Binding to the actual retained Gaussian entry producer
+
+The live source is `research/rational-unitary-fft/gaussian_reference.py` at
+the exact base in SOURCES.json. Its original geometry and proof are retained
+in `RAW-GAUSSIAN-PROOF.md`. `source.py` authenticates all source bytes before
+execution. It rebinds the original import dependencies and extracts only the
+unchanged `rational`/`load_intervals` helpers from `gaussian.py`, avoiding an
+unused full-circuit compiler import. It changes no executed numerical function
+body. `Reference.for_cap` is not called by this adapter; its use would require
+the larger compiler dependency closure.
+
+For original source size S, excess K0, target period N=S+K0, and
+theta=K0/S, the source fixes
+
+    c_j=floor(theta*j+1/2), q_j=j+c_j, beta_j=theta*j-c_j.
+
+The narrow reference has identity holes and zero selected/hole cross entries.
+For a source halfwidth w0 with 2w0<S, it keeps the unique nearest-period source
+offset of size at most w0. Its physical target halfwidth is at most 2w0+2.
+The producer's shared-weight-ratio, cross-cell and cross-period branches are
+retained exactly. The diagonal is exactly one. A physical band W>=2w0+2
+therefore contains every nonzero entry of E=I-H. Our table loops over every
+canonical target row and every physical offset, calls that exact entry rule,
+checks the original row mass and truncates the resulting rational toward zero.
+Holes and genuine period crossings use the same rule as all other entries.
+
+The source's relative-weight construction avoids silently replacing tiny
+positive weights by zero. With entry precision b_e its weight precision is
+
+    P_weight=ceil(2 alpha^2/theta)+b_e+7,
+
+and its kernel precision adds O(alpha^2 w0). Under the retained caller's
+theta in [1/(4p^2),1/p^2], alpha^2=O(log p), b_e=O(p), and W<p, these are
+O(p^2 log p) offline heights. The source interval proof gives terminating
+Machin/Taylor loops at requested precision. The rational reference entries
+are generated before the present q-grid truncation; they are not redefined
+at each rectangle origin.
+
+Here is an intentionally loose fixed-tape production bound. Let B exceed
+all coefficient/parameter descriptor heights, requested interval precisions,
+W+1, q+1, and log2(N+1). Source coordinate arithmetic uses O(B)-bit integers.
+The two Machin arctangent loops have O(B) terms: their denominators contain
+5^(2j+1) or 239^(2j+1), and the requested tail is 2^-O(B). Their exact rational
+sums are then rounded to the requested B-bit dyadic interval. The positive
+Taylor loop for exp(-x) has O(B) terms on that dyadic grid; the source proof
+gives a stop by ceil(J/3) at working precision J. The source either takes its
+large-argument shortcut or performs at most O(B) range-reduction and squaring
+steps (the logarithmic bound would also suffice). These are explicit finite
+loop bounds, not an assumed polynomial-time exponential oracle.
+
+Even a product of all denominators in O(B) exact Machin terms has O(B^2) bits;
+reduction cannot increase that bound. Temporary products and row-mass sums
+also have O(B^2) bits, since W<=B. On H-bit integers, schoolbook operations
+and Euclidean reduction have a safe O(H^3) allowance. O(B) such steps therefore
+cost at most O(B^7); O(B^8) per source evaluation safely includes powers,
+encoded loop controls, conversion and the fixed number of source branches.
+The dyadic Taylor and squaring operations need smaller bounds. This justifies
+the deliberately loose polynomial used below without hiding rational heights.
+
+The original Python caches can be serialized and looked up by complete
+sequential scans. There are O(Ns) cached records, each of polynomial B size.
+Charging such a full scan at each of O(Ns) entry calls, rather than assuming
+a constant-time dictionary, yields the safe production bound
+
+    T_ref = O(N^2 s^2 B^10),    setup space O(Ns B^2),         (8)
+
+including scalar arithmetic, cache records, coefficient division/rounding,
+table writing, cache erasure and all returns. Several axes sum their versions
+of (8). This is a conservative implementation argument, not a fast setup
+benchmark. A producer that recomputes instead of caches also satisfies a
+fixed polynomial allowance. The finite source run executes the retained
+producer and records cache counts and actual rational heights; it does not
+claim that the host dictionary trace itself is the serialized simulation.
+
+The complete row-gap certificate and the analytic comparison between this H
+and the ideal Gaussian remain inherited from the cited source. Our setup
+checks the chosen rational gap on every actual reference row. If a caller
+also supplies ||H-H0||<=E0<delta, the standard resolvent identity adds
+
+    R E0 / [a delta(delta-E0)]
+
+for a normalized single-axis inverse. This is the already known reference
+perturbation bridge, not a new analytic proof. Each such error must still be
+included when adopting (5) in an outer caller.
+
+## 8. Complete substitution into the retained sparse budget
+
+This section is a conditional implementation substitution into #4100's
+archived route, not acceptance of that route or of a new multiplication
+theorem. Its exact parameters are in the pinned PROOF/GAUSSIAN/HALO files.
+The underlying direct row-gap specialization is already in #6880:
+
+    delta_i >= 1/(16p^2), W_i<p, J_i=16p^4,
+    b_i=(J_i-1)W_i<16p^5.
+
+Keep the existing conservative A=ceil(p^48) and
+L=2^ceil(400 log2 p); no new core geometry is needed. Require eventual
+checks L>4A, b_i<=A and N_i>=2L. Then every first-face expanded side has
+length at most L+2b_i<N_i. It satisfies the nonaliasing contract in Section 2,
+including physical wraps.
+
+Use a common q>=F_in, max_i u_i, where F_in is the actual incoming grid, and
+fund, for a desired local group allowance 2^-Cp,
+
+    q >= Cp + ceil(log2(4 h_axes max_i[(s_i R+2)/delta_i])).   (9)
+
+This makes sum_i nu_i<=2^-Cp/4. Since rho_i^J_i<=exp(-p^2), the tail term in
+(5) is also below 2^-Cp/4 eventually for fixed C and polynomial R. The chosen
+q is O(p) whenever F_in=O(p) and R is polynomial. No exact incoming bits are
+discarded: q is at least F_in. One may choose a_i between delta_i^-1 and
+2delta_i^-1, or use the caller's larger existing dyadic p^100 normalization.
+The same normalizer must be used by any core route with which these outputs
+are spliced. The total outer compensation is O(d log p)=o(p), and must be
+paid/restored by the existing caller; it is not canceled for free here.
+
+For completeness, implement the source's “balanced groups” explicitly. With
+d>=g>=2, put m=ceil(d/g) and split the d axes into m groups of sizes
+floor(d/m) or ceil(d/m). Every group has at most g axes and at least
+floor(g/2) axes. Thus there is no exceptional final one-axis remainder to
+which a growing-group amortization has been incorrectly applied.
+
+The source has ell=Theta(p^(1-epsilon)), axis periods at most 2^ell,
+d=Theta(p^epsilon), and g=Theta(p^beta), with beta>1-epsilon. A first-face
+rectangle has at least h_axes-1 long sides of length L-2A, so its volume C
+satisfies
+
+    log2 C >= (h_axes-1) log2(L-2A).
+
+Because h_axes=Omega(p^beta), the right side dominates
+ell + c log p for every fixed c. Therefore even a complete concatenated
+axis archive scan, of size 2^O(ell) poly(p), repeated once or twice per local
+axis, is eventually bounded by C. This proves absorption of the repeated
+scan term in (7). It is stronger than simply saying local setup is polynomial
+in p. For arbitrary fixed h_axes, or any failed finite comparison, retain
+the full h_axes G w^2 term. The effective comparison can be made with integer
+bit lengths before adopting the asymptotic branch.
+
+Offline production across all d axes costs
+d*2^O(ell)*poly(p)=2^o(p)=o(V), using (8), where V=T_total*p is the source's
+full bit volume. This is a different charge from repeated per-rectangle
+archive scans. Preparing each group's archive once as it is reached gives
+the same summed bound and uses a constant physical tape pool.
+
+In the actual balanced regime, all control/coordinate fields fit O(p) bits:
+h_axes log L=o(p), h_axes ell=o(p), and the source uses beta+1-epsilon<1.
+Numerical carriers have O(p) bits by (9). Thus w=O(p), J_i=O(p^4), s_i=O(p),
+and K=O(p). Equation (7) gives the deliberately conservative local bound
+
+    O(C h_axes p^7) bit work, plus the explicit offline setup. (10)
+
+There are O(h_axes A/L) copied records per original full-array record in a
+group. Summing (10) over all rectangles and O(d/g) balanced groups gives
+
+    O(V d g A p^6 / L)                                    (11)
+
+for this numerical consumer, with sparse layout, pages and arithmetic
+included. It is inside the older allowance O(V d g A^3/L polylog p).
+With A=p^48 and L>=p^400 its exponent is at most
+epsilon+beta+54-400<0. The dense gather/return scans remain the separate
+O(V d/g) row of the outer ledger; this package does not invoke a dense scan
+per numerical axis. The existing first-face copy producer and unique-return
+transaction must provide those operations. Formula (11) is not a new kappa
+claim; it establishes that this explicit consumer does not exhaust the
+already reserved conservative halo budget.
+
+## 9. Evidence, limits and remaining composition
+
+The verifier uses exact integers and Fractions for every acceptance decision.
+It checks 32 signed nonstationary cyclic-band lines, including identity holes,
+negative/positive coefficients and wrapping targets. Its independent dense
+polynomial evaluator forms successive powers and their sum. A second global
+rounded evaluator checks exact bit equality, while the written proof supplies
+the universal quantifiers.
+
+Two synthetic tensors execute the complete sparse tape schedule in two and
+three dimensions. A second history executes three differently shaped rectangles
+with the same eight roles and no new tape construction permitted. The actual source fixture is
+Reference(32,8,2,1,8,32), with period 40 and eight identity holes. All 1,600
+original entries are checked, including omitted entries and genuine wraps.
+Three local lines and a 756-record two-axis saved rectangle are executed;
+the latter returns exactly twelve target records. Its source-certified gap,
+numerical bound, tail bound, complete products/roundings, page scan count,
+radix count and summed retained extents are recorded in RESULT.json.
+
+These finite source parameters are legal for the retained Reference API but
+are not an execution of the eventual outer production regime. The all-size
+parameter substitution rests on Sections 7–8 and the explicitly retained
+source hypotheses, not on extrapolation from forty rows.
+
+Controls reject wrong normalization, insufficient source grid, ambiguous band
+offsets, missing row gap, oversized actual data, aliased page intervals,
+incorrect dependency crops and negative-zero records. Actual consumer code
+mutations exercise wrong recurrence sign, wrong neighbor rewind and omitted
+erasure, wrong sparse-axis exposure, stale axis pages and shifted return keys;
+a dropped actual periodic branch changes the returned source answer. The
+long-short-long history and counterfactual high-water tariff guard the
+physical reuse obligation that is invisible to a numerical-only comparison.
+Normal and optimized replay do not rely on Python assertions.
+
+Two additional checks were independently developed during adversarial review.
+Neither imports verify.py, the dense-power oracle, or its expected outputs.
+The first solves four rows of the original forty-by-forty H inverse by exact
+rational elimination of H^T. Every computed row satisfies its exact inverse
+equations. Tensoring these rows then gives an independent original-inverse
+answer at four two-axis targets, against which the physical consumer has
+maximum component-l1 error below 5.252e-9, within (5)'s 8.213e-8 allowance.
+Its nested target has identical returned bits, all eight tape roles are reused
+with constructors sealed, and the reference archive stays unchanged. A shifted
+target control has error greater than 0.109.
+
+The second executes every singleton output of one forty-row input, computes
+the original-reference residual r=x/a-Hy, and uses
+||H^-1||_infinity<=1/delta to certify ||y-H^-1 x/a||<=||r||/delta.
+This gives error below 7.667e-9 without using a polynomial oracle. For a
+cyclically shifted returned vector, ||r||/||H||_infinity gives an error lower
+bound greater than 0.543. Every acceptance decision is exact rational
+arithmetic. Both scripts run normally and with assertions disabled as
+registered checks; their decimal output is only a readable summary.
+The independent method and implementation provenance concern a separate AI
+reviewer in the same research effort, not external mathematical acceptance.
+
+No arbitrary native implementation, complete finite-core adoption, dense
+first-face copy/return protocol, broad Gaussian map, all-depth supplier,
+outer tensor/CRT algorithm or exact integer-recovery theorem is established
+here. The source H, its certified row gap and ideal-Gaussian comparison remain
+named dependencies. #5325 and #4415 already address other error-join/suffix
+questions; their results are not duplicated or silently assumed compatible
+with a different rounded reference. A complete join must verify that the
+core, this consumer, normalizers and the eventual outer recovery use the same
+source interface and actual grid/radius contracts. All five selected
+framework assumptions remain in force. No new kappa.
diff --git a/research/shrinking-reference-halo/README.md b/research/shrinking-reference-halo/README.md
new file mode 100644
index 0000000000..e9809decb1
--- /dev/null
+++ b/research/shrinking-reference-halo/README.md
@@ -0,0 +1,201 @@
+# Compute sparse Gaussian inverse halos from the original band
+
+**Scoped constructive result, with a written all-size proof and exact finite
+corroboration. No new κ.**
+
+This package replaces an unpriced global polynomial-row oracle with an
+explicit local numerical consumer. It evaluates the normalized inverse
+polynomial from the original rational reference band, shrinking the saved
+dependency interval after each step. The full local tensor program includes
+sparse axis exposure, absolute-coordinate coefficient pages, actual rounding,
+immutable fixed-source lines, physical head returns and cleanup.
+
+The contribution is the source-bound sequential interface and complete bill.
+The Neumann/Horner identities, the direct row-gap locality degree, and generic
+rounded core/halo composition were already available. The comparison below
+is part of the novelty boundary, not a claim of general literature priority.
+
+## Technical result
+
+For real cyclic band matrices `H_i=I-E_i` with row gap `delta_i>0`, bandwidth
+`W_i`, and a shared q grid, choose dyadic `a_i` with `a_i delta_i>=1`. The
+program uses `J_i` fixed-source updates and a saved halo of
+`b_i=(J_i-1)W_i`. It returns the target rectangle with error at most
+
+    sum_i [(2W_i+1)R+2] * 2^-q/delta_i
+      + R sum_i (1-delta_i)^J_i/(a_i delta_i).
+
+Every actual intermediate remains on the same grid and within the original
+component-l1 radius `R`. Each source line is preserved through its complete
+update sequence. The program never forms the dense polynomial coefficient
+rows, and it never assumes translation invariance of the reference entries.
+
+The numerical tensor uses eight reusable local tape roles and one protected
+concatenated reference archive. Each local page takes at most two **complete
+archive scans per rectangle/axis**, and is reused across all spectator lines.
+Sorting touches only the sparse saved rectangle. A live-body/blank-suffix
+invariant prevents repeated erasure of old large buffers from introducing an
+unfunded `L/A` factor on a later short face.
+
+For copied volume `C`, key width `K`, arithmetic/control width `w`, and
+archive coefficient count `G`, the complete generic bit bill is
+
+    T_reference + O(w^2 [h_axes G + C sum_i(J_i(2W_i+1)+K+1)]).
+
+The full archive term is explicit. In the exact balanced growing-group regime
+of the pinned #4100 route, a rectangle's many long sides absorb the repeated
+archive scans. The original source producer has separately charged
+`d*2^O(ell)*poly(p)=2^o(p)` setup. The resulting numerical consumer costs
+`O(V d g A p^6/L)`, inside the route's older conservative halo allowance.
+This substitution does not admit that archived outer proof or change the
+selected conditional frontier.
+
+The complete definitions, no-alias domain, fixed-role implementation,
+coefficient producer, scalar arithmetic and production substitution are in
+[PROOF.md](PROOF.md). Exact base and source hashes are in
+[SOURCES.json](SOURCES.json).
+
+## What was already proved
+
+| Source | Existing result | Present distinction |
+|---|---|---|
+| #1430 and #6490 | Stable fixed-source Horner evaluation and its oracle precision allocation | Original reference entries, local shrinking domains and sequential producer/consumer cost |
+| #5159 and #5216 | Complete rounded whole-period service on one rational Gaussian Reference | Sparse local tensor, variable certified gaps, fixed tape roles and production-group substitution |
+| #5260 and #5284 | Host-array direct solves and variable-gap cyclic-band precision | Different iterative mechanism; includes the sparse physical page/layout interface |
+| #3851 | Physical normalized principal-window compression core | Complements that core; does not reprove its Schur/q-convolution mechanism or use its different gap as this caller's gap |
+| #6880 | Direct row-gap polynomial, `J=16p^4`, inward-rounded polynomial rows and nonlinear core/halo composition | Eliminates the polynomial-row oracle using the original band and prices its production/access |
+| #4870 | First-face source-copy enumeration | Receives one completed saved rectangle; dense-source copy generation and final unique return remain outside this consumer |
+
+#5325's tensor error join, #4415's outer suffix accounting, and #4205/#4253's
+finite-core circuit theorem are not claimed as new work. A future integration
+must check their source/reference versions and actual grids before composing
+them with this consumer.
+
+## Exact evidence and reproduction
+
+From the repository root, with CPython 3.12 and the standard library:
+
+```sh
+python3 -I -B research/shrinking-reference-halo/verify.py
+```
+
+Expected marker: `PASS_SHRINKING_REFERENCE_HALO`, with 32 finite lines,
+40 Gaussian rows, 1,600 original source entries, 17 rejection controls,
+and `no_new_kappa: true`.
+
+The registered replay runs the author verifier and two separately developed
+mathematical checks, each in normal and optimized Python:
+
+```sh
+python3 -B scripts/research_package.py --package research/shrinking-reference-halo
+```
+
+[RESULT.json](RESULT.json) is generated by the verifier and required by normal
+read-only replay. It records:
+
+- Thirty-two signed, nonstationary cyclic-band lines and ninety-six returned
+  target coordinates, with exact dense-polynomial and full rounded-period
+  comparators.
+- Complete two- and three-axis synthetic tensor executions, followed by a
+  long/short/long rectangle history with all tape constructors disabled.
+- The actual retained `Reference(32,8,2,1,8,32)`, including every one of its
+  1,600 entries, all eight identity holes, and genuine across-period entries.
+- Three actual-reference lines and a two-axis, 756-record saved rectangle
+  returning twelve target records, with the complete product, rounding,
+  archive-scan, radix, head-action and retained-space counts.
+- Seventeen explicit rejection/code-mutation controls. Separate executed
+  comparisons detect dropping the actual periodic branch and the unfavorable
+  high-water-clearing tariff, even though the latter leaves numerical answers
+  unchanged.
+
+The matrix-power oracle forms successive exact powers and their sum; it does
+not import the numerical recurrence's implementation. The global rounded
+comparator additionally checks bit-for-bit locality.
+
+The separately developed [independent_inverse.py](independent_inverse.py)
+solves four rows of the **original rational inverse** by exact elimination,
+checks their exact matrix residuals, and uses those rows to evaluate the
+two-axis inverse independently of the polynomial recurrence. The physical
+consumer's four outputs have maximum error below `5.252e-9`, within the
+proved `8.213e-8` allowance. A second nested target returns identical bits,
+reuses the same eight roles with tape creation disabled, and preserves the
+archive. A wrong-target control produces error greater than `0.109`.
+
+[independent_residual.py](independent_residual.py) runs all forty physical
+singleton outputs and bounds their inverse error directly from the original
+matrix residual and its exact row gap. The certified error is below
+`7.667e-9`, while a cyclically misreturned output has error greater than
+`0.543`. Neither check imports the author verifier or its expected output.
+Their expected markers are `PASS_LEAD_EXACT_TENSOR_INVERSE` and
+`PASS_LEAD_ORIGINAL_REFERENCE_RESIDUAL`.
+
+These checks were developed by a separate AI reviewer within this contribution,
+using different mathematical mechanisms. All acceptance comparisons use
+exact rational arithmetic; displayed decimal summaries are diagnostic. The
+all-size claims rest on the written proof. No external human or formal-kernel
+acceptance is asserted.
+
+## Scope and limitations
+
+The source-bound forty-row example is a legal finite Reference fixture, not
+an execution of the asymptotic outer production parameters. Its all-input
+same-reference numerical error is funded below `2^-20` per axis, while the
+source's ideal-Gaussian perturbation and global gap proof remain inherited.
+The generic theorem explicitly requires zero outside the stated cyclic band;
+checking stored row mass alone does not prove support.
+
+Binary tape movement is executed. Scalar integer macros are exact in the
+reference and are priced by a written ordinary schoolbook arithmetic
+implementation. Source cache serialization and its conservative polynomial
+setup bound are proved, not claimed as a measured fast Python producer.
+Retained blank backing is included in space; Python allocator zeroization
+and byte-exact host heap accounting are not claimed.
+
+The saved rectangle must come from original values before any core mutation.
+This package consumes that saved copy and returns its target; it does not
+implement the full dense-source first-face gather or final dense unique-key
+merge. It supplies no new native supplier, core admission, complete broad
+Gaussian map, all-depth compiler, CRT join or exact integer multiplier. All
+five selected framework assumptions remain. **No new κ.**
+
+## Provenance and credit
+
+Scientific base: `7c49fe32c55de02c2c873655c804b16e4c3fef0a`.
+The selected conditional frontier at that base is
+`781451/250000000 = 0.003125804`; it is unchanged.
+
+The compatible, concurrently published #6880 proof was read at
+`e212af981b49c299de515f8c23dfb0e5b73e2e95`. This package is self-contained for
+its local theorem and has no executable dependency on that unmerged commit.
+The exact retained Gaussian implementation and source proof are pinned at
+the canonical base in SOURCES.json; no predecessor file is changed.
+
+Prepared for **@CubeJerry**, with substantial OpenAI Codex assistance in
+mathematics, source analysis, implementation, verification and prose. Credit
+Cinna Davis (#4100), Jose Manuel / jmbarrancoml (#3851, #4205/#4253),
+JoyboyBrian (#5159/#5216), Hanson Sun / bbMisk (#1430), Ali Romman
+(#5260/#5284), @codyw912 (#4870), Nick Petalas (#4217/#5986), and the inherited work of
+Vlado Vojdanovski, Jeremy Kothe, Mason Hale and Chafik Boukhalfa. Classical
+Neumann iteration, Horner evaluation, diagonal dominance, stable radix
+distribution and ordinary binary arithmetic retain their original credit.
+The source's Harvey–van der Hoeven, OpenAI manuscript and Douglas Colkitt
+lineage and Apache-2.0 notices are retained in the declared sources.
+
+## Open next questions
+
+The former first-face transaction join question is resolved within the
+explicit source/plan hypotheses by [the integrated reference
+transaction](../first-face-reference-join/README.md). Its source-bound
+streamed codec preserves the common grid and original values, canonicalizes
+only target returns, and proves the complete group bill. Actual-reference
+wrap/hole execution and independent unequal-halo full-grid checks are
+retained there. This does not admit the accelerated core or outer caller.
+
+1. **Use the same rounded reference at the actual finite core and outer
+   recovery.** The local result does not permit substituting a similarly named
+   Gaussian matrix. First pin the core's exact reference/normalizers and its
+   all-input error, then insert (5) in its existing recovery ledger. Source
+   compatibility and complete outer admission remain open.
+
+The quantified questions, overlap coverage and stopping rule are also retained
+in [TASK.json](TASK.json). No further optimization is reserved by this package.
diff --git a/research/shrinking-reference-halo/RESULT.json b/research/shrinking-reference-halo/RESULT.json
new file mode 100644
index 0000000000..2e546fe9ab
--- /dev/null
+++ b/research/shrinking-reference-halo/RESULT.json
@@ -0,0 +1,3662 @@
+{
+  "backing_reuse": {
+    "correct": [
+      {
+        "moves": 61264,
+        "output": [
+          [
+            -768,
+            -393
+          ],
+          [
+            -704,
+            -366
+          ],
+          [
+            -640,
+            -339
+          ],
+          [
+            -576,
+            -312
+          ],
+          [
+            -512,
+            -285
+          ],
+          [
+            -448,
+            -257
+          ],
+          [
+            -384,
+            -230
+          ],
+          [
+            -320,
+            -203
+          ],
+          [
+            -257,
+            -176
+          ],
+          [
+            -193,
+            -149
+          ],
+          [
+            -129,
+            -122
+          ],
+          [
+            -65,
+            -95
+          ],
+          [
+            -1,
+            -68
+          ],
+          [
+            62,
+            -41
+          ],
+          [
+            125,
+            -14
+          ],
+          [
+            189,
+            13
+          ],
+          [
+            253,
+            40
+          ],
+          [
+            317,
+            67
+          ],
+          [
+            381,
+            94
+          ],
+          [
+            445,
+            121
+          ],
+          [
+            509,
+            148
+          ],
+          [
+            572,
+            175
+          ],
+          [
+            636,
+            202
+          ],
+          [
+            700,
+            229
+          ],
+          [
+            764,
+            257
+          ],
+          [
+            764,
+            284
+          ],
+          [
+            572,
+            311
+          ],
+          [
+            -515,
+            338
+          ],
+          [
+            -707,
+            365
+          ],
+          [
+            -707,
+            392
+          ],
+          [
+            -643,
+            387
+          ],
+          [
+            -579,
+            287
+          ],
+          [
+            -516,
+            -261
+          ],
+          [
+            -452,
+            -362
+          ],
+          [
+            -388,
+            -367
+          ],
+          [
+            -324,
+            -340
+          ],
+          [
+            -260,
+            -313
+          ]
+        ],
+        "retained_bits": 5110,
+        "saved_length": 41,
+        "target_length": 37,
+        "writes": 12292
+      },
+      {
+        "moves": 12880,
+        "output": [
+          [
+            505,
+            12
+          ]
+        ],
+        "retained_bits": 5110,
+        "saved_length": 5,
+        "target_length": 1,
+        "writes": 1204
+      },
+      {
+        "moves": 69748,
+        "output": [
+          [
+            -8,
+            -341
+          ],
+          [
+            55,
+            -313
+          ],
+          [
+            118,
+            -286
+          ],
+          [
+            182,
+            -259
+          ],
+          [
+            246,
+            -232
+          ],
+          [
+            310,
+            -205
+          ],
+          [
+            374,
+            -178
+          ],
+          [
+            438,
+            -151
+          ],
+          [
+            502,
+            -124
+          ],
+          [
+            565,
+            -96
+          ],
+          [
+            629,
+            -69
+          ],
+          [
+            693,
+            -42
+          ],
+          [
+            757,
+            -15
+          ],
+          [
+            757,
+            11
+          ],
+          [
+            565,
+            38
+          ],
+          [
+            -522,
+            65
+          ],
+          [
+            -714,
+            92
+          ],
+          [
+            -714,
+            119
+          ],
+          [
+            -650,
+            146
+          ],
+          [
+            -586,
+            173
+          ],
+          [
+            -523,
+            201
+          ],
+          [
+            -459,
+            228
+          ],
+          [
+            -395,
+            255
+          ],
+          [
+            -331,
+            282
+          ],
+          [
+            -267,
+            309
+          ],
+          [
+            -203,
+            336
+          ],
+          [
+            -139,
+            363
+          ],
+          [
+            -75,
+            390
+          ],
+          [
+            -12,
+            386
+          ],
+          [
+            13,
+            283
+          ],
+          [
+            -76,
+            -272
+          ],
+          [
+            -703,
+            -406
+          ],
+          [
+            -793,
+            -418
+          ],
+          [
+            -768,
+            -393
+          ],
+          [
+            -704,
+            -366
+          ],
+          [
+            -640,
+            -339
+          ],
+          [
+            -576,
+            -312
+          ]
+        ],
+        "retained_bits": 5110,
+        "saved_length": 41,
+        "target_length": 37,
+        "writes": 12292
+      }
+    ],
+    "counterfactual": [
+      {
+        "moves": 61488,
+        "output": [
+          [
+            -768,
+            -393
+          ],
+          [
+            -704,
+            -366
+          ],
+          [
+            -640,
+            -339
+          ],
+          [
+            -576,
+            -312
+          ],
+          [
+            -512,
+            -285
+          ],
+          [
+            -448,
+            -257
+          ],
+          [
+            -384,
+            -230
+          ],
+          [
+            -320,
+            -203
+          ],
+          [
+            -257,
+            -176
+          ],
+          [
+            -193,
+            -149
+          ],
+          [
+            -129,
+            -122
+          ],
+          [
+            -65,
+            -95
+          ],
+          [
+            -1,
+            -68
+          ],
+          [
+            62,
+            -41
+          ],
+          [
+            125,
+            -14
+          ],
+          [
+            189,
+            13
+          ],
+          [
+            253,
+            40
+          ],
+          [
+            317,
+            67
+          ],
+          [
+            381,
+            94
+          ],
+          [
+            445,
+            121
+          ],
+          [
+            509,
+            148
+          ],
+          [
+            572,
+            175
+          ],
+          [
+            636,
+            202
+          ],
+          [
+            700,
+            229
+          ],
+          [
+            764,
+            257
+          ],
+          [
+            764,
+            284
+          ],
+          [
+            572,
+            311
+          ],
+          [
+            -515,
+            338
+          ],
+          [
+            -707,
+            365
+          ],
+          [
+            -707,
+            392
+          ],
+          [
+            -643,
+            387
+          ],
+          [
+            -579,
+            287
+          ],
+          [
+            -516,
+            -261
+          ],
+          [
+            -452,
+            -362
+          ],
+          [
+            -388,
+            -367
+          ],
+          [
+            -324,
+            -340
+          ],
+          [
+            -260,
+            -313
+          ]
+        ],
+        "retained_bits": 5110,
+        "saved_length": 41,
+        "target_length": 37,
+        "writes": 12404
+      },
+      {
+        "moves": 24192,
+        "output": [
+          [
+            505,
+            12
+          ]
+        ],
+        "retained_bits": 5110,
+        "saved_length": 5,
+        "target_length": 1,
+        "writes": 6860
+      },
+      {
+        "moves": 69972,
+        "output": [
+          [
+            -8,
+            -341
+          ],
+          [
+            55,
+            -313
+          ],
+          [
+            118,
+            -286
+          ],
+          [
+            182,
+            -259
+          ],
+          [
+            246,
+            -232
+          ],
+          [
+            310,
+            -205
+          ],
+          [
+            374,
+            -178
+          ],
+          [
+            438,
+            -151
+          ],
+          [
+            502,
+            -124
+          ],
+          [
+            565,
+            -96
+          ],
+          [
+            629,
+            -69
+          ],
+          [
+            693,
+            -42
+          ],
+          [
+            757,
+            -15
+          ],
+          [
+            757,
+            11
+          ],
+          [
+            565,
+            38
+          ],
+          [
+            -522,
+            65
+          ],
+          [
+            -714,
+            92
+          ],
+          [
+            -714,
+            119
+          ],
+          [
+            -650,
+            146
+          ],
+          [
+            -586,
+            173
+          ],
+          [
+            -523,
+            201
+          ],
+          [
+            -459,
+            228
+          ],
+          [
+            -395,
+            255
+          ],
+          [
+            -331,
+            282
+          ],
+          [
+            -267,
+            309
+          ],
+          [
+            -203,
+            336
+          ],
+          [
+            -139,
+            363
+          ],
+          [
+            -75,
+            390
+          ],
+          [
+            -12,
+            386
+          ],
+          [
+            13,
+            283
+          ],
+          [
+            -76,
+            -272
+          ],
+          [
+            -703,
+            -406
+          ],
+          [
+            -793,
+            -418
+          ],
+          [
+            -768,
+            -393
+          ],
+          [
+            -704,
+            -366
+          ],
+          [
+            -640,
+            -339
+          ],
+          [
+            -576,
+            -312
+          ]
+        ],
+        "retained_bits": 5110,
+        "saved_length": 41,
+        "target_length": 37,
+        "writes": 12404
+      }
+    ],
+    "counterfactual_detected": true,
+    "retained_extent_ratio": "41/5"
+  },
+  "claim": "scoped written proof and finite tape corroboration",
+  "control_count": 17,
+  "controls": [
+    "unfunded normalization",
+    "lost normalized-source precision",
+    "nonunique cyclic offsets",
+    "missing contraction gap",
+    "bad original row gap",
+    "oversized actual input",
+    "repeated canonical page coordinate",
+    "immutable coefficient page",
+    "immutable fixed source",
+    "prematurely cropped dependency interval",
+    "noncanonical negative zero",
+    "wrong recurrence sign",
+    "wrong neighbor rewind",
+    "missing scratch erasure",
+    "wrong sparse axis exposure",
+    "stale axis coefficient page",
+    "shifted returned tensor key"
+  ],
+  "finite": [
+    {
+      "bill": {
+        "additions": 0,
+        "control_steps": 183,
+        "maximum_single_tape_extent": 495,
+        "moves": 3828,
+        "page_scans": 2,
+        "peak_scalar_bits": 10,
+        "products": 0,
+        "reads": 1122,
+        "roundings": 6,
+        "setup_divisions": 45,
+        "setup_entries": 45,
+        "source_shifts": 6,
+        "writes": 792
+      },
+      "bits": 9,
+      "gap": "1/8",
+      "length": 3,
+      "lower": -2,
+      "nonzero_error": true,
+      "output": [
+        [
+          -43,
+          -1
+        ],
+        [
+          15,
+          40
+        ],
+        [
+          43,
+          -17
+        ]
+      ],
+      "period": 15,
+      "resident_extents": [
+        66,
+        99,
+        66,
+        0
+      ],
+      "terms": 1,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 30,
+        "control_steps": 385,
+        "maximum_single_tape_extent": 1200,
+        "moves": 11376,
+        "page_scans": 2,
+        "peak_scalar_bits": 19,
+        "products": 30,
+        "reads": 3252,
+        "roundings": 20,
+        "setup_divisions": 100,
+        "setup_entries": 100,
+        "source_shifts": 20,
+        "writes": 2268
+      },
+      "bits": 10,
+      "gap": "1/4",
+      "length": 3,
+      "lower": 17,
+      "nonzero_error": true,
+      "output": [
+        [
+          -85,
+          93
+        ],
+        [
+          -139,
+          145
+        ],
+        [
+          166,
+          -5
+        ]
+      ],
+      "period": 20,
+      "resident_extents": [
+        168,
+        420,
+        72,
+        168
+      ],
+      "terms": 2,
+      "width": 2
+    },
+    {
+      "bill": {
+        "additions": 48,
+        "control_steps": 207,
+        "maximum_single_tape_extent": 819,
+        "moves": 8944,
+        "page_scans": 1,
+        "peak_scalar_bits": 22,
+        "products": 48,
+        "reads": 2223,
+        "roundings": 30,
+        "setup_divisions": 63,
+        "setup_entries": 63,
+        "source_shifts": 30,
+        "writes": 2054
+      },
+      "bits": 11,
+      "gap": "3/8",
+      "length": 3,
+      "lower": 9,
+      "nonzero_error": true,
+      "output": [
+        [
+          115,
+          -111
+        ],
+        [
+          300,
+          200
+        ],
+        [
+          337,
+          193
+        ]
+      ],
+      "period": 21,
+      "resident_extents": [
+        182,
+        273,
+        182,
+        130
+      ],
+      "terms": 3,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 210,
+        "control_steps": 681,
+        "maximum_single_tape_extent": 2100,
+        "moves": 32928,
+        "page_scans": 2,
+        "peak_scalar_bits": 23,
+        "products": 210,
+        "reads": 9702,
+        "roundings": 72,
+        "setup_divisions": 150,
+        "setup_entries": 150,
+        "source_shifts": 72,
+        "writes": 5586
+      },
+      "bits": 12,
+      "gap": "1/8",
+      "length": 3,
+      "lower": 1,
+      "nonzero_error": true,
+      "output": [
+        [
+          230,
+          6
+        ],
+        [
+          486,
+          -58
+        ],
+        [
+          -385,
+          -17
+        ]
+      ],
+      "period": 30,
+      "resident_extents": [
+        420,
+        1050,
+        308,
+        420
+      ],
+      "terms": 4,
+      "width": 2
+    },
+    {
+      "bill": {
+        "additions": 0,
+        "control_steps": 231,
+        "maximum_single_tape_extent": 627,
+        "moves": 4620,
+        "page_scans": 2,
+        "peak_scalar_bits": 10,
+        "products": 0,
+        "reads": 1386,
+        "roundings": 6,
+        "setup_divisions": 57,
+        "setup_entries": 57,
+        "source_shifts": 6,
+        "writes": 924
+      },
+      "bits": 9,
+      "gap": "1/4",
+      "length": 3,
+      "lower": -2,
+      "nonzero_error": true,
+      "output": [
+        [
+          -40,
+          -63
+        ],
+        [
+          -90,
+          -31
+        ],
+        [
+          1,
+          122
+        ]
+      ],
+      "period": 19,
+      "resident_extents": [
+        66,
+        99,
+        66,
+        0
+      ],
+      "terms": 1,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 30,
+        "control_steps": 367,
+        "maximum_single_tape_extent": 1140,
+        "moves": 11016,
+        "page_scans": 2,
+        "peak_scalar_bits": 19,
+        "products": 30,
+        "reads": 3132,
+        "roundings": 20,
+        "setup_divisions": 95,
+        "setup_entries": 95,
+        "source_shifts": 20,
+        "writes": 2208
+      },
+      "bits": 10,
+      "gap": "3/8",
+      "length": 3,
+      "lower": 16,
+      "nonzero_error": true,
+      "output": [
+        [
+          129,
+          -2
+        ],
+        [
+          -211,
+          51
+        ],
+        [
+          -206,
+          13
+        ]
+      ],
+      "period": 19,
+      "resident_extents": [
+        168,
+        420,
+        72,
+        168
+      ],
+      "terms": 2,
+      "width": 2
+    },
+    {
+      "bill": {
+        "additions": 48,
+        "control_steps": 199,
+        "maximum_single_tape_extent": 780,
+        "moves": 8788,
+        "page_scans": 1,
+        "peak_scalar_bits": 21,
+        "products": 48,
+        "reads": 2184,
+        "roundings": 30,
+        "setup_divisions": 60,
+        "setup_entries": 60,
+        "source_shifts": 30,
+        "writes": 2015
+      },
+      "bits": 11,
+      "gap": "1/8",
+      "length": 3,
+      "lower": 9,
+      "nonzero_error": true,
+      "output": [
+        [
+          -208,
+          165
+        ],
+        [
+          194,
+          -23
+        ],
+        [
+          327,
+          -150
+        ]
+      ],
+      "period": 20,
+      "resident_extents": [
+        182,
+        273,
+        182,
+        130
+      ],
+      "terms": 3,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 210,
+        "control_steps": 663,
+        "maximum_single_tape_extent": 2030,
+        "moves": 32508,
+        "page_scans": 2,
+        "peak_scalar_bits": 23,
+        "products": 210,
+        "reads": 9562,
+        "roundings": 72,
+        "setup_divisions": 145,
+        "setup_entries": 145,
+        "source_shifts": 72,
+        "writes": 5516
+      },
+      "bits": 12,
+      "gap": "1/4",
+      "length": 3,
+      "lower": 1,
+      "nonzero_error": true,
+      "output": [
+        [
+          -452,
+          -551
+        ],
+        [
+          471,
+          -200
+        ],
+        [
+          -718,
+          -37
+        ]
+      ],
+      "period": 29,
+      "resident_extents": [
+        420,
+        1050,
+        308,
+        420
+      ],
+      "terms": 4,
+      "width": 2
+    },
+    {
+      "bill": {
+        "additions": 0,
+        "control_steps": 219,
+        "maximum_single_tape_extent": 594,
+        "moves": 4422,
+        "page_scans": 2,
+        "peak_scalar_bits": 10,
+        "products": 0,
+        "reads": 1320,
+        "roundings": 6,
+        "setup_divisions": 54,
+        "setup_entries": 54,
+        "source_shifts": 6,
+        "writes": 891
+      },
+      "bits": 9,
+      "gap": "3/8",
+      "length": 3,
+      "lower": -2,
+      "nonzero_error": true,
+      "output": [
+        [
+          3,
+          24
+        ],
+        [
+          22,
+          -46
+        ],
+        [
+          1,
+          118
+        ]
+      ],
+      "period": 18,
+      "resident_extents": [
+        66,
+        99,
+        66,
+        0
+      ],
+      "terms": 1,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 30,
+        "control_steps": 439,
+        "maximum_single_tape_extent": 1380,
+        "moves": 12456,
+        "page_scans": 2,
+        "peak_scalar_bits": 17,
+        "products": 30,
+        "reads": 3612,
+        "roundings": 20,
+        "setup_divisions": 115,
+        "setup_entries": 115,
+        "source_shifts": 20,
+        "writes": 2448
+      },
+      "bits": 10,
+      "gap": "1/8",
+      "length": 3,
+      "lower": 20,
+      "nonzero_error": true,
+      "output": [
+        [
+          22,
+          5
+        ],
+        [
+          1,
+          43
+        ],
+        [
+          -11,
+          -2
+        ]
+      ],
+      "period": 23,
+      "resident_extents": [
+        168,
+        420,
+        72,
+        168
+      ],
+      "terms": 2,
+      "width": 2
+    },
+    {
+      "bill": {
+        "additions": 48,
+        "control_steps": 191,
+        "maximum_single_tape_extent": 741,
+        "moves": 8632,
+        "page_scans": 1,
+        "peak_scalar_bits": 22,
+        "products": 48,
+        "reads": 2145,
+        "roundings": 30,
+        "setup_divisions": 57,
+        "setup_entries": 57,
+        "source_shifts": 30,
+        "writes": 1976
+      },
+      "bits": 11,
+      "gap": "1/4",
+      "length": 3,
+      "lower": 8,
+      "nonzero_error": true,
+      "output": [
+        [
+          -448,
+          -86
+        ],
+        [
+          55,
+          179
+        ],
+        [
+          673,
+          -56
+        ]
+      ],
+      "period": 19,
+      "resident_extents": [
+        182,
+        273,
+        182,
+        130
+      ],
+      "terms": 3,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 210,
+        "control_steps": 645,
+        "maximum_single_tape_extent": 1960,
+        "moves": 32088,
+        "page_scans": 2,
+        "peak_scalar_bits": 24,
+        "products": 210,
+        "reads": 9422,
+        "roundings": 72,
+        "setup_divisions": 140,
+        "setup_entries": 140,
+        "source_shifts": 72,
+        "writes": 5446
+      },
+      "bits": 12,
+      "gap": "3/8",
+      "length": 3,
+      "lower": 1,
+      "nonzero_error": true,
+      "output": [
+        [
+          675,
+          430
+        ],
+        [
+          -876,
+          67
+        ],
+        [
+          205,
+          399
+        ]
+      ],
+      "period": 28,
+      "resident_extents": [
+        420,
+        1050,
+        308,
+        420
+      ],
+      "terms": 4,
+      "width": 2
+    },
+    {
+      "bill": {
+        "additions": 0,
+        "control_steps": 207,
+        "maximum_single_tape_extent": 561,
+        "moves": 4224,
+        "page_scans": 2,
+        "peak_scalar_bits": 10,
+        "products": 0,
+        "reads": 1254,
+        "roundings": 6,
+        "setup_divisions": 51,
+        "setup_entries": 51,
+        "source_shifts": 6,
+        "writes": 858
+      },
+      "bits": 9,
+      "gap": "1/8",
+      "length": 3,
+      "lower": -2,
+      "nonzero_error": true,
+      "output": [
+        [
+          53,
+          5
+        ],
+        [
+          56,
+          5
+        ],
+        [
+          48,
+          -1
+        ]
+      ],
+      "period": 17,
+      "resident_extents": [
+        66,
+        99,
+        66,
+        0
+      ],
+      "terms": 1,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 30,
+        "control_steps": 421,
+        "maximum_single_tape_extent": 1320,
+        "moves": 12096,
+        "page_scans": 2,
+        "peak_scalar_bits": 20,
+        "products": 30,
+        "reads": 3492,
+        "roundings": 20,
+        "setup_divisions": 110,
+        "setup_entries": 110,
+        "source_shifts": 20,
+        "writes": 2388
+      },
+      "bits": 10,
+      "gap": "1/4",
+      "length": 3,
+      "lower": 19,
+      "nonzero_error": true,
+      "output": [
+        [
+          33,
+          288
+        ],
+        [
+          -111,
+          57
+        ],
+        [
+          -143,
+          -92
+        ]
+      ],
+      "period": 22,
+      "resident_extents": [
+        168,
+        420,
+        72,
+        168
+      ],
+      "terms": 2,
+      "width": 2
+    },
+    {
+      "bill": {
+        "additions": 48,
+        "control_steps": 223,
+        "maximum_single_tape_extent": 897,
+        "moves": 9256,
+        "page_scans": 1,
+        "peak_scalar_bits": 22,
+        "products": 48,
+        "reads": 2301,
+        "roundings": 30,
+        "setup_divisions": 69,
+        "setup_entries": 69,
+        "source_shifts": 30,
+        "writes": 2132
+      },
+      "bits": 11,
+      "gap": "3/8",
+      "length": 3,
+      "lower": 10,
+      "nonzero_error": true,
+      "output": [
+        [
+          -309,
+          183
+        ],
+        [
+          54,
+          277
+        ],
+        [
+          570,
+          -127
+        ]
+      ],
+      "period": 23,
+      "resident_extents": [
+        182,
+        273,
+        182,
+        130
+      ],
+      "terms": 3,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 210,
+        "control_steps": 627,
+        "maximum_single_tape_extent": 1890,
+        "moves": 31668,
+        "page_scans": 2,
+        "peak_scalar_bits": 23,
+        "products": 210,
+        "reads": 9282,
+        "roundings": 72,
+        "setup_divisions": 135,
+        "setup_entries": 135,
+        "source_shifts": 72,
+        "writes": 5376
+      },
+      "bits": 12,
+      "gap": "1/8",
+      "length": 3,
+      "lower": 1,
+      "nonzero_error": true,
+      "output": [
+        [
+          -641,
+          -19
+        ],
+        [
+          564,
+          128
+        ],
+        [
+          110,
+          23
+        ]
+      ],
+      "period": 27,
+      "resident_extents": [
+        420,
+        1050,
+        308,
+        420
+      ],
+      "terms": 4,
+      "width": 2
+    },
+    {
+      "bill": {
+        "additions": 0,
+        "control_steps": 195,
+        "maximum_single_tape_extent": 528,
+        "moves": 4026,
+        "page_scans": 2,
+        "peak_scalar_bits": 10,
+        "products": 0,
+        "reads": 1188,
+        "roundings": 6,
+        "setup_divisions": 48,
+        "setup_entries": 48,
+        "source_shifts": 6,
+        "writes": 825
+      },
+      "bits": 9,
+      "gap": "1/4",
+      "length": 3,
+      "lower": -2,
+      "nonzero_error": true,
+      "output": [
+        [
+          -29,
+          39
+        ],
+        [
+          52,
+          56
+        ],
+        [
+          -86,
+          7
+        ]
+      ],
+      "period": 16,
+      "resident_extents": [
+        66,
+        99,
+        66,
+        0
+      ],
+      "terms": 1,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 30,
+        "control_steps": 403,
+        "maximum_single_tape_extent": 1260,
+        "moves": 11736,
+        "page_scans": 2,
+        "peak_scalar_bits": 19,
+        "products": 30,
+        "reads": 3372,
+        "roundings": 20,
+        "setup_divisions": 105,
+        "setup_entries": 105,
+        "source_shifts": 20,
+        "writes": 2328
+      },
+      "bits": 10,
+      "gap": "3/8",
+      "length": 3,
+      "lower": 18,
+      "nonzero_error": true,
+      "output": [
+        [
+          -66,
+          -131
+        ],
+        [
+          185,
+          83
+        ],
+        [
+          -52,
+          69
+        ]
+      ],
+      "period": 21,
+      "resident_extents": [
+        168,
+        420,
+        72,
+        168
+      ],
+      "terms": 2,
+      "width": 2
+    },
+    {
+      "bill": {
+        "additions": 48,
+        "control_steps": 215,
+        "maximum_single_tape_extent": 858,
+        "moves": 9100,
+        "page_scans": 1,
+        "peak_scalar_bits": 20,
+        "products": 48,
+        "reads": 2262,
+        "roundings": 30,
+        "setup_divisions": 66,
+        "setup_entries": 66,
+        "source_shifts": 30,
+        "writes": 2093
+      },
+      "bits": 11,
+      "gap": "1/8",
+      "length": 3,
+      "lower": 10,
+      "nonzero_error": true,
+      "output": [
+        [
+          -84,
+          0
+        ],
+        [
+          -198,
+          -14
+        ],
+        [
+          104,
+          -128
+        ]
+      ],
+      "period": 22,
+      "resident_extents": [
+        182,
+        273,
+        182,
+        130
+      ],
+      "terms": 3,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 210,
+        "control_steps": 699,
+        "maximum_single_tape_extent": 2170,
+        "moves": 33348,
+        "page_scans": 2,
+        "peak_scalar_bits": 24,
+        "products": 210,
+        "reads": 9842,
+        "roundings": 72,
+        "setup_divisions": 155,
+        "setup_entries": 155,
+        "source_shifts": 72,
+        "writes": 5656
+      },
+      "bits": 12,
+      "gap": "1/4",
+      "length": 3,
+      "lower": 1,
+      "nonzero_error": true,
+      "output": [
+        [
+          -384,
+          105
+        ],
+        [
+          223,
+          -620
+        ],
+        [
+          486,
+          31
+        ]
+      ],
+      "period": 31,
+      "resident_extents": [
+        420,
+        1050,
+        308,
+        420
+      ],
+      "terms": 4,
+      "width": 2
+    },
+    {
+      "bill": {
+        "additions": 0,
+        "control_steps": 183,
+        "maximum_single_tape_extent": 495,
+        "moves": 3828,
+        "page_scans": 2,
+        "peak_scalar_bits": 10,
+        "products": 0,
+        "reads": 1122,
+        "roundings": 6,
+        "setup_divisions": 45,
+        "setup_entries": 45,
+        "source_shifts": 6,
+        "writes": 792
+      },
+      "bits": 9,
+      "gap": "3/8",
+      "length": 3,
+      "lower": -2,
+      "nonzero_error": true,
+      "output": [
+        [
+          119,
+          0
+        ],
+        [
+          79,
+          36
+        ],
+        [
+          -27,
+          58
+        ]
+      ],
+      "period": 15,
+      "resident_extents": [
+        66,
+        99,
+        66,
+        0
+      ],
+      "terms": 1,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 30,
+        "control_steps": 385,
+        "maximum_single_tape_extent": 1200,
+        "moves": 11376,
+        "page_scans": 2,
+        "peak_scalar_bits": 18,
+        "products": 30,
+        "reads": 3252,
+        "roundings": 20,
+        "setup_divisions": 100,
+        "setup_entries": 100,
+        "source_shifts": 20,
+        "writes": 2268
+      },
+      "bits": 10,
+      "gap": "1/8",
+      "length": 3,
+      "lower": 17,
+      "nonzero_error": true,
+      "output": [
+        [
+          -21,
+          42
+        ],
+        [
+          -69,
+          54
+        ],
+        [
+          -39,
+          -23
+        ]
+      ],
+      "period": 20,
+      "resident_extents": [
+        168,
+        420,
+        72,
+        168
+      ],
+      "terms": 2,
+      "width": 2
+    },
+    {
+      "bill": {
+        "additions": 48,
+        "control_steps": 207,
+        "maximum_single_tape_extent": 819,
+        "moves": 8944,
+        "page_scans": 1,
+        "peak_scalar_bits": 22,
+        "products": 48,
+        "reads": 2223,
+        "roundings": 30,
+        "setup_divisions": 63,
+        "setup_entries": 63,
+        "source_shifts": 30,
+        "writes": 2054
+      },
+      "bits": 11,
+      "gap": "1/4",
+      "length": 3,
+      "lower": 9,
+      "nonzero_error": true,
+      "output": [
+        [
+          297,
+          -225
+        ],
+        [
+          -171,
+          132
+        ],
+        [
+          -13,
+          -46
+        ]
+      ],
+      "period": 21,
+      "resident_extents": [
+        182,
+        273,
+        182,
+        130
+      ],
+      "terms": 3,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 210,
+        "control_steps": 681,
+        "maximum_single_tape_extent": 2100,
+        "moves": 32928,
+        "page_scans": 2,
+        "peak_scalar_bits": 24,
+        "products": 210,
+        "reads": 9702,
+        "roundings": 72,
+        "setup_divisions": 150,
+        "setup_entries": 150,
+        "source_shifts": 72,
+        "writes": 5586
+      },
+      "bits": 12,
+      "gap": "3/8",
+      "length": 3,
+      "lower": 1,
+      "nonzero_error": true,
+      "output": [
+        [
+          206,
+          445
+        ],
+        [
+          419,
+          -532
+        ],
+        [
+          300,
+          -519
+        ]
+      ],
+      "period": 30,
+      "resident_extents": [
+        420,
+        1050,
+        308,
+        420
+      ],
+      "terms": 4,
+      "width": 2
+    },
+    {
+      "bill": {
+        "additions": 0,
+        "control_steps": 231,
+        "maximum_single_tape_extent": 627,
+        "moves": 4620,
+        "page_scans": 2,
+        "peak_scalar_bits": 10,
+        "products": 0,
+        "reads": 1386,
+        "roundings": 6,
+        "setup_divisions": 57,
+        "setup_entries": 57,
+        "source_shifts": 6,
+        "writes": 924
+      },
+      "bits": 9,
+      "gap": "1/8",
+      "length": 3,
+      "lower": -2,
+      "nonzero_error": true,
+      "output": [
+        [
+          -60,
+          -1
+        ],
+        [
+          -63,
+          0
+        ],
+        [
+          48,
+          8
+        ]
+      ],
+      "period": 19,
+      "resident_extents": [
+        66,
+        99,
+        66,
+        0
+      ],
+      "terms": 1,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 30,
+        "control_steps": 367,
+        "maximum_single_tape_extent": 1140,
+        "moves": 11016,
+        "page_scans": 2,
+        "peak_scalar_bits": 20,
+        "products": 30,
+        "reads": 3132,
+        "roundings": 20,
+        "setup_divisions": 95,
+        "setup_entries": 95,
+        "source_shifts": 20,
+        "writes": 2208
+      },
+      "bits": 10,
+      "gap": "1/4",
+      "length": 3,
+      "lower": 16,
+      "nonzero_error": true,
+      "output": [
+        [
+          225,
+          22
+        ],
+        [
+          184,
+          15
+        ],
+        [
+          198,
+          11
+        ]
+      ],
+      "period": 19,
+      "resident_extents": [
+        168,
+        420,
+        72,
+        168
+      ],
+      "terms": 2,
+      "width": 2
+    },
+    {
+      "bill": {
+        "additions": 48,
+        "control_steps": 199,
+        "maximum_single_tape_extent": 780,
+        "moves": 8788,
+        "page_scans": 1,
+        "peak_scalar_bits": 22,
+        "products": 48,
+        "reads": 2184,
+        "roundings": 30,
+        "setup_divisions": 60,
+        "setup_entries": 60,
+        "source_shifts": 30,
+        "writes": 2015
+      },
+      "bits": 11,
+      "gap": "3/8",
+      "length": 3,
+      "lower": 9,
+      "nonzero_error": true,
+      "output": [
+        [
+          383,
+          172
+        ],
+        [
+          20,
+          -235
+        ],
+        [
+          323,
+          -222
+        ]
+      ],
+      "period": 20,
+      "resident_extents": [
+        182,
+        273,
+        182,
+        130
+      ],
+      "terms": 3,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 210,
+        "control_steps": 663,
+        "maximum_single_tape_extent": 2030,
+        "moves": 32508,
+        "page_scans": 2,
+        "peak_scalar_bits": 23,
+        "products": 210,
+        "reads": 9562,
+        "roundings": 72,
+        "setup_divisions": 145,
+        "setup_entries": 145,
+        "source_shifts": 72,
+        "writes": 5516
+      },
+      "bits": 12,
+      "gap": "1/8",
+      "length": 3,
+      "lower": 1,
+      "nonzero_error": true,
+      "output": [
+        [
+          488,
+          4
+        ],
+        [
+          462,
+          -41
+        ],
+        [
+          -136,
+          106
+        ]
+      ],
+      "period": 29,
+      "resident_extents": [
+        420,
+        1050,
+        308,
+        420
+      ],
+      "terms": 4,
+      "width": 2
+    },
+    {
+      "bill": {
+        "additions": 0,
+        "control_steps": 219,
+        "maximum_single_tape_extent": 594,
+        "moves": 4422,
+        "page_scans": 2,
+        "peak_scalar_bits": 10,
+        "products": 0,
+        "reads": 1320,
+        "roundings": 6,
+        "setup_divisions": 54,
+        "setup_entries": 54,
+        "source_shifts": 6,
+        "writes": 891
+      },
+      "bits": 9,
+      "gap": "1/4",
+      "length": 3,
+      "lower": -2,
+      "nonzero_error": true,
+      "output": [
+        [
+          -25,
+          -98
+        ],
+        [
+          -38,
+          37
+        ],
+        [
+          42,
+          54
+        ]
+      ],
+      "period": 18,
+      "resident_extents": [
+        66,
+        99,
+        66,
+        0
+      ],
+      "terms": 1,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 30,
+        "control_steps": 439,
+        "maximum_single_tape_extent": 1380,
+        "moves": 12456,
+        "page_scans": 2,
+        "peak_scalar_bits": 19,
+        "products": 30,
+        "reads": 3612,
+        "roundings": 20,
+        "setup_divisions": 115,
+        "setup_entries": 115,
+        "source_shifts": 20,
+        "writes": 2448
+      },
+      "bits": 10,
+      "gap": "3/8",
+      "length": 3,
+      "lower": 20,
+      "nonzero_error": true,
+      "output": [
+        [
+          -200,
+          -33
+        ],
+        [
+          -39,
+          138
+        ],
+        [
+          -165,
+          -32
+        ]
+      ],
+      "period": 23,
+      "resident_extents": [
+        168,
+        420,
+        72,
+        168
+      ],
+      "terms": 2,
+      "width": 2
+    },
+    {
+      "bill": {
+        "additions": 48,
+        "control_steps": 191,
+        "maximum_single_tape_extent": 741,
+        "moves": 8632,
+        "page_scans": 1,
+        "peak_scalar_bits": 21,
+        "products": 48,
+        "reads": 2145,
+        "roundings": 30,
+        "setup_divisions": 57,
+        "setup_entries": 57,
+        "source_shifts": 30,
+        "writes": 1976
+      },
+      "bits": 11,
+      "gap": "1/8",
+      "length": 3,
+      "lower": 8,
+      "nonzero_error": true,
+      "output": [
+        [
+          -38,
+          -416
+        ],
+        [
+          -142,
+          -20
+        ],
+        [
+          300,
+          45
+        ]
+      ],
+      "period": 19,
+      "resident_extents": [
+        182,
+        273,
+        182,
+        130
+      ],
+      "terms": 3,
+      "width": 1
+    },
+    {
+      "bill": {
+        "additions": 210,
+        "control_steps": 645,
+        "maximum_single_tape_extent": 1960,
+        "moves": 32088,
+        "page_scans": 2,
+        "peak_scalar_bits": 23,
+        "products": 210,
+        "reads": 9422,
+        "roundings": 72,
+        "setup_divisions": 140,
+        "setup_entries": 140,
+        "source_shifts": 72,
+        "writes": 5446
+      },
+      "bits": 12,
+      "gap": "1/4",
+      "length": 3,
+      "lower": 1,
+      "nonzero_error": true,
+      "output": [
+        [
+          -313,
+          436
+        ],
+        [
+          -419,
+          -45
+        ],
+        [
+          -133,
+          210
+        ]
+      ],
+      "period": 28,
+      "resident_extents": [
+        420,
+        1050,
+        308,
+        420
+      ],
+      "terms": 4,
+      "width": 2
+    }
+  ],
+  "finite_lines": 32,
+  "finite_target_outputs": 96,
+  "gaussian": {
+    "checked_off_band_entries": 1240,
+    "dropped_wrap_detected": true,
+    "gap": "65413/65536",
+    "holes": [
+      2,
+      7,
+      12,
+      17,
+      22,
+      27,
+      32,
+      37
+    ],
+    "lines": [
+      {
+        "bill": {
+          "additions": 702,
+          "control_steps": 1219,
+          "maximum_single_tape_extent": 7830,
+          "moves": 166440,
+          "page_scans": 2,
+          "peak_scalar_bits": 55,
+          "products": 702,
+          "reads": 57570,
+          "roundings": 136,
+          "setup_divisions": 0,
+          "setup_entries": 0,
+          "source_shifts": 136,
+          "writes": 17730
+        },
+        "lower": -2,
+        "nonzero_error": true,
+        "output": [
+          [
+            44823113,
+            19209557
+          ],
+          [
+            -44739418,
+            -19173813
+          ],
+          [
+            -44739242,
+            19173961
+          ],
+          [
+            44739406,
+            -19174022
+          ],
+          [
+            44739259,
+            19173950
+          ]
+        ],
+        "resident_extents": [
+          1740,
+          7830,
+          1260,
+          1740
+        ]
+      },
+      {
+        "bill": {
+          "additions": 702,
+          "control_steps": 1219,
+          "maximum_single_tape_extent": 7830,
+          "moves": 166440,
+          "page_scans": 2,
+          "peak_scalar_bits": 55,
+          "products": 702,
+          "reads": 57570,
+          "roundings": 136,
+          "setup_divisions": 0,
+          "setup_entries": 0,
+          "source_shifts": 136,
+          "writes": 17730
+        },
+        "lower": 5,
+        "nonzero_error": true,
+        "output": [
+          [
+            44739285,
+            -19173933
+          ],
+          [
+            -44739449,
+            19173994
+          ],
+          [
+            44739302,
+            -19173922
+          ],
+          [
+            44822858,
+            19209723
+          ],
+          [
+            -44739475,
+            -19173978
+          ]
+        ],
+        "resident_extents": [
+          1740,
+          7830,
+          1260,
+          1740
+        ]
+      },
+      {
+        "bill": {
+          "additions": 702,
+          "control_steps": 819,
+          "maximum_single_tape_extent": 7830,
+          "moves": 144840,
+          "page_scans": 1,
+          "peak_scalar_bits": 55,
+          "products": 702,
+          "reads": 46770,
+          "roundings": 136,
+          "setup_divisions": 0,
+          "setup_entries": 0,
+          "source_shifts": 136,
+          "writes": 17730
+        },
+        "lower": 18,
+        "nonzero_error": true,
+        "output": [
+          [
+            -44822943,
+            19209668
+          ],
+          [
+            44739247,
+            -19173923
+          ],
+          [
+            44739412,
+            19173851
+          ],
+          [
+            -44739577,
+            -19173912
+          ],
+          [
+            44739429,
+            19173840
+          ]
+        ],
+        "resident_extents": [
+          1740,
+          7830,
+          1260,
+          1740
+        ]
+      }
+    ],
+    "nonzero_wrap_entries": 2,
+    "numerical_bound": "11/267931648",
+    "original_matrix_entries": 1600,
+    "period": 40,
+    "setup": {
+      "band_source_calls": 360,
+      "kernel_error_bits": 68,
+      "maximum_rational_height": 175,
+      "parameters": [
+        32,
+        8,
+        2,
+        1,
+        8,
+        32
+      ],
+      "production_bill": {
+        "additions": 0,
+        "control_steps": 400,
+        "maximum_single_tape_extent": 10800,
+        "moves": 21600,
+        "page_scans": 0,
+        "peak_scalar_bits": 0,
+        "products": 0,
+        "reads": 0,
+        "roundings": 0,
+        "setup_divisions": 360,
+        "setup_entries": 360,
+        "source_shifts": 0,
+        "writes": 10800
+      },
+      "reference_sha256": "1c9678360096d96f71a01153d8ef51ce2b53b5fe2b1f2d35f7b0f6de9d1f9a85",
+      "stored_coefficient_height": 140,
+      "stored_entries": 360,
+      "stored_kernels": 1,
+      "stored_weights": 32,
+      "table_bits": 10800,
+      "weight_precision": 71
+    },
+    "tail_bound": "228886641/36824245303148281856",
+    "target_bits": 20,
+    "tensor": {
+      "axis_receipts": [
+        {
+          "axis": 0,
+          "input_lines": 27,
+          "line_length": 28,
+          "output_records": 108,
+          "page_scans": 2,
+          "products": 17496,
+          "radix_passes": 10,
+          "target_length": 4
+        },
+        {
+          "axis": 1,
+          "input_lines": 4,
+          "line_length": 27,
+          "output_records": 12,
+          "page_scans": 2,
+          "products": 2376,
+          "radix_passes": 10,
+          "target_length": 3
+        }
+      ],
+      "bill": {
+        "additions": 19872,
+        "control_steps": 39124,
+        "maximum_single_tape_extent": 52920,
+        "moves": 11240280,
+        "page_scans": 4,
+        "peak_scalar_bits": 54,
+        "products": 19872,
+        "reads": 2398440,
+        "roundings": 3936,
+        "setup_divisions": 720,
+        "setup_entries": 720,
+        "source_shifts": 3936,
+        "writes": 2976180
+      },
+      "copied_records": 756,
+      "dimensions": 2,
+      "fixed_local_tape_roles": 8,
+      "key_width": 10,
+      "label": "actual-reference-2d",
+      "nonzero_error": true,
+      "numerical_bound": "11/133965824",
+      "output": [
+        [
+          [
+            -1,
+            5
+          ],
+          [
+            -16563329,
+            -11064879
+          ]
+        ],
+        [
+          [
+            -1,
+            6
+          ],
+          [
+            -16561022,
+            -11063579
+          ]
+        ],
+        [
+          [
+            -1,
+            7
+          ],
+          [
+            -16558485,
+            -11062163
+          ]
+        ],
+        [
+          [
+            0,
+            5
+          ],
+          [
+            -16770857,
+            -11181245
+          ]
+        ],
+        [
+          [
+            0,
+            6
+          ],
+          [
+            -16768550,
+            -11179945
+          ]
+        ],
+        [
+          [
+            0,
+            7
+          ],
+          [
+            -16766014,
+            -11178529
+          ]
+        ],
+        [
+          [
+            1,
+            5
+          ],
+          [
+            -16770410,
+            -11180988
+          ]
+        ],
+        [
+          [
+            1,
+            6
+          ],
+          [
+            -16768103,
+            -11179688
+          ]
+        ],
+        [
+          [
+            1,
+            7
+          ],
+          [
+            -16765566,
+            -11178272
+          ]
+        ],
+        [
+          [
+            2,
+            5
+          ],
+          [
+            -16769819,
+            -11180663
+          ]
+        ],
+        [
+          [
+            2,
+            6
+          ],
+          [
+            -16767512,
+            -11179363
+          ]
+        ],
+        [
+          [
+            2,
+            7
+          ],
+          [
+            -16764976,
+            -11177947
+          ]
+        ]
+      ],
+      "protected_archive_bits": 21600,
+      "role_extents": [
+        [
+          "rectangle current",
+          52920
+        ],
+        [
+          "rectangle next",
+          7560
+        ],
+        [
+          "radix zero",
+          31360
+        ],
+        [
+          "radix one",
+          26460
+        ],
+        [
+          "fixed borrowed line",
+          1680
+        ],
+        [
+          "fixed iterate zero",
+          1680
+        ],
+        [
+          "fixed iterate one",
+          1200
+        ],
+        [
+          "fixed local band page",
+          7560
+        ]
+      ],
+      "saved_lengths": [
+        28,
+        27
+      ],
+      "source_setup": {
+        "kernel_error_bits": 68,
+        "maximum_rational_height": 175,
+        "parameters": [
+          32,
+          8,
+          2,
+          1,
+          8,
+          32
+        ],
+        "reference_sha256": "1c9678360096d96f71a01153d8ef51ce2b53b5fe2b1f2d35f7b0f6de9d1f9a85",
+        "stored_entries": 360,
+        "stored_kernels": 1,
+        "stored_weights": 32,
+        "weight_precision": 71
+      },
+      "target_records": 12,
+      "total_retained_local_bits": 130420
+    }
+  },
+  "no_new_kappa": true,
+  "nonzero_rounding_lines": 32,
+  "program_sha256": {
+    "engine.py": "38ca22b213a0291cc7ba821baf513db289c1c3e7c24c579c5eff3349280484b2",
+    "source.py": "20c0fb2e4aa95de976ef6ce74ded4bf1cb9073732eca7eda8f61e45d239afa2c",
+    "tensor.py": "b3cfe3c18988a89d4a639e8104db7a87f7029d556c74c2e0f60d687ec6be5e80",
+    "verify.py": "9263a65f31d75f0f53d6acb2219781ee3b48a56fe08963716f104890ea5945f5"
+  },
+  "rectangle_reuse": {
+    "constructors_sealed_during_calls": true,
+    "fixed_role_count": 8,
+    "history": [
+      {
+        "archive_scans": 3,
+        "copied_records": 81,
+        "moves": 582456,
+        "output": [
+          [
+            [
+              -1,
+              4
+            ],
+            [
+              12,
+              -25
+            ]
+          ],
+          [
+            [
+              -1,
+              5
+            ],
+            [
+              20,
+              -23
+            ]
+          ],
+          [
+            [
+              -1,
+              6
+            ],
+            [
+              28,
+              -20
+            ]
+          ],
+          [
+            [
+              -1,
+              7
+            ],
+            [
+              39,
+              -28
+            ]
+          ],
+          [
+            [
+              -1,
+              8
+            ],
+            [
+              50,
+              -27
+            ]
+          ],
+          [
+            [
+              0,
+              4
+            ],
+            [
+              -32,
+              -27
+            ]
+          ],
+          [
+            [
+              0,
+              5
+            ],
+            [
+              -24,
+              -25
+            ]
+          ],
+          [
+            [
+              0,
+              6
+            ],
+            [
+              -16,
+              -23
+            ]
+          ],
+          [
+            [
+              0,
+              7
+            ],
+            [
+              -8,
+              -22
+            ]
+          ],
+          [
+            [
+              0,
+              8
+            ],
+            [
+              0,
+              -22
+            ]
+          ],
+          [
+            [
+              1,
+              4
+            ],
+            [
+              -35,
+              -19
+            ]
+          ],
+          [
+            [
+              1,
+              5
+            ],
+            [
+              -27,
+              -17
+            ]
+          ],
+          [
+            [
+              1,
+              6
+            ],
+            [
+              -19,
+              -15
+            ]
+          ],
+          [
+            [
+              1,
+              7
+            ],
+            [
+              -10,
+              -13
+            ]
+          ],
+          [
+            [
+              1,
+              8
+            ],
+            [
+              -3,
+              -12
+            ]
+          ],
+          [
+            [
+              2,
+              4
+            ],
+            [
+              -31,
+              -10
+            ]
+          ],
+          [
+            [
+              2,
+              5
+            ],
+            [
+              -23,
+              -8
+            ]
+          ],
+          [
+            [
+              2,
+              6
+            ],
+            [
+              -15,
+              -6
+            ]
+          ],
+          [
+            [
+              2,
+              7
+            ],
+            [
+              -7,
+              -4
+            ]
+          ],
+          [
+            [
+              2,
+              8
+            ],
+            [
+              0,
+              -3
+            ]
+          ],
+          [
+            [
+              3,
+              4
+            ],
+            [
+              -28,
+              -1
+            ]
+          ],
+          [
+            [
+              3,
+              5
+            ],
+            [
+              -19,
+              0
+            ]
+          ],
+          [
+            [
+              3,
+              6
+            ],
+            [
+              -11,
+              1
+            ]
+          ],
+          [
+            [
+              3,
+              7
+            ],
+            [
+              -3,
+              3
+            ]
+          ],
+          [
+            [
+              3,
+              8
+            ],
+            [
+              4,
+              6
+            ]
+          ],
+          [
+            [
+              4,
+              4
+            ],
+            [
+              -24,
+              6
+            ]
+          ],
+          [
+            [
+              4,
+              5
+            ],
+            [
+              -16,
+              8
+            ]
+          ],
+          [
+            [
+              4,
+              6
+            ],
+            [
+              -8,
+              10
+            ]
+          ],
+          [
+            [
+              4,
+              7
+            ],
+            [
+              0,
+              13
+            ]
+          ],
+          [
+            [
+              4,
+              8
+            ],
+            [
+              8,
+              16
+            ]
+          ],
+          [
+            [
+              5,
+              4
+            ],
+            [
+              -20,
+              15
+            ]
+          ],
+          [
+            [
+              5,
+              5
+            ],
+            [
+              -12,
+              17
+            ]
+          ],
+          [
+            [
+              5,
+              6
+            ],
+            [
+              -4,
+              19
+            ]
+          ],
+          [
+            [
+              5,
+              7
+            ],
+            [
+              3,
+              22
+            ]
+          ],
+          [
+            [
+              5,
+              8
+            ],
+            [
+              12,
+              25
+            ]
+          ]
+        ],
+        "retained_bits": 8988,
+        "saved_lengths": [
+          9,
+          9
+        ],
+        "target_records": 35,
+        "writes": 181088
+      },
+      {
+        "archive_scans": 3,
+        "copied_records": 18,
+        "moves": 66468,
+        "output": [
+          [
+            [
+              8,
+              -1
+            ],
+            [
+              -44,
+              -7
+            ]
+          ],
+          [
+            [
+              8,
+              0
+            ],
+            [
+              -33,
+              28
+            ]
+          ]
+        ],
+        "retained_bits": 8988,
+        "saved_lengths": [
+          3,
+          6
+        ],
+        "target_records": 2,
+        "writes": 18956
+      },
+      {
+        "archive_scans": 3,
+        "copied_records": 77,
+        "moves": 472446,
+        "output": [
+          [
+            [
+              1,
+              9
+            ],
+            [
+              4,
+              -10
+            ]
+          ],
+          [
+            [
+              1,
+              10
+            ],
+            [
+              13,
+              -7
+            ]
+          ],
+          [
+            [
+              1,
+              11
+            ],
+            [
+              21,
+              -5
+            ]
+          ],
+          [
+            [
+              1,
+              12
+            ],
+            [
+              29,
+              -3
+            ]
+          ],
+          [
+            [
+              1,
+              13
+            ],
+            [
+              37,
+              -1
+            ]
+          ],
+          [
+            [
+              1,
+              14
+            ],
+            [
+              45,
+              0
+            ]
+          ],
+          [
+            [
+              1,
+              15
+            ],
+            [
+              52,
+              2
+            ]
+          ],
+          [
+            [
+              2,
+              9
+            ],
+            [
+              8,
+              0
+            ]
+          ],
+          [
+            [
+              2,
+              10
+            ],
+            [
+              16,
+              0
+            ]
+          ],
+          [
+            [
+              2,
+              11
+            ],
+            [
+              24,
+              2
+            ]
+          ],
+          [
+            [
+              2,
+              12
+            ],
+            [
+              32,
+              5
+            ]
+          ],
+          [
+            [
+              2,
+              13
+            ],
+            [
+              40,
+              6
+            ]
+          ],
+          [
+            [
+              2,
+              14
+            ],
+            [
+              48,
+              8
+            ]
+          ],
+          [
+            [
+              2,
+              15
+            ],
+            [
+              56,
+              10
+            ]
+          ],
+          [
+            [
+              3,
+              9
+            ],
+            [
+              12,
+              7
+            ]
+          ],
+          [
+            [
+              3,
+              10
+            ],
+            [
+              20,
+              9
+            ]
+          ],
+          [
+            [
+              3,
+              11
+            ],
+            [
+              28,
+              11
+            ]
+          ],
+          [
+            [
+              3,
+              12
+            ],
+            [
+              36,
+              13
+            ]
+          ],
+          [
+            [
+              3,
+              13
+            ],
+            [
+              44,
+              15
+            ]
+          ],
+          [
+            [
+              3,
+              14
+            ],
+            [
+              52,
+              17
+            ]
+          ],
+          [
+            [
+              3,
+              15
+            ],
+            [
+              61,
+              19
+            ]
+          ],
+          [
+            [
+              4,
+              9
+            ],
+            [
+              16,
+              16
+            ]
+          ],
+          [
+            [
+              4,
+              10
+            ],
+            [
+              23,
+              18
+            ]
+          ],
+          [
+            [
+              4,
+              11
+            ],
+            [
+              31,
+              20
+            ]
+          ],
+          [
+            [
+              4,
+              12
+            ],
+            [
+              39,
+              21
+            ]
+          ],
+          [
+            [
+              4,
+              13
+            ],
+            [
+              48,
+              24
+            ]
+          ],
+          [
+            [
+              4,
+              14
+            ],
+            [
+              55,
+              26
+            ]
+          ],
+          [
+            [
+              4,
+              15
+            ],
+            [
+              72,
+              20
+            ]
+          ],
+          [
+            [
+              5,
+              9
+            ],
+            [
+              19,
+              26
+            ]
+          ],
+          [
+            [
+              5,
+              10
+            ],
+            [
+              27,
+              19
+            ]
+          ],
+          [
+            [
+              5,
+              11
+            ],
+            [
+              35,
+              21
+            ]
+          ],
+          [
+            [
+              5,
+              12
+            ],
+            [
+              43,
+              23
+            ]
+          ],
+          [
+            [
+              5,
+              13
+            ],
+            [
+              51,
+              25
+            ]
+          ],
+          [
+            [
+              5,
+              14
+            ],
+            [
+              60,
+              31
+            ]
+          ],
+          [
+            [
+              5,
+              15
+            ],
+            [
+              60,
+              -30
+            ]
+          ]
+        ],
+        "retained_bits": 9204,
+        "saved_lengths": [
+          7,
+          11
+        ],
+        "target_records": 35,
+        "writes": 145378
+      }
+    ]
+  },
+  "schema_version": 1,
+  "seed": 72,
+  "source_sha256": {
+    "research/certified-gaussian-recovery/NOTICE.md": "10acae9e78402ca70c6afd0e8d6da8fefc0da519c646cf43d93f923aba85b86d",
+    "research/certified-gaussian-recovery/intervals.py": "159d2a7d32a8cc7c8f56632a8ef127308b984a0a6753c9d6bdccacc6e7d6d4df",
+    "research/rational-unitary-fft/RAW-GAUSSIAN-PROOF.md": "3f683643a0c0b45d58ec09ebe511e4006cd103e38753f82a4ce21a8570383358",
+    "research/rational-unitary-fft/exact.py": "c9b89d7357210af69865690ba12e695366961f8b501a8fab9d0fefe3fb30c479",
+    "research/rational-unitary-fft/gaussian.py": "08155357fd39b5fd7959f51f1d205b6511b8577b51520d793c89f92368b399ab",
+    "research/rational-unitary-fft/gaussian_reference.py": "ed4d0908646e391d4a0ea32c988a0301a1793a72294ac7058a664ed3283ca3c3",
+    "research/unconditional-batched-crt/GAUSSIAN.md": "2f63c91c58f2d1cf31294812c75970ea390c61866a8da7ed700d4316a033a242",
+    "research/unconditional-batched-crt/HALO.md": "a2adcf18614983e9255def6d3f5e59be0018a392e418d65e94323722838289cc",
+    "research/unconditional-batched-crt/PROOF.md": "689fc7b01c5f04f77019ff02d1b79cb4f7020bd98e05b1052020bad295dec060"
+  },
+  "tensors": [
+    {
+      "axis_receipts": [
+        {
+          "axis": 0,
+          "input_lines": 6,
+          "line_length": 4,
+          "output_records": 12,
+          "page_scans": 2,
+          "products": 72,
+          "radix_passes": 5,
+          "target_length": 2
+        },
+        {
+          "axis": 1,
+          "input_lines": 2,
+          "line_length": 6,
+          "output_records": 4,
+          "page_scans": 2,
+          "products": 72,
+          "radix_passes": 5,
+          "target_length": 2
+        }
+      ],
+      "bill": {
+        "additions": 144,
+        "control_steps": 1226,
+        "maximum_single_tape_extent": 792,
+        "moves": 103200,
+        "page_scans": 4,
+        "peak_scalar_bits": 18,
+        "products": 144,
+        "reads": 19976,
+        "roundings": 120,
+        "setup_divisions": 66,
+        "setup_entries": 66,
+        "source_shifts": 120,
+        "writes": 30904
+      },
+      "copied_records": 24,
+      "dimensions": 2,
+      "fixed_local_tape_roles": 8,
+      "key_width": 5,
+      "label": "signed-2d",
+      "nonzero_error": true,
+      "numerical_bound": "25/768",
+      "output": [
+        [
+          [
+            -1,
+            9
+          ],
+          [
+            23,
+            -9
+          ]
+        ],
+        [
+          [
+            -1,
+            10
+          ],
+          [
+            -16,
+            9
+          ]
+        ],
+        [
+          [
+            0,
+            9
+          ],
+          [
+            -11,
+            8
+          ]
+        ],
+        [
+          [
+            0,
+            10
+          ],
+          [
+            1,
+            6
+          ]
+        ]
+      ],
+      "protected_archive_bits": 792,
+      "role_extents": [
+        [
+          "rectangle current",
+          696
+        ],
+        [
+          "rectangle next",
+          348
+        ],
+        [
+          "radix zero",
+          464
+        ],
+        [
+          "radix one",
+          348
+        ],
+        [
+          "fixed borrowed line",
+          144
+        ],
+        [
+          "fixed iterate zero",
+          144
+        ],
+        [
+          "fixed iterate one",
+          96
+        ],
+        [
+          "fixed local band page",
+          216
+        ]
+      ],
+      "saved_lengths": [
+        4,
+        6
+      ],
+      "target_records": 4,
+      "total_retained_local_bits": 2456
+    },
+    {
+      "axis_receipts": [
+        {
+          "axis": 0,
+          "input_lines": 24,
+          "line_length": 4,
+          "output_records": 48,
+          "page_scans": 2,
+          "products": 288,
+          "radix_passes": 7,
+          "target_length": 2
+        },
+        {
+          "axis": 1,
+          "input_lines": 8,
+          "line_length": 6,
+          "output_records": 16,
+          "page_scans": 2,
+          "products": 288,
+          "radix_passes": 7,
+          "target_length": 2
+        },
+        {
+          "axis": 2,
+          "input_lines": 4,
+          "line_length": 4,
+          "output_records": 8,
+          "page_scans": 2,
+          "products": 48,
+          "radix_passes": 7,
+          "target_length": 2
+        }
+      ],
+      "bill": {
+        "additions": 624,
+        "control_steps": 5151,
+        "maximum_single_tape_extent": 2976,
+        "moves": 559200,
+        "page_scans": 6,
+        "peak_scalar_bits": 18,
+        "products": 624,
+        "reads": 102260,
+        "roundings": 528,
+        "setup_divisions": 99,
+        "setup_entries": 99,
+        "source_shifts": 528,
+        "writes": 174220
+      },
+      "copied_records": 96,
+      "dimensions": 3,
+      "fixed_local_tape_roles": 8,
+      "key_width": 7,
+      "label": "signed-3d",
+      "nonzero_error": true,
+      "numerical_bound": "65/1536",
+      "output": [
+        [
+          [
+            -1,
+            9,
+            -1
+          ],
+          [
+            -3,
+            0
+          ]
+        ],
+        [
+          [
+            -1,
+            9,
+            0
+          ],
+          [
+            -1,
+            0
+          ]
+        ],
+        [
+          [
+            -1,
+            10,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ]
+        ],
+        [
+          [
+            -1,
+            10,
+            0
+          ],
+          [
+            3,
+            0
+          ]
+        ],
+        [
+          [
+            0,
+            9,
+            -1
+          ],
+          [
+            -1,
+            2
+          ]
+        ],
+        [
+          [
+            0,
+            9,
+            0
+          ],
+          [
+            2,
+            -2
+          ]
+        ],
+        [
+          [
+            0,
+            10,
+            -1
+          ],
+          [
+            6,
+            1
+          ]
+        ],
+        [
+          [
+            0,
+            10,
+            0
+          ],
+          [
+            -3,
+            1
+          ]
+        ]
+      ],
+      "protected_archive_bits": 1188,
+      "role_extents": [
+        [
+          "rectangle current",
+          2976
+        ],
+        [
+          "rectangle next",
+          1488
+        ],
+        [
+          "radix zero",
+          1984
+        ],
+        [
+          "radix one",
+          1488
+        ],
+        [
+          "fixed borrowed line",
+          144
+        ],
+        [
+          "fixed iterate zero",
+          144
+        ],
+        [
+          "fixed iterate one",
+          96
+        ],
+        [
+          "fixed local band page",
+          216
+        ]
+      ],
+      "saved_lengths": [
+        4,
+        6,
+        4
+      ],
+      "target_records": 8,
+      "total_retained_local_bits": 8536
+    }
+  ]
+}
diff --git a/research/shrinking-reference-halo/SOURCES.json b/research/shrinking-reference-halo/SOURCES.json
new file mode 100644
index 0000000000..2e7ea79dae
--- /dev/null
+++ b/research/shrinking-reference-halo/SOURCES.json
@@ -0,0 +1,72 @@
+{
+  "schema_version": 1,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "files": [
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "path": "research/rational-unitary-fft/exact.py",
+      "usage": "input",
+      "git_blob": "aae41e6acfb2e5a4fafdd85727891eb746b57b42",
+      "sha256": "c9b89d7357210af69865690ba12e695366961f8b501a8fab9d0fefe3fb30c479"
+    },
+    {
+      "path": "research/rational-unitary-fft/gaussian.py",
+      "usage": "input",
+      "git_blob": "52ad2e1d605f5f7d669234567c25bc087306dd44",
+      "sha256": "08155357fd39b5fd7959f51f1d205b6511b8577b51520d793c89f92368b399ab"
+    },
+    {
+      "path": "research/rational-unitary-fft/gaussian_reference.py",
+      "usage": "input",
+      "git_blob": "92addfabde50655cea7ad5a84cca9cff5457adee",
+      "sha256": "ed4d0908646e391d4a0ea32c988a0301a1793a72294ac7058a664ed3283ca3c3"
+    },
+    {
+      "path": "research/rational-unitary-fft/RAW-GAUSSIAN-PROOF.md",
+      "usage": "input",
+      "git_blob": "1fb549d24a419abb50f5b772437d87e48c65fe06",
+      "sha256": "3f683643a0c0b45d58ec09ebe511e4006cd103e38753f82a4ce21a8570383358"
+    },
+    {
+      "path": "research/certified-gaussian-recovery/intervals.py",
+      "usage": "input",
+      "git_blob": "91d458865aa026bdf0d59653a4ecbfe3a178ecbc",
+      "sha256": "159d2a7d32a8cc7c8f56632a8ef127308b984a0a6753c9d6bdccacc6e7d6d4df"
+    },
+    {
+      "path": "research/certified-gaussian-recovery/NOTICE.md",
+      "usage": "input",
+      "git_blob": "5e3269b5afe5e11f044ffae45216c4731b42c7af",
+      "sha256": "10acae9e78402ca70c6afd0e8d6da8fefc0da519c646cf43d93f923aba85b86d"
+    },
+    {
+      "path": "research/unconditional-batched-crt/HALO.md",
+      "usage": "input",
+      "git_blob": "5f601b3c8ac368aa79aa1007effe5933a360237b",
+      "sha256": "a2adcf18614983e9255def6d3f5e59be0018a392e418d65e94323722838289cc"
+    },
+    {
+      "path": "research/unconditional-batched-crt/PROOF.md",
+      "usage": "input",
+      "git_blob": "406eb561cc8d6041ea3fba1a849653b654f2198c",
+      "sha256": "689fc7b01c5f04f77019ff02d1b79cb4f7020bd98e05b1052020bad295dec060"
+    },
+    {
+      "path": "research/unconditional-batched-crt/GAUSSIAN.md",
+      "usage": "input",
+      "git_blob": "adfb28c93e6b06178c901caaac39ede41a9e541b",
+      "sha256": "2f63c91c58f2d1cf31294812c75970ea390c61866a8da7ed700d4316a033a242"
+    }
+  ]
+}
diff --git a/research/shrinking-reference-halo/TASK.json b/research/shrinking-reference-halo/TASK.json
new file mode 100644
index 0000000000..e86759a09a
--- /dev/null
+++ b/research/shrinking-reference-halo/TASK.json
@@ -0,0 +1,93 @@
+{
+  "schema_version": 1,
+  "task_id": "uniform-transfer-audit",
+  "priority_revision": 8,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "original_card": {
+    "id": "uniform-transfer-audit",
+    "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?",
+    "starting_points": [
+      "docs/research/current-priorities.md",
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md"
+    ],
+    "methods": [
+      "Construct and independently check one source-bound instance of the stated first experiment.",
+      "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+    ],
+    "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_selected_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+      "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+    },
+    "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.",
+    "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+    "allowed_variations": [
+      "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+    ],
+    "scope_change_triggers": [
+      "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+      "Treating an archived proposal or local numerical pass as complete supplier admission."
+    ],
+    "overlap_terms": [
+      "native_all_columns",
+      "owned_erasure",
+      "compiler",
+      "precision_tape",
+      "analytic_recovery"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.",
+        "evidence": "research/unconditional-batched-crt/README.md",
+        "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.",
+        "status": "author-checked",
+        "source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+        "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+        "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+        "status": "reviewed",
+        "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+        "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+      }
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "A source-bound local shrinking-domain normalized inverse tensor consumer on fixed sequential tape roles, with coefficient/data error, original reference-band production, full archive access, physical sparse axis exposure and complete generic/production cost.",
+  "scope_change_reason": "Direct degree specialization and generic Horner stability are already proved. Follow the remaining global coefficient-page and physical local consumer obligation of #6880 and the host-array service boundary of #5159; retain all original Gaussian and outer assumptions.",
+  "bottleneck_link": "Constructs one analytic_recovery/precision_tape component using the actual rational Gaussian Reference without a global polynomial-row oracle. Does not discharge either complete selected assumption.",
+  "budget_minutes": 180,
+  "stop_rule": "Stop at the verified local consumer and its complete cost. No scalar degree retuning, source analytic reproof, independent supplier admission or speculative outer theorem claim.",
+  "outcome": "completed",
+  "evidence": "PROOF.md; engine.py/source.py/tensor.py; exact typed RESULT.json; independently developed original-inverse rational elimination and all-row residual certificates; six successful normal and optimized registered replays; predecessor overlap sources.",
+  "author": "CubeJerry",
+  "ai_assistance": "Substantial OpenAI Codex assistance in mathematics, source analysis, implementation, exact verification and separate adversarial AI review.",
+  "open_questions": [
+    {
+      "question": "Can the same fixed reference and normalizer be admitted at the finite core and outer recovery?",
+      "why_it_matters": "Similar Gaussian terminology does not make different rounded matrices or all-input error contracts interchangeable.",
+      "first_step": "Pin the exact core reference and actual-input theorem, then substitute the complete tensor error in the existing recovery ledger.",
+      "blocked_by": "Finite core adoption, source compatibility and full outer multiplier admission remain unproved here."
+    }
+  ],
+  "resolved_questions": [
+    {
+      "question": "Can this local consumer be joined to the actual first-face gather and unique-return transaction?",
+      "why_it_matters": "Its saved rectangle must contain original values before core mutation, and every returned target key must be consumed exactly once.",
+      "first_step": "Bind one wrapping/hole rectangle codec and q-grid on both sides, then prove and execute the complete group transaction.",
+      "blocked_by": "The dense-source copy/return chronology and actual outer ownership interface are outside this package.",
+      "resolution": "Resolved under the explicit source/plan hypotheses by research/first-face-reference-join: universal codec/chronology/cost composition, actual Reference64 transaction, independent whole-grid unequal-halo/spectator checks. Actual core and complete outer admission remain open."
+    }
+  ],
+  "integration_package": "research/first-face-reference-join"
+}
diff --git a/research/shrinking-reference-halo/VERIFY.json b/research/shrinking-reference-halo/VERIFY.json
new file mode 100644
index 0000000000..1345ca68ab
--- /dev/null
+++ b/research/shrinking-reference-halo/VERIFY.json
@@ -0,0 +1,82 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/rational-unitary-fft/exact.py",
+    "research/rational-unitary-fft/gaussian.py",
+    "research/rational-unitary-fft/gaussian_reference.py",
+    "research/rational-unitary-fft/RAW-GAUSSIAN-PROOF.md",
+    "research/certified-gaussian-recovery/intervals.py",
+    "research/certified-gaussian-recovery/NOTICE.md",
+    "research/unconditional-batched-crt/HALO.md",
+    "research/unconditional-batched-crt/PROOF.md",
+    "research/unconditional-batched-crt/GAUSSIAN.md"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Exact source-band line/tensor proof obligations, all forty-row reference entries, fixed-role history, complete physical invoices and negative controls; typed mandatory receipt."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "The identical exact source-bound consumer, ownership histories and rejection controls with assertions disabled."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/independent_inverse.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Separate exact original-matrix inverse-row elimination and physical two-axis tensor execution, sealed fixed-role reuse and wrong-target control. Normal replay."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/independent_inverse.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Separate exact original-matrix inverse-row elimination and physical two-axis tensor execution, sealed fixed-role reuse and wrong-target control. Assertions-disabled replay."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/independent_residual.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Separate all-forty-row original-reference residual certificate and wrong-return-order lower bound, without the author polynomial verifier. Normal replay."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/independent_residual.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Separate all-forty-row original-reference residual certificate and wrong-return-order lower bound, without the author polynomial verifier. Assertions-disabled replay."
+    }
+  ]
+}
diff --git a/research/shrinking-reference-halo/engine.py b/research/shrinking-reference-halo/engine.py
new file mode 100644
index 0000000000..984dffee3f
--- /dev/null
+++ b/research/shrinking-reference-halo/engine.py
@@ -0,0 +1,385 @@
+"""Sequential shrinking-domain normalized inverse action.
+
+Prepared for @CubeJerry with substantial OpenAI Codex assistance. Apache-2.0.
+Classical fixed-source Horner iteration is inherited; this file supplies the
+local shrinking domains, sequential band-page extraction and ownership trace.
+Bit-tape movement is executed. Bounded integer arithmetic is a declared scalar
+macro, with its ordinary schoolbook bit cost established in PROOF.md.
+"""
+from dataclasses import dataclass, field
+from fractions import Fraction as Q
+from hashlib import sha256
+
+
+def need(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def trunc(n, denominator):
+    need(type(n) is int and type(denominator) is int and denominator > 0,
+         "integer truncation domain")
+    return (-1 if n < 0 else 1) * (abs(n) // denominator)
+
+
+def inward(value, bits):
+    value = Q(value)
+    return trunc(value.numerator << bits, value.denominator)
+
+
+@dataclass
+class Bill:
+    reads: int = 0
+    writes: int = 0
+    moves: int = 0
+    products: int = 0
+    additions: int = 0
+    roundings: int = 0
+    source_shifts: int = 0
+    control_steps: int = 0
+    peak_scalar_bits: int = 0
+    setup_entries: int = 0
+    setup_divisions: int = 0
+    page_scans: int = 0
+    maximum_single_tape_extent: int = 0
+
+    def scalar(self, *values):
+        self.peak_scalar_bits = max(self.peak_scalar_bits,
+                                    *(abs(x).bit_length() + 1 for x in values))
+
+    def record(self):
+        return {name: getattr(self, name) for name in self.__dataclass_fields__}
+
+
+class Tape:
+    """Binary tape; data may be accessed only at the current head.
+
+    The host list implements tape cells, not a program-visible indexed array.
+    snapshot() is an independent diagnostic, never a transition primitive.
+    Blank cells are zero. Every cell beyond live_bits is already blank. Clear
+    erases the complete current live body; retained blank backing stays paid
+    in space but need not be erased again for every later shorter line.
+    """
+    def __init__(self, bill, name):
+        self._cells = []
+        self.head = 0
+        self.live_bits = 0
+        self.bill = bill
+        self.name = name
+        self.readonly = False
+
+    @property
+    def extent(self):
+        return len(self._cells)
+
+    def read(self):
+        need(self.head < self.live_bits, "read beyond live encoded body")
+        self.bill.reads += 1
+        return self._cells[self.head] if self.head < self.extent else 0
+
+    def write(self, bit):
+        need(not self.readonly, "write to borrowed immutable tape")
+        need(type(bit) is int and bit in (0, 1), "binary cell")
+        if self.head >= self.extent:
+            self._cells.extend([0] * (self.head + 1 - self.extent))
+        self._cells[self.head] = bit
+        self.live_bits = max(self.live_bits, self.head + 1)
+        self.bill.writes += 1
+        self.bill.maximum_single_tape_extent = max(self.bill.maximum_single_tape_extent, self.extent)
+
+    def step(self, direction):
+        need(type(direction) is int and direction in (-1, 1), "one-cell head move")
+        need(self.head + direction >= 0, "left tape boundary")
+        self.head += direction
+        self.bill.moves += 1
+
+    def walk(self, distance):
+        need(type(distance) is int, "encoded head displacement")
+        direction = -1 if distance < 0 else 1
+        for _ in range(abs(distance)):
+            self.step(direction)
+
+    def rewind(self):
+        self.walk(-self.head)
+
+    def clear(self):
+        need(not self.readonly, "clear borrowed immutable tape")
+        self.rewind()
+        occupied = self.live_bits
+        for _ in range(occupied):
+            self.write(0)
+            self.step(1)
+        self.rewind()
+        self.live_bits = 0
+
+    def snapshot(self):
+        return bytes(self._cells)
+
+
+def put_int(tape, value, width):
+    need(type(value) is int and type(width) is int and width >= 2,
+         "fixed-width integer")
+    need(abs(value) < (1 << (width - 1)), "integer carrier overflow")
+    tape.write(int(value < 0)); tape.step(1)
+    for shift in range(width - 2, -1, -1):
+        tape.write((abs(value) >> shift) & 1); tape.step(1)
+
+
+def get_int(tape, width):
+    sign = tape.read(); tape.step(1)
+    magnitude = 0
+    for _ in range(width - 1):
+        magnitude = 2 * magnitude + tape.read(); tape.step(1)
+    need(not (sign and magnitude == 0), "noncanonical negative zero")
+    return -magnitude if sign else magnitude
+
+
+def put_complex(tape, value, width):
+    need(type(value) is tuple and len(value) == 2, "signed complex pair")
+    put_int(tape, value[0], width); put_int(tape, value[1], width)
+
+
+def get_complex(tape, width):
+    return get_int(tape, width), get_int(tape, width)
+
+
+@dataclass(frozen=True)
+class Plan:
+    period: int
+    halfwidth: int
+    bits: int
+    terms: int
+    normalizer_shift: int
+    gap: Q
+    radius: int = 1
+
+    def __post_init__(self):
+        need(all(type(x) is int for x in (self.period, self.halfwidth, self.bits,
+             self.terms, self.normalizer_shift, self.radius)), "integer plan parameters")
+        need(self.period > 0 and self.halfwidth >= 0
+             and 2 * self.halfwidth < self.period, "unique cyclic band offsets")
+        need(self.bits >= self.normalizer_shift >= 0 and self.terms >= 1
+             and self.radius >= 1, "precision, iteration and radius domain")
+        need(type(self.gap) in (int, Q) and 0 < self.gap <= 1, "positive rational gap")
+        need((1 << self.normalizer_shift) * self.gap >= 1, "funded normalization")
+
+    @property
+    def band(self):
+        return 2 * self.halfwidth + 1
+
+    @property
+    def halo(self):
+        return (self.terms - 1) * self.halfwidth
+
+    @property
+    def coefficient_width(self):
+        return self.bits + 2
+
+    @property
+    def data_width(self):
+        return self.bits + self.radius.bit_length() + 1
+
+    @property
+    def numeric_error(self):
+        return Q(self.band * self.radius + 2, 1 << self.bits) / self.gap
+
+    @property
+    def tail_error(self):
+        return self.radius * (1 - self.gap) ** self.terms / (
+            (1 << self.normalizer_shift) * self.gap)
+
+
+@dataclass(frozen=True)
+class Table:
+    tape: Tape
+    plan: Plan
+    source_id: str
+
+
+@dataclass(frozen=True)
+class Page:
+    tape: Tape
+    plan: Plan
+    lower: int
+    length: int
+    source_id: str
+
+
+@dataclass(frozen=True)
+class Output:
+    tape: Tape
+    lower: int
+    length: int
+    width: int
+    blank_scratch: tuple = field(repr=False)
+
+
+def prepare_table(plan, entry, source_id, bill):
+    """entry(row, column) returns the exact fixed E=I-H coefficient.
+
+    Generic entry-production cost remains explicit; source.py provides the
+    authenticated Gaussian instantiation and its separately charged setup.
+    All offsets, including zero entries, are generated and stored.
+    """
+    tape = Tape(bill, "global band table")
+    largest_height = 0
+    for row in range(plan.period):
+        mass = Q(0)
+        for offset in range(-plan.halfwidth, plan.halfwidth + 1):
+            value = Q(entry(row, (row + offset) % plan.period))
+            largest_height = max(largest_height, abs(value.numerator).bit_length(),
+                                 value.denominator.bit_length())
+            mass += abs(value)
+            coefficient = inward(value, plan.bits)
+            need(abs(Q(coefficient, 1 << plan.bits)) <= abs(value), "inward coefficient")
+            need(abs(value - Q(coefficient, 1 << plan.bits)) < Q(1, 1 << plan.bits),
+                 "coefficient error")
+            put_int(tape, coefficient, plan.coefficient_width)
+            bill.setup_entries += 1
+            bill.setup_divisions += 1
+        need(mass <= 1 - plan.gap, "actual source row gap")
+        bill.control_steps += plan.band + 1
+    tape.rewind(); tape.readonly = True
+    return Table(tape, plan, source_id), largest_height
+
+
+def extract_page(table, lower, length, bill, page_tape=None):
+    """At most two COMPLETE ordered scans, including all skipped records.
+
+    The lifted interval has length less than the physical period, so each
+    canonical coordinate appears at most once. A wrapping tail is emitted
+    before its head. No random seek into the global table is used.
+    """
+    plan = table.plan
+    need(type(lower) is int and type(length) is int and 0 < length < plan.period,
+         "nonaliasing lifted page interval")
+    need(table.tape.head == 0, "global table origin")
+    # Accounting ownership can change between calls; it is not encoded data.
+    # Charge the repeated complete scan to THIS call, not to old preparation.
+    table.tape.bill = bill
+    start = lower % plan.period
+    first = min(length, plan.period - start)
+    spans = [(start, start + first)]
+    if first < length:
+        spans.append((0, length - first))
+    page = page_tape if page_tape is not None else Tape(bill, "local band page")
+    need(page.head == 0 and not page.readonly and page.live_bits == 0,
+         "blank local page role")
+    page.bill = bill
+    for begin, end in spans:
+        for row in range(plan.period):
+            for _ in range(plan.band):
+                value = get_int(table.tape, plan.coefficient_width)
+                if begin <= row < end:
+                    put_int(page, value, plan.coefficient_width)
+            bill.control_steps += plan.band + 1
+        table.tape.rewind()
+        bill.page_scans += 1
+    need(page.head == length * plan.band * plan.coefficient_width,
+         "complete ordered page")
+    page.rewind(); page.readonly = True
+    return Page(page, plan, lower, length, table.source_id)
+
+
+def input_tape(plan, values, bill):
+    tape = Tape(bill, "borrowed input")
+    for value in values:
+        need(type(value) is tuple and len(value) == 2 and
+             all(type(x) is int for x in value), "integer grid input")
+        need(abs(value[0]) + abs(value[1]) <= plan.radius * (1 << plan.bits),
+             "input radius")
+        put_complex(tape, value, plan.data_width)
+    tape.rewind(); tape.readonly = True
+    return tape
+
+
+def apply_line(page, source, target_lower, target_length, bill, workspace=None):
+    """Return only the target; preserve borrowed input/page and both origins.
+
+    source contains the entire saved dependency interval. All arithmetic is
+    performed on encoded integer numerators; no Fraction or matrix oracle is
+    used by the online recurrence. Other tensor coordinates are spectators.
+    """
+    p = page.plan
+    need(type(target_lower) is int and type(target_length) is int and target_length > 0,
+         "nonempty target interval")
+    lower, length = target_lower - p.halo, target_length + 2 * p.halo
+    need(page.lower == lower and page.length == length, "exact saved dependency domain")
+    need(length < p.period, "no repeated canonical input coordinate")
+    need(source.readonly and page.tape.readonly and source.head == page.tape.head == 0,
+         "immutable origin-aligned input and page")
+    source.bill = page.tape.bill = bill
+    record_bits = 2 * p.data_width
+    need(source.live_bits == length * record_bits, "complete input shape")
+    if workspace is None:
+        current, following = Tape(bill, "current iterate"), Tape(bill, "next iterate")
+    else:
+        need(type(workspace) is tuple and len(workspace) == 2
+             and workspace[0] is not workspace[1], "two distinct fixed iterate roles")
+        current, following = workspace
+        need(all(t.head == 0 and not t.readonly and t.live_bits == 0 for t in workspace),
+             "blank fixed iterate roles")
+        current.bill = following.bill = bill
+    scale = 1 << p.bits
+    # First term z_1=trunc_q(x/a); no E row is needed for this term.
+    for _ in range(length):
+        x = get_complex(source, p.data_width)
+        need(abs(x[0]) + abs(x[1]) <= p.radius * scale, "actual incoming radius")
+        z = tuple(trunc(v, 1 << p.normalizer_shift) for v in x)
+        put_complex(current, z, p.data_width)
+        bill.roundings += 2; bill.source_shifts += 2; bill.control_steps += 1
+        bill.scalar(*x, *z)
+    source.rewind(); current.rewind()
+    active_lower, active_length = lower, length
+    for _ in range(1, p.terms):
+        out_lower, out_length = active_lower + p.halfwidth, active_length - 2 * p.halfwidth
+        source.walk((out_lower - lower) * record_bits)
+        page.tape.walk((out_lower - lower) * p.band * p.coefficient_width)
+        for row in range(out_length):
+            x = get_complex(source, p.data_width)
+            real = x[0] << (p.bits - p.normalizer_shift)
+            imag = x[1] << (p.bits - p.normalizer_shift)
+            bill.source_shifts += 2
+            for _ in range(p.band):
+                coefficient = get_int(page.tape, p.coefficient_width)
+                z = get_complex(current, p.data_width)
+                product_real, product_imag = coefficient * z[0], coefficient * z[1]
+                real += product_real; imag += product_imag
+                bill.products += 2; bill.additions += 2; bill.control_steps += 1
+                bill.scalar(coefficient, *z, product_real, product_imag, real, imag)
+                need(abs(real) + abs(imag) <= p.radius * scale * scale,
+                     "partial exact accumulator radius")
+            result = trunc(real, scale), trunc(imag, scale)
+            need(abs(result[0]) + abs(result[1]) <= p.radius * scale,
+                 "actual rounded iterate radius")
+            put_complex(following, result, p.data_width)
+            bill.roundings += 2; bill.control_steps += 1
+            if row + 1 < out_length:
+                current.walk(-2 * p.halfwidth * record_bits)
+        need(current.head == active_length * record_bits, "complete neighbor-window traversal")
+        source.rewind(); page.tape.rewind()
+        current.clear(); following.rewind()
+        current, following = following, current
+        active_lower, active_length = out_lower, out_length
+    need((active_lower, active_length) == (target_lower, target_length), "target-only return")
+    need(source.head == page.tape.head == current.head == following.head == 0,
+         "return origins")
+    need(following.live_bits == 0, "cleared alternate iterate")
+    return Output(current, active_lower, active_length, p.data_width, (following,))
+
+
+def consume(output):
+    """Caller read, clear and origin restoration; reads only the live prefix.
+
+    An iterate buffer can retain a larger previously occupied blank suffix.
+    The complete live body is cleared; the suffix is blank by invariant.
+    """
+    need(output.tape.head == 0, "output origin")
+    result = tuple(get_complex(output.tape, output.width) for _ in range(output.length))
+    output.tape.clear()
+    need(output.tape.head == 0 and output.tape.live_bits == 0, "consumed output cleanup")
+    return result
+
+
+def tape_digest(tape):
+    return sha256(tape.snapshot()).hexdigest()
diff --git a/research/shrinking-reference-halo/independent_inverse.py b/research/shrinking-reference-halo/independent_inverse.py
new file mode 100644
index 0000000000..81f2729b24
--- /dev/null
+++ b/research/shrinking-reference-halo/independent_inverse.py
@@ -0,0 +1,147 @@
+"""Independent exact inverse-row check of the physical tensor consumer.
+
+The oracle solves the original rational matrix by Gaussian elimination;
+it does not evaluate a Neumann polynomial or a Horner recurrence.
+"""
+from fractions import Fraction as F
+from hashlib import sha256
+import importlib.util
+import itertools
+import json
+from pathlib import Path
+import random
+import sys
+
+PACKAGE = Path(__file__).resolve().parent
+
+
+def load(name, file):
+    spec = importlib.util.spec_from_file_location(name, file)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def inverse_rows(matrix, which):
+    """Solve H^T v=e_r, with exact rational elimination and residual checks."""
+    n = len(matrix)
+    targets = tuple(sorted(set(which)))
+    a = [[matrix[j][i] for j in range(n)] +
+         [F(int(i == r)) for r in targets] for i in range(n)]
+    for column in range(n):
+        pivot = next(r for r in range(column, n) if a[r][column])
+        a[column], a[pivot] = a[pivot], a[column]
+        divisor = a[column][column]
+        a[column] = [v / divisor for v in a[column]]
+        for row in range(column + 1, n):
+            factor = a[row][column]
+            if factor:
+                a[row] = [x - factor * y for x, y in zip(a[row], a[column])]
+    result = {}
+    for index, target in enumerate(targets):
+        row = [F(0)] * n
+        for r in range(n - 1, -1, -1):
+            row[r] = a[r][n + index] - sum(a[r][j] * row[j] for j in range(r + 1, n))
+        for c in range(n):
+            if sum(row[j] * matrix[j][c] for j in range(n)) != int(c == target):
+                raise AssertionError('exact inverse-row residual')
+        result[target] = row
+    return result
+
+
+def main():
+    engine = load('shrinking_halo_engine', PACKAGE / 'engine.py')
+    tensor = load('lead_tensor', PACKAGE / 'tensor.py')
+    source = load('lead_source', PACKAGE / 'source.py')
+    raw = source.authenticated_inputs(PACKAGE)
+    reference = source.make_reference(raw, (32, 8, 2, 1, 8, 32))
+    reference.require_narrow_gap()
+    n = reference.target_size
+    matrix = [[reference.entry('narrow', r, c).value for c in range(n)] for r in range(n)]
+    rho = max(sum(abs(F(int(r == c)) - matrix[r][c]) for c in range(n)) for r in range(n))
+    gap = F(int((1 - rho) * (1 << 16)), 1 << 16)
+    shift = 0
+    while (1 << shift) * gap < 1:
+        shift += 1
+    plan = engine.Plan(n, 2 * reference.spec.source_halfwidth + 2, 28, 4, shift, gap)
+    targets = ((-3, 2), (39, 2))
+    rows = inverse_rows(matrix, [x % n for lo, count in targets for x in range(lo, lo + count)])
+    scale = 1 << plan.bits
+    rng = random.Random(2026110875)
+    values = [[(rng.randrange(-8, 9) * (scale // 32),
+                rng.randrange(-8, 9) * (scale // 32)) for _ in range(n)] for _ in range(n)]
+    exact = {}
+    for r, s in itertools.product(*(range(lo, lo + count) for lo, count in targets)):
+        exact[r, s] = tuple(
+            sum(rows[r % n][u] * sum(rows[s % n][v] * values[u][v][part]
+                                    for v in range(n)) for u in range(n)) /
+            (scale * (1 << (2 * shift))) for part in (0, 1))
+    bill = engine.Bill()
+    production = source.make_reference(raw, (32, 8, 2, 1, 8, 32))
+
+    def prepared():
+        for _ in range(2):
+            table, _ = engine.prepare_table(
+                plan, lambda r, c: source.source_entry(production, r, c),
+                production.description_hash, bill)
+            yield table
+
+    archive = tensor.pack_tables(prepared(), bill)
+    before_archive = engine.tape_digest(archive.tape)
+    pool = tensor.TensorWorkspace.create(bill)
+    role_ids = tuple(map(id, pool.roles))
+    original_init = engine.Tape.__init__
+
+    def no_new_tapes(*_args, **_kwargs):
+        raise AssertionError('new physical role during tensor work or reuse')
+
+    engine.Tape.__init__ = no_new_tapes
+    observations = []
+    outputs = []
+    try:
+        for target in (targets, ((-3, 1), (39, 1))):
+            layout = tensor.Layout.make(archive.plans, target)
+            payloads = (values[u % n][v % n] for u, v in itertools.product(
+                *(range(lo, lo + count) for lo, count in zip(layout.lowers, layout.lengths))))
+            incoming = tensor.rectangle_input(layout, payloads, bill, tape=pool.rectangles[0])
+            result = tensor.apply_tensor(archive, target, incoming, bill, workspace=pool)
+            outputs.append(dict(tensor.consume_tensor(result)))
+            observations.append({'saved_records': layout.volume, 'target_records': result.count,
+                                 'retained_bits': sum(t.extent for t in pool.roles)})
+            if tuple(map(id, pool.roles)) != role_ids:
+                raise AssertionError('workspace roles changed')
+            if not all(t.head == 0 and t.live_bits == 0 and not any(t.snapshot()) for t in pool.roles):
+                raise AssertionError('nonblank workspace after return')
+            if engine.tape_digest(archive.tape) != before_archive or archive.tape.head:
+                raise AssertionError('borrowed archive changed')
+    finally:
+        engine.Tape.__init__ = original_init
+    bound = 2 * (plan.numeric_error + plan.tail_error)
+    errors = {}
+    for key, actual in outputs[0].items():
+        error = sum(abs(F(actual[p], scale) - exact[key][p]) for p in (0, 1))
+        if error > bound:
+            raise AssertionError(('exact original tensor inverse', key, str(error), str(bound)))
+        errors[key] = error
+    if outputs[1][(-3, 39)] != outputs[0][(-3, 39)]:
+        raise AssertionError('nested-target or retained-history dependence')
+    actual = outputs[0][(-3, 39)]
+    wrong = sum(abs(F(actual[p], scale) - exact[(-2, 40)][p]) for p in (0, 1))
+    if wrong <= bound:
+        raise AssertionError('wrong canonical target key not distinguished')
+    print('PASS_LEAD_EXACT_TENSOR_INVERSE')
+    print(json.dumps({'period': n, 'original_entries': n * n,
+                      'exact_inverse_rows': sorted(rows), 'checked_outputs': len(outputs[0]),
+                      'maximum_inverse_error': float(max(errors.values())),
+                      'proved_inverse_error_bound': float(bound),
+                      'wrong_target_error': float(wrong),
+                      'fixed_tape_roles': len(pool.roles), 'runs': observations,
+                      'actual_bit_actions': bill.reads + bill.writes + bill.moves,
+                      'source_entries': len(production.entries),
+                      'sha256': {p: sha256((PACKAGE / p).read_bytes()).hexdigest()
+                                 for p in ('engine.py', 'tensor.py', 'source.py')}}, sort_keys=True))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/shrinking-reference-halo/independent_residual.py b/research/shrinking-reference-halo/independent_residual.py
new file mode 100644
index 0000000000..e68b361a43
--- /dev/null
+++ b/research/shrinking-reference-halo/independent_residual.py
@@ -0,0 +1,91 @@
+"""Independent residual certification of the actual Gaussian consumer.
+
+Uses the author's numerical consumer, but no author's verifier or expected
+outputs. The mathematical oracle is an exact original-reference residual.
+"""
+from fractions import Fraction as F
+from hashlib import sha256
+import importlib.util
+import json
+from pathlib import Path
+import random
+import sys
+
+PACKAGE = Path(__file__).resolve().parent
+
+
+def load(name, file):
+    spec = importlib.util.spec_from_file_location(name, file)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def main():
+    engine = load('lead_halo_engine', PACKAGE/'engine.py')
+    source = load('lead_halo_source', PACKAGE/'source.py')
+    raw = source.authenticated_inputs(PACKAGE)
+    reference = source.make_reference(raw, (32,8,2,1,8,32))
+    reference.require_narrow_gap()
+    n = reference.target_size
+    H = [[reference.entry('narrow',r,c).value for c in range(n)] for r in range(n)]
+    E = [[F(int(r==c))-H[r][c] for c in range(n)] for r in range(n)]
+    rho = max(sum(map(abs,row)) for row in E)
+    gap = F(int((1-rho)*(1<<16)),1<<16)
+    shift = 0
+    while (1<<shift)*gap < 1:
+        shift += 1
+    plan = engine.Plan(n, 2*reference.spec.source_halfwidth+2, 28,4,shift,gap)
+    rng = random.Random(2026110874)
+    scale = 1<<plan.bits
+    x = []
+    for r in range(n):
+        re = rng.randrange(-scale//2, scale//2)
+        im = rng.randrange(-scale//3, scale//3)
+        x.append((re,im))
+    production = engine.Bill()
+    table,_ = engine.prepare_table(plan,lambda r,c:E[r][c],reference.description_hash,production)
+    table_digest = engine.tape_digest(table.tape)
+    y = []
+    all_bits = 0
+    for row in range(n):
+        bill = engine.Bill()
+        lower,length = row-plan.halo, 1+2*plan.halo
+        page = engine.extract_page(table,lower,length,bill)
+        inp = engine.input_tape(plan,tuple(x[j%n] for j in range(lower,lower+length)),bill)
+        inp_digest,page_digest = engine.tape_digest(inp),engine.tape_digest(page.tape)
+        output = engine.apply_line(page,inp,row,1,bill)
+        value, = engine.consume(output)
+        if (engine.tape_digest(inp)!=inp_digest or engine.tape_digest(page.tape)!=page_digest
+                or inp.head or page.tape.head or table.tape.head):
+            raise AssertionError('borrowed inputs or origin changed')
+        y.append(tuple(F(v,scale) for v in value))
+        all_bits += bill.reads+bill.writes+bill.moves
+    if engine.tape_digest(table.tape)!=table_digest:
+        raise AssertionError('reference table changed')
+    def residual(values):
+        return max(sum(abs(F(x[r][part],scale*(1<<shift))-
+                           sum(H[r][c]*values[c][part] for c in range(n)))
+                       for part in (0,1)) for r in range(n))
+    defect = residual(y)
+    certified = defect/gap
+    if not certified < F(1,1<<20):
+        raise AssertionError(('complete original-reference inverse residual',str(certified)))
+    shifted = y[1:]+y[:1]
+    wrong_lower_bound = residual(shifted)/(1+rho)
+    if wrong_lower_bound <= F(1,1<<20):
+        raise AssertionError('wrong canonical return order not detected')
+    print('PASS_LEAD_ORIGINAL_REFERENCE_RESIDUAL')
+    print(json.dumps({'period':n,'original_entries':n*n,'all_physical_output_rows':len(y),
+                      'fixed_source_sha256':reference.description_hash,
+                      'engine_sha256':sha256((PACKAGE/'engine.py').read_bytes()).hexdigest(),
+                      'source_adapter_sha256':sha256((PACKAGE/'source.py').read_bytes()).hexdigest(),
+                      'actual_bit_actions':all_bits,
+                      'certified_inverse_error_upper':float(certified),
+                      'required_error_upper':float(F(1,1<<20)),
+                      'wrong_return_order_error_lower_bound':float(wrong_lower_bound)},sort_keys=True))
+
+
+if __name__=='__main__':
+    main()
diff --git a/research/shrinking-reference-halo/source.py b/research/shrinking-reference-halo/source.py
new file mode 100644
index 0000000000..b78551e461
--- /dev/null
+++ b/research/shrinking-reference-halo/source.py
@@ -0,0 +1,114 @@
+"""Authenticated binding to the retained global Gaussian Reference.
+
+Prepared for @CubeJerry with substantial OpenAI Codex assistance. Apache-2.0.
+The executed Reference/interval algorithms belong to Jose Manuel and Mason
+Hale, with the original geometry and mathematical lineage credited in README.
+"""
+import ast
+from fractions import Fraction as Q
+from hashlib import sha256
+import json
+from pathlib import Path
+import sys
+from types import ModuleType
+
+
+def need(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+REFERENCE = "research/rational-unitary-fft/gaussian_reference.py"
+EXACT = "research/rational-unitary-fft/exact.py"
+GAUSSIAN = "research/rational-unitary-fft/gaussian.py"
+INTERVALS = "research/certified-gaussian-recovery/intervals.py"
+
+
+def authenticated_inputs(package):
+    root = package.parent.parent
+    manifest = json.loads((package / "SOURCES.json").read_text())
+    raw = {}
+    for item in manifest["files"]:
+        if item["usage"] == "input":
+            content = (root / item["path"]).read_bytes()
+            need(sha256(content).hexdigest() == item["sha256"],
+                 "changed pinned input: " + item["path"])
+            raw[item["path"]] = content
+    need(all(path in raw for path in (REFERENCE, EXACT, GAUSSIAN, INTERVALS)),
+         "complete source dependency manifest")
+    return raw
+
+
+def _module(name, statements, namespace=None):
+    module = ModuleType(name)
+    if namespace:
+        module.__dict__.update(namespace)
+    sys.modules[name] = module
+    tree = ast.Module(body=statements, type_ignores=[])
+    exec(compile(ast.fix_missing_locations(tree), "<authenticated source adapter>",
+                 "exec", optimize=0), module.__dict__)
+    return module
+
+
+def reference_class(raw):
+    """Rebind only imports, leaving every executed numerical body unchanged.
+
+    gaussian.py also imports a full circuit compiler unused by Reference's
+    explicit constructor/entry interface. Extract exactly its three named
+    helpers; no numerical source expression or loop is changed. for_cap is
+    outside this adapter's domain and is not invoked.
+    """
+    exact_tree = ast.parse(raw[EXACT])
+    exact = _module("_shrinking_source_exact", exact_tree.body)
+    gaussian_tree = ast.parse(raw[GAUSSIAN])
+    wanted = {"rational", "load_intervals"}
+    helpers = [node for node in gaussian_tree.body
+               if isinstance(node, ast.FunctionDef) and node.name in wanted]
+    need({node.name for node in helpers} == wanted, "retained Gaussian helper shape")
+    gaussian = _module("_shrinking_source_gaussian", helpers,
+                       {"Q": Q, "need": need, "sha256": sha256, "sys": sys,
+                        "ModuleType": ModuleType})
+    tree = ast.parse(raw[REFERENCE])
+    body = [node for node in tree.body if not (
+        isinstance(node, ast.ImportFrom) and node.module in ("exact", "gaussian"))]
+    reference = _module("_shrinking_source_reference", body,
+                        {"Mat": exact.Mat, "ceil_log2": exact.ceil_log2,
+                         "need": exact.need, "INTERVALS": INTERVALS,
+                         "load_intervals": gaussian.load_intervals,
+                         "rational": gaussian.rational})
+    return reference.Reference
+
+
+def make_reference(raw, parameters):
+    return reference_class(raw)(raw, *parameters)
+
+
+def source_entry(reference, row, column):
+    return Q(int(row == column)) - reference.entry("narrow", row, column).value
+
+
+def source_receipt(reference):
+    """Diagnostic setup inventory; not an asserted exact Python heap count."""
+    values = [entry.value for entry in reference.entries.values()]
+    weight_values = [value for receipt in reference.weights.values()
+                     for value in receipt.values() if type(value) is Q]
+    height = max([1] + [max(abs(x.numerator).bit_length(), x.denominator.bit_length())
+                        for x in values + weight_values])
+    return dict(reference_sha256=reference.description_hash,
+                parameters=list(reference.spec.__dict__.values()),
+                stored_entries=len(reference.entries), stored_weights=len(reference.weights),
+                stored_kernels=len(reference.kernel), maximum_rational_height=height,
+                weight_precision=reference.weight_precision,
+                kernel_error_bits=reference.kernel_error_bits)
+
+
+def clear_reference(reference):
+    """Release setup caches; physical erasure is separately charged in proof.
+
+    This does not claim secure zeroization of Python immutable integers.
+    """
+    reference.entries.clear(); reference.weights.clear(); reference.kernel.clear()
+    for name in ("pi_interval", "root_of_unity"):
+        function = getattr(reference.exp.oracle, name, None)
+        if function is not None and hasattr(function, "cache_clear"):
+            function.cache_clear()
diff --git a/research/shrinking-reference-halo/tensor.py b/research/shrinking-reference-halo/tensor.py
new file mode 100644
index 0000000000..40e84c41bf
--- /dev/null
+++ b/research/shrinking-reference-halo/tensor.py
@@ -0,0 +1,343 @@
+"""One local sparse rectangle on a fixed pool of sequential tape roles.
+
+Prepared for @CubeJerry with substantial OpenAI Codex assistance. Apache-2.0.
+The full-source gather and the final dense unique-return merge are separate.
+"""
+from dataclasses import dataclass
+import shrinking_halo_engine as M
+
+
+def put_unsigned(tape, value, width):
+    M.need(type(value) is int and 0 <= value < (1 << width), "unsigned key carrier")
+    for shift in range(width - 1, -1, -1):
+        tape.write((value >> shift) & 1); tape.step(1)
+
+
+def get_unsigned(tape, width):
+    value = 0
+    for _ in range(width):
+        value = 2 * value + tape.read(); tape.step(1)
+    return value
+
+
+@dataclass(frozen=True)
+class Archive:
+    tape: M.Tape
+    plans: tuple
+    source_ids: tuple
+
+
+def pack_tables(tables, bill):
+    """Consume one prepared axis table at a time into ONE protected archive.
+
+    A generator is sufficient: no simultaneous family of physical axis tapes
+    is required. Each old table body is erased before advancing the iterator.
+    The finite tuple of descriptors is charged as an encoded control block.
+    """
+    archive = M.Tape(bill, "global band archive")
+    plans, source_ids = [], []
+    bits = None
+    for table in tables:
+        if bits is None:
+            bits = table.plan.bits
+        M.need(table.plan.bits == bits and table.tape.head == 0, "common archive grid/origin")
+        table.tape.bill = bill
+        for _ in range(table.plan.period * table.plan.band):
+            coefficient = M.get_int(table.tape, table.plan.coefficient_width)
+            M.put_int(archive, coefficient, table.plan.coefficient_width)
+            bill.control_steps += 1
+        table.tape.readonly = False; table.tape.clear()
+        plans.append(table.plan); source_ids.append(table.source_id)
+    M.need(plans, "nonempty band archive")
+    archive.rewind(); archive.readonly = True
+    return Archive(archive, tuple(plans), tuple(source_ids))
+
+
+def archive_page(archive, axis, lower, length, page_tape, bill):
+    """One/two full ARCHIVE scans per local axis, never per spectator line."""
+    M.need(type(axis) is int and 0 <= axis < len(archive.plans), "archive axis")
+    p = archive.plans[axis]
+    M.need(type(lower) is int and type(length) is int and 0 < length < p.period,
+           "nonaliasing local page")
+    M.need(archive.tape.head == 0 and archive.tape.readonly, "protected archive origin")
+    M.need(page_tape.head == 0 and not page_tape.readonly and page_tape.live_bits == 0,
+           "reusable blank local page")
+    archive.tape.bill = page_tape.bill = bill
+    begin = lower % p.period
+    first = min(length, p.period - begin)
+    spans = [(begin, begin + first)]
+    if first < length:
+        spans.append((0, length - first))
+    for begin, end in spans:
+        for catalog_axis, pp in enumerate(archive.plans):
+            for row in range(pp.period):
+                emit = catalog_axis == axis and begin <= row < end
+                for _ in range(pp.band):
+                    coefficient = M.get_int(archive.tape, pp.coefficient_width)
+                    if emit:
+                        M.put_int(page_tape, coefficient, pp.coefficient_width)
+                bill.control_steps += pp.band + 1
+        archive.tape.rewind(); bill.page_scans += 1
+    M.need(page_tape.live_bits == length * p.band * p.coefficient_width, "complete local page")
+    page_tape.rewind(); page_tape.readonly = True
+    return M.Page(page_tape, p, lower, length, archive.source_ids[axis])
+
+
+@dataclass(frozen=True)
+class Layout:
+    targets: tuple
+    lowers: tuple
+    lengths: tuple
+    field_widths: tuple
+    field_shifts: tuple
+    key_width: int
+    data_width: int
+    bits: int
+    radius: int
+
+    @classmethod
+    def make(cls, plans, targets):
+        M.need(len(plans) == len(targets) and plans, "complete tensor axis metadata")
+        bits, radius = plans[0].bits, plans[0].radius
+        M.need(all(p.bits == bits and p.radius == radius for p in plans),
+               "one incoming/output tensor grid and radius")
+        lowers, lengths, widths = [], [], []
+        for p, target in zip(plans, targets):
+            M.need(type(target) is tuple and len(target) == 2 and
+                   all(type(x) is int for x in target) and target[1] > 0, "target axis interval")
+            lo, length = target[0] - p.halo, target[1] + 2 * p.halo
+            M.need(length < p.period, "each saved axis has unique canonical coordinates")
+            lowers.append(lo); lengths.append(length); widths.append(max(1, (length - 1).bit_length()))
+        shifts, total = [0] * len(plans), 0
+        for i in range(len(plans) - 1, -1, -1):
+            shifts[i] = total; total += widths[i]
+        return cls(tuple(targets), tuple(lowers), tuple(lengths), tuple(widths), tuple(shifts),
+                   total, plans[0].data_width, bits, radius)
+
+    @property
+    def record_bits(self):
+        return self.key_width + 2 * self.data_width
+
+    @property
+    def volume(self):
+        result = 1
+        for length in self.lengths:
+            result *= length
+        return result
+
+    def key(self, offsets):
+        M.need(len(offsets) == len(self.lengths), "complete coordinate tuple")
+        key = 0
+        for offset, length, shift in zip(offsets, self.lengths, self.field_shifts):
+            M.need(type(offset) is int and 0 <= offset < length, "local coordinate range")
+            key += offset << shift
+        return key
+
+    def coordinate(self, key, axis):
+        return (key >> self.field_shifts[axis]) & ((1 << self.field_widths[axis]) - 1)
+
+    def without_axis(self, key, axis):
+        mask = ((1 << self.field_widths[axis]) - 1) << self.field_shifts[axis]
+        return key & ~mask
+
+
+def put_record(tape, key, value, layout):
+    put_unsigned(tape, key, layout.key_width)
+    M.put_complex(tape, value, layout.data_width)
+
+
+def get_record(tape, layout):
+    return get_unsigned(tape, layout.key_width), M.get_complex(tape, layout.data_width)
+
+
+def coordinate_odometer(lengths):
+    """Metadata convenience; encoded carries are explicitly charged in proof."""
+    coordinate = [0] * len(lengths)
+    while True:
+        yield tuple(coordinate)
+        axis = len(lengths) - 1
+        while axis >= 0 and coordinate[axis] + 1 == lengths[axis]:
+            coordinate[axis] = 0; axis -= 1
+        if axis < 0:
+            return
+        coordinate[axis] += 1
+
+
+def rectangle_input(layout, values, bill, tape=None):
+    """Charged codec from lexicographic payload stream, no indexed data lookup."""
+    tape = tape if tape is not None else M.Tape(bill, "rectangle current")
+    M.need(tape.head == 0 and tape.live_bits == 0 and not tape.readonly, "blank reusable rectangle role")
+    tape.bill = bill
+    stream = iter(values)
+    for offsets in coordinate_odometer(layout.lengths):
+        try:
+            value = next(stream)
+        except StopIteration as error:
+            raise ValueError("incomplete saved rectangle") from error
+        M.need(type(value) is tuple and len(value) == 2 and all(type(x) is int for x in value)
+               and abs(value[0]) + abs(value[1]) <= layout.radius * (1 << layout.bits),
+               "saved rectangle data/radius")
+        put_record(tape, layout.key(offsets), value, layout)
+        bill.control_steps += len(layout.lengths) + 1
+    try:
+        next(stream)
+    except StopIteration:
+        pass
+    else:
+        raise ValueError("extra saved rectangle payload")
+    tape.rewind()
+    return tape
+
+
+def expose_axis(current, count, axis, layout, buckets, bill):
+    """Stable LSD distribution into two fixed buckets, then full concatenation."""
+    M.need(current.head == 0 and not current.readonly, "owned rectangle origin")
+    M.need(current.live_bits == count * layout.record_bits, "complete sparse body")
+    order = (axis,) + tuple(j for j in range(len(layout.lengths) - 1, -1, -1) if j != axis)
+    passes = 0
+    for field in order:
+        for bit in range(layout.field_widths[field]):
+            M.need(all(t.head == 0 and t.live_bits == 0 for t in buckets),
+                   "blank fixed radix buckets")
+            sizes = [0, 0]
+            position = layout.field_shifts[field] + bit
+            for _ in range(count):
+                key, value = get_record(current, layout)
+                destination = (key >> position) & 1
+                put_record(buckets[destination], key, value, layout)
+                sizes[destination] += 1
+                bill.control_steps += 1
+            current.clear()
+            for bucket, size in zip(buckets, sizes):
+                bucket.rewind()
+                for _ in range(size):
+                    key, value = get_record(bucket, layout)
+                    put_record(current, key, value, layout)
+                    bill.control_steps += 1
+                bucket.clear()
+            current.rewind(); passes += 1
+    return passes
+
+
+@dataclass(frozen=True)
+class TensorOutput:
+    tape: M.Tape
+    count: int
+    layout: Layout
+    role_extents: tuple
+    axis_receipts: tuple
+    blank_roles: tuple
+
+
+@dataclass(frozen=True)
+class TensorWorkspace:
+    rectangles: tuple
+    buckets: tuple
+    line_source: M.Tape
+    iterates: tuple
+    page: M.Tape
+
+    @classmethod
+    def create(cls, bill, first_rectangle=None):
+        first = first_rectangle if first_rectangle is not None else M.Tape(bill, "rectangle current")
+        return cls((first, M.Tape(bill, "rectangle next")),
+                   (M.Tape(bill, "radix zero"), M.Tape(bill, "radix one")),
+                   M.Tape(bill, "fixed borrowed line"),
+                   (M.Tape(bill, "fixed iterate zero"), M.Tape(bill, "fixed iterate one")),
+                   M.Tape(bill, "fixed local band page"))
+
+    @property
+    def roles(self):
+        return self.rectangles + self.buckets + (self.line_source,) + self.iterates + (self.page,)
+
+
+def apply_tensor(archive, targets, source, bill, workspace=None):
+    """Consume one saved rectangle; return its complete target in lex order.
+
+    There are eight local tape roles, independent of axis count and iteration
+    count, plus the one protected global archive and bounded scalar/control
+    tapes. No source/table preparation is repeated inside a spectator line.
+    """
+    layout = Layout.make(archive.plans, targets)
+    M.need(source.head == 0 and not source.readonly
+           and source.live_bits == layout.volume * layout.record_bits, "owned complete rectangle")
+    pool = workspace if workspace is not None else TensorWorkspace.create(bill, source)
+    roles = pool.roles
+    M.need(len({id(t) for t in roles}) == 8 and any(t is source for t in pool.rectangles),
+           "eight distinct fixed roles with designated input")
+    M.need(all(t is source or (t.head == 0 and t.live_bits == 0 and not t.readonly) for t in roles),
+           "all noninput fixed roles blank and reusable")
+    for tape in roles:
+        tape.bill = bill
+    current = source
+    following = pool.rectangles[1] if source is pool.rectangles[0] else pool.rectangles[0]
+    buckets, line_source, iterates, page_tape = pool.buckets, pool.line_source, pool.iterates, pool.page
+    count = layout.volume
+    receipts = []
+    for axis, p in enumerate(archive.plans):
+        start_products, start_scans = bill.products, bill.page_scans
+        page = archive_page(archive, axis, layout.lowers[axis], layout.lengths[axis], page_tape, bill)
+        passes = expose_axis(current, count, axis, layout, buckets, bill)
+        line_length = layout.lengths[axis]
+        M.need(count % line_length == 0, "complete spectator lines")
+        lines = count // line_length
+        target_lower, target_length = layout.targets[axis]
+        previous_spectator = -1
+        for _ in range(lines):
+            spectator = None
+            for position in range(line_length):
+                key, value = get_record(current, layout)
+                other = layout.without_axis(key, axis)
+                if spectator is None:
+                    spectator = other
+                    M.need(spectator > previous_spectator, "unique ordered spectator line")
+                    previous_spectator = spectator
+                M.need(other == spectator and layout.coordinate(key, axis) == position,
+                       "full ordered local dependency line")
+                M.put_complex(line_source, value, p.data_width)
+                bill.control_steps += len(layout.lengths) + 1
+            line_source.rewind(); line_source.readonly = True
+            output = M.apply_line(page, line_source, target_lower, target_length, bill,
+                                  workspace=iterates)
+            for offset in range(target_length):
+                value = M.get_complex(output.tape, p.data_width)
+                coordinate = target_lower - layout.lowers[axis] + offset
+                key = spectator | (coordinate << layout.field_shifts[axis])
+                put_record(following, key, value, layout)
+                bill.control_steps += len(layout.lengths) + 1
+            output.tape.clear()
+            line_source.readonly = False; line_source.clear()
+        current.clear(); following.rewind()
+        current, following = following, current
+        page_tape.readonly = False; page_tape.clear()
+        count = lines * target_length
+        M.need(current.live_bits == count * layout.record_bits, "exact next tensor rectangle")
+        receipts.append(dict(axis=axis, input_lines=lines, line_length=line_length,
+                             target_length=target_length, radix_passes=passes,
+                             page_scans=bill.page_scans - start_scans,
+                             products=bill.products - start_products, output_records=count))
+    blank = tuple(t for t in roles if t is not current)
+    M.need(all(t.head == 0 and t.live_bits == 0 for t in blank),
+           "all nonreturn fixed roles erased")
+    M.need(current.head == archive.tape.head == 0, "tensor/archive return origins")
+    return TensorOutput(current, count, layout,
+                        tuple((t.name, t.extent) for t in roles), tuple(receipts), blank)
+
+
+def consume_tensor(output):
+    """Return lifted coordinates, payloads; consume and clear the live output."""
+    layout = output.layout
+    result = []
+    previous = -1
+    for _ in range(output.count):
+        key, value = get_record(output.tape, layout)
+        M.need(key > previous, "unique lexicographic target key")
+        previous = key
+        coordinates = tuple(layout.lowers[i] + layout.coordinate(key, i)
+                            for i in range(len(layout.lengths)))
+        M.need(all(lo <= x < lo + length for x, (lo, length) in zip(coordinates, layout.targets)),
+               "target-only tensor output")
+        result.append((coordinates, value))
+    output.tape.clear()
+    M.need(output.tape.head == 0 and output.tape.live_bits == 0, "tensor return cleanup")
+    return tuple(result)
diff --git a/research/shrinking-reference-halo/verify.py b/research/shrinking-reference-halo/verify.py
new file mode 100644
index 0000000000..bde34700a9
--- /dev/null
+++ b/research/shrinking-reference-halo/verify.py
@@ -0,0 +1,554 @@
+"""Exact, read-only normal/optimized corroboration of the scoped theorem.
+
+Prepared for @CubeJerry with substantial OpenAI Codex assistance. Apache-2.0.
+The dense polynomial oracle forms separate powers, not the online recurrence.
+"""
+import argparse
+from dataclasses import replace
+from fractions import Fraction as Q
+from hashlib import sha256
+import importlib.util
+import itertools
+import json
+from pathlib import Path
+import random
+import sys
+import types
+
+PACKAGE = Path(__file__).resolve().parent
+
+
+def load_local(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+M = load_local("shrinking_halo_engine", PACKAGE / "engine.py")
+S = load_local("shrinking_halo_source", PACKAGE / "source.py")
+T = load_local("shrinking_halo_tensor", PACKAGE / "tensor.py")
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def rejected(function, label):
+    try:
+        function()
+    except (ValueError, IndexError):
+        return label
+    raise ValueError("negative control accepted: " + label)
+
+
+def pair_norm(value):
+    return abs(value[0]) + abs(value[1])
+
+
+def dense_polynomial(matrix, data, terms, normalizer):
+    """Independent exact mechanism: explicit successive powers and sum."""
+    n = len(data)
+    power = tuple((Q(z[0]), Q(z[1])) for z in data)
+    total = [list(z) for z in power]
+    for _ in range(1, terms):
+        following = []
+        for row in range(n):
+            following.append(tuple(sum((matrix[row][column] * power[column][part]
+                                        for column in range(n)), Q(0))
+                                   for part in (0, 1)))
+        power = tuple(following)
+        for row in range(n):
+            for part in (0, 1):
+                total[row][part] += power[row][part]
+    return tuple(tuple(value / normalizer for value in z) for z in total)
+
+
+def rounded_global(matrix, data, plan):
+    """Full-period host comparator, solely to verify exact rounded conformance."""
+    n, scale = len(data), 1 << plan.bits
+    coefficients = [[M.inward(value, plan.bits) for value in row] for row in matrix]
+    current = [(0, 0)] * n
+    for _ in range(plan.terms):
+        current = [tuple(M.trunc((data[row][part] << (plan.bits - plan.normalizer_shift))
+                               + sum(coefficients[row][column] * current[column][part]
+                                     for column in range(n)), scale)
+                         for part in (0, 1)) for row in range(n)]
+    return tuple(current)
+
+
+def run_line(matrix, data, plan, lower, length, engine=M, table=None, bill=None):
+    bill = bill or engine.Bill()
+    table = table or engine.prepare_table(plan, lambda r, c: matrix[r][c], "finite exact E", bill)[0]
+    before_table = engine.tape_digest(table.tape)
+    saved_lower, saved_length = lower - plan.halo, length + 2 * plan.halo
+    page = engine.extract_page(table, saved_lower, saved_length, bill)
+    values = tuple(data[row % plan.period] for row in range(saved_lower, saved_lower + saved_length))
+    source = engine.input_tape(plan, values, bill)
+    before_source, before_page = engine.tape_digest(source), engine.tape_digest(page.tape)
+    output = engine.apply_line(page, source, lower, length, bill)
+    require(output.tape.head == 0 and output.length == length, "owned exact output extent")
+    physical_extents = (source.extent, page.tape.extent, output.tape.extent,
+                        sum(t.extent for t in output.blank_scratch))
+    actual = engine.consume(output)
+    require(before_source == engine.tape_digest(source) and source.head == 0,
+            "borrowed input bytes/origin")
+    require(before_page == engine.tape_digest(page.tape) and page.tape.head == 0,
+            "borrowed page bytes/origin")
+    require(before_table == engine.tape_digest(table.tape) and table.tape.head == 0,
+            "global table bytes/origin")
+    require(all(t.head == 0 and not any(t.snapshot()) for t in output.blank_scratch),
+            "alternate backing cleanup")
+    expected = rounded_global(matrix, data, plan)
+    require(actual == tuple(expected[row % plan.period] for row in range(lower, lower + length)),
+            "exact full-period rounded conformance")
+    rational_data = tuple(tuple(Q(v, 1 << plan.bits) for v in z) for z in data)
+    exact = dense_polynomial(matrix, rational_data, plan.terms, 1 << plan.normalizer_shift)
+    error = max(pair_norm(tuple(Q(actual[j][part], 1 << plan.bits) -
+                               exact[(lower + j) % plan.period][part] for part in (0, 1)))
+                for j in range(length))
+    require(error <= plan.numeric_error, "proved coefficient/data bound")
+    n0 = saved_length
+    output_counts = [length + 2 * (plan.terms - k) * plan.halfwidth
+                     for k in range(2, plan.terms + 1)]
+    expected_products = 2 * plan.band * sum(output_counts)
+    expected_roundings = 2 * (n0 + sum(output_counts))
+    require(bill.products == expected_products, "complete multiply invoice")
+    require(bill.additions == expected_products, "complete accumulation invoice")
+    require(bill.roundings == expected_roundings, "all completed data roundings")
+    return actual, error, bill, physical_extents
+
+
+def matrix_cases():
+    rng = random.Random(72)
+    cases = []
+    for case in range(32):
+        width = 1 + case % 2
+        terms = 1 + case % 4
+        n = 2 * (terms - 1) * width + 15 + case % 5
+        gap = Q(1 + case % 3, 8)
+        bits = 9 + case % 4
+        shift = 0
+        while (1 << shift) * gap < 1:
+            shift += 1
+        plan = M.Plan(n, width, bits, terms, shift, gap)
+        matrix = [[Q(0) for _ in range(n)] for _ in range(n)]
+        holes = {n // 2}
+        for row in range(n):
+            if row in holes:
+                continue
+            support = [((row + offset) % n, rng.choice((-1, 1)), rng.randint(1, 7))
+                       for offset in range(-width, width + 1)
+                       if offset and (row + offset) % n not in holes]
+            denominator = sum(weight for _, _, weight in support)
+            for column, sign, weight in support:
+                matrix[row][column] = sign * (1 - gap) * Q(weight, denominator)
+        data = []
+        for _ in range(n):
+            real = rng.randint(-(1 << bits), 1 << bits)
+            imag = rng.randint(-((1 << bits) - abs(real)), (1 << bits) - abs(real))
+            data.append((real, imag))
+        lower = (-2, n - 3, n // 2 - 1, 1)[case % 4]
+        cases.append((matrix, tuple(data), plan, lower, 3))
+    return cases
+
+
+def finite_cases():
+    receipts, nonzero_errors = [], 0
+    for matrix, data, plan, lower, length in matrix_cases():
+        output, error, bill, extents = run_line(matrix, data, plan, lower, length)
+        nonzero_errors += int(error > 0)
+        receipts.append(dict(period=plan.period, width=plan.halfwidth, terms=plan.terms,
+                             bits=plan.bits, lower=lower, length=length, gap=str(plan.gap),
+                             output=list(output), nonzero_error=error > 0,
+                             bill=bill.record(), resident_extents=list(extents)))
+    require(nonzero_errors >= 24, "nontrivial rounding fixtures")
+    return receipts, nonzero_errors
+
+
+def tensor_oracle(matrices, plans, data, rounded):
+    """Full canonical tensor, including coordinates outside every local box."""
+    sizes = tuple(p.period for p in plans)
+    current = dict(data)
+    if not rounded:
+        current = {key: tuple(Q(v, 1 << plans[0].bits) for v in z)
+                   for key, z in current.items()}
+    for axis, (matrix, plan) in enumerate(zip(matrices, plans)):
+        following = {}
+        others = tuple(i for i in range(len(plans)) if i != axis)
+        for spectator in itertools.product(*(range(sizes[i]) for i in others)):
+            keys = []
+            for coordinate in range(sizes[axis]):
+                key, other = [], 0
+                for i in range(len(plans)):
+                    if i == axis:
+                        key.append(coordinate)
+                    else:
+                        key.append(spectator[other]); other += 1
+                keys.append(tuple(key))
+            line = tuple(current[key] for key in keys)
+            values = rounded_global(matrix, line, plan) if rounded else dense_polynomial(
+                matrix, line, plan.terms, 1 << plan.normalizer_shift)
+            following.update(zip(keys, values))
+        current = following
+    return current
+
+
+def tensor_case(matrices, plans, targets, label, tensor_module=T, entry_services=None, source_ids=None):
+    bill = M.Bill()
+    def prepared():
+        for axis, (matrix, plan) in enumerate(zip(matrices, plans)):
+            entry = entry_services[axis] if entry_services is not None else (
+                lambda r, c, matrix=matrix: matrix[r][c])
+            source_id = source_ids[axis] if source_ids is not None else label + "/axis/" + str(axis)
+            yield M.prepare_table(plan, entry, source_id, bill)[0]
+    archive = T.pack_tables(prepared(), bill)
+    archive_before = M.tape_digest(archive.tape)
+    layout = T.Layout.make(plans, targets)
+    scale = 1 << plans[0].bits
+    full_data = {}
+    for key in itertools.product(*(range(p.period) for p in plans)):
+        code = sum((i + 3) * (x + 1) ** 2 for i, x in enumerate(key))
+        real = (code * 173 % (scale // 2)) - scale // 4
+        imag = (code * 97 % (scale // 3)) - scale // 6
+        full_data[key] = real, imag
+    def local_values():
+        for offsets in T.coordinate_odometer(layout.lengths):
+            canonical = tuple((lo + x) % p.period for lo, x, p in zip(layout.lowers, offsets, plans))
+            yield full_data[canonical]
+    source = T.rectangle_input(layout, local_values(), bill)
+    start_products, start_scans = bill.products, bill.page_scans
+    output = tensor_module.apply_tensor(archive, targets, source, bill)
+    values = tensor_module.consume_tensor(output)
+    require(archive_before == M.tape_digest(archive.tape) and archive.tape.head == 0,
+            "tensor preserves global source archive")
+    exact = tensor_oracle(matrices, plans, full_data, rounded=False)
+    rounded = tensor_oracle(matrices, plans, full_data, rounded=True)
+    errors = []
+    for key, value in values:
+        canonical = tuple(x % p.period for x, p in zip(key, plans))
+        require(value == rounded[canonical], "full rounded tensor equality")
+        errors.append(pair_norm(tuple(Q(value[part], scale) - exact[canonical][part]
+                                      for part in (0, 1))))
+    error = max(errors)
+    require(error <= sum(p.numeric_error for p in plans), "complete normalized tensor bound")
+    require(error > 0, "nonzero tensor rounding defect")
+    expected_count = 1
+    for _, length in targets:
+        expected_count *= length
+    require(len(values) == expected_count, "complete target tensor")
+    require(len(output.role_extents) == 8, "fixed local physical role count")
+    products, scans, live_count = 0, 0, layout.volume
+    for axis, (plan, target, receipt) in enumerate(zip(plans, targets, output.axis_receipts)):
+        lines = live_count // layout.lengths[axis]
+        n = target[1]
+        per_line = 2 * plan.band * ((plan.terms - 1) * n +
+                                  plan.halfwidth * (plan.terms - 1) * (plan.terms - 2))
+        require(receipt["products"] == lines * per_line, "tensor complete product invoice")
+        expected_scans = 1 + int((layout.lowers[axis] % plan.period) + layout.lengths[axis] > plan.period)
+        require(receipt["page_scans"] == expected_scans, "one page production per axis, not per line")
+        require(receipt["radix_passes"] == layout.key_width, "complete sparse radix exposure")
+        products += lines * per_line; scans += expected_scans
+        live_count = lines * n
+    require(bill.products - start_products == products and bill.page_scans - start_scans == scans,
+            "complete tensor invoice totals")
+    return dict(label=label, dimensions=len(plans), saved_lengths=list(layout.lengths),
+                copied_records=layout.volume, target_records=len(values),
+                key_width=layout.key_width, fixed_local_tape_roles=8,
+                role_extents=list(output.role_extents), total_retained_local_bits=sum(n for _, n in output.role_extents),
+                protected_archive_bits=archive.tape.extent, axis_receipts=list(output.axis_receipts),
+                output=list(values), numerical_bound=str(sum(p.numeric_error for p in plans)),
+                nonzero_error=True, bill=bill.record())
+
+
+def synthetic_tensors(tensor_module=T):
+    result = []
+    for dimensions in (2, 3):
+        matrices, plans, targets = [], [], []
+        for axis in range(dimensions):
+            n, width, terms = 11, 1, 2 + axis % 2
+            gap = Q(axis + 2, 8)
+            plan = M.Plan(n, width, 10, terms, 2, gap)
+            matrix = [[Q(0) for _ in range(n)] for _ in range(n)]
+            for row in range(n):
+                if row == n // 2:
+                    continue
+                for offset in (-1, 1):
+                    column = (row + offset) % n
+                    if column != n // 2:
+                        matrix[row][column] = (-1 if (row + axis + offset) % 2 else 1) * (1 - gap) / 2
+            matrices.append(matrix); plans.append(plan)
+            targets.append((-1 if axis % 2 == 0 else n - 2, 2))
+        result.append(tensor_case(tuple(matrices), tuple(plans), tuple(targets),
+                                 "signed-" + str(dimensions) + "d", tensor_module))
+    return result
+
+
+def reuse_history(engine=M):
+    """Long line, short face, long line on exactly the same physical roles."""
+    bill = engine.Bill()
+    plan = engine.Plan(101, 1, 12, 3, 1, Q(1, 2))
+    matrix = [[Q(1, 4) if (c-r) % 101 in (1, 100) else Q(0)
+               for c in range(101)] for r in range(101)]
+    data = tuple(((r * 73) % 2048 - 1024, (r * 31) % 1024 - 512) for r in range(101))
+    table, _ = engine.prepare_table(plan, lambda r, c: matrix[r][c], "reused source", bill)
+    page_role = engine.Tape(bill, "reused page")
+    source_role = engine.Tape(bill, "reused source")
+    iterates = (engine.Tape(bill, "reused iterate 0"), engine.Tape(bill, "reused iterate 1"))
+    records = []
+    exact = rounded_global(matrix, data, plan)
+    for lower, length in ((2, 37), (50, 1), (70, 37)):
+        before = bill.record()
+        page = engine.extract_page(table, lower-plan.halo, length+2*plan.halo, bill, page_role)
+        for row in range(lower-plan.halo, lower+length+plan.halo):
+            engine.put_complex(source_role, data[row % 101], plan.data_width)
+        source_role.rewind(); source_role.readonly = True
+        output = engine.apply_line(page, source_role, lower, length, bill, workspace=iterates)
+        values = engine.consume(output)
+        require(values == tuple(exact[r % 101] for r in range(lower, lower+length)),
+                "long-short-long exact returned values")
+        source_role.readonly = False; source_role.clear()
+        page_role.readonly = False; page_role.clear()
+        roles = (source_role, page_role) + iterates
+        require(all(t.head == 0 and t.live_bits == 0 and not any(t.snapshot()) for t in roles),
+                "long-short-long retained blank suffix invariant")
+        after = bill.record()
+        records.append(dict(target_length=length, saved_length=length+2*plan.halo,
+                            output=list(values), retained_bits=sum(t.extent for t in roles),
+                            writes=after["writes"]-before["writes"],
+                            moves=after["moves"]-before["moves"]))
+    return records
+
+
+def backing_history_control():
+    correct = reuse_history()
+    text = (PACKAGE / "engine.py").read_text()
+    require(text.count("occupied = self.live_bits") == 1, "unique historical clear site")
+    module = types.ModuleType("_shrinking_counterfactual_highwater")
+    sys.modules[module.__name__] = module
+    exec(compile(text.replace("occupied = self.live_bits", "occupied = self.extent"),
+                 "<counterfactual high-water clearing>", "exec"), module.__dict__)
+    counterfactual = reuse_history(module)
+    require([x["output"] for x in correct] == [x["output"] for x in counterfactual],
+            "counterfactual preserves numerical result")
+    require(counterfactual[1]["writes"] > 3 * correct[1]["writes"],
+            "historical backing creates a real short-face tariff")
+    return dict(correct=correct, counterfactual=counterfactual,
+                retained_extent_ratio="41/5", counterfactual_detected=True)
+
+
+def rectangle_reuse_history():
+    bill = M.Bill()
+    plans = (M.Plan(17, 1, 10, 2, 1, Q(3, 4)), M.Plan(17, 1, 10, 3, 1, Q(7, 8)))
+    matrices = tuple([[Q((1 if axis == 0 else -1), 8 << axis)
+                        if (c-r) % 17 in (1, 16) and r != 8 and c != 8 else Q(0)
+                       for c in range(17)] for r in range(17)] for axis in range(2))
+    def prepared():
+        for axis, plan in enumerate(plans):
+            yield M.prepare_table(plan, lambda r, c, axis=axis: matrices[axis][r][c],
+                                  "rectangle reuse axis " + str(axis), bill)[0]
+    archive = T.pack_tables(prepared(), bill)
+    workspace = T.TensorWorkspace.create(bill)
+    role_ids = {id(t) for t in workspace.roles}
+    data = {key: ((13*key[0]+29*key[1]) % 512-256, (31*key[0]+7*key[1]) % 256-128)
+            for key in itertools.product(range(17), repeat=2)}
+    expected = tensor_oracle(matrices, plans, data, rounded=True)
+    history = []
+    original_constructor = M.Tape.__init__
+    def forbidden_constructor(*args, **kwargs):
+        raise ValueError("new tape role inside rectangle reuse history")
+    M.Tape.__init__ = forbidden_constructor
+    try:
+        for targets in (((-1, 7), (4, 5)), ((8, 1), (-1, 2)), ((1, 5), (9, 7))):
+            layout = T.Layout.make(plans, targets)
+            values = (data[tuple((lo+x) % 17 for lo, x in zip(layout.lowers, offsets))]
+                      for offsets in T.coordinate_odometer(layout.lengths))
+            before = bill.record()
+            source = T.rectangle_input(layout, values, bill, workspace.rectangles[0])
+            output = T.apply_tensor(archive, targets, source, bill, workspace=workspace)
+            require({id(output.tape)} | {id(t) for t in output.blank_roles} == role_ids,
+                    "same eight roles across completed rectangles")
+            answer = T.consume_tensor(output)
+            require(all(value == expected[tuple(x % 17 for x in key)] for key, value in answer),
+                    "long-short-long rectangle exact output")
+            require(all(t.head == 0 and t.live_bits == 0 and not any(t.snapshot())
+                        for t in workspace.roles), "reused rectangle complete restoration")
+            after = bill.record()
+            history.append(dict(saved_lengths=list(layout.lengths), copied_records=layout.volume,
+                                target_records=len(answer), output=list(answer),
+                                retained_bits=sum(t.extent for t in workspace.roles),
+                                writes=after["writes"]-before["writes"],
+                                moves=after["moves"]-before["moves"],
+                                archive_scans=after["page_scans"]-before["page_scans"]))
+    finally:
+        M.Tape.__init__ = original_constructor
+    return dict(fixed_role_count=8, constructors_sealed_during_calls=True, history=history)
+
+
+def gaussian_cases(raw):
+    reference = S.make_reference(raw, (32, 8, 2, 1, 8, 32))
+    reference.require_narrow_gap()
+    gap = Q((reference.narrow_gap * (1 << 16)).numerator //
+            (reference.narrow_gap * (1 << 16)).denominator, 1 << 16)
+    shift = 0
+    while (1 << shift) * gap < 1:
+        shift += 1
+    plan = M.Plan(reference.target_size, 2 * reference.spec.source_halfwidth + 2,
+                  28, 4, shift, gap)
+    require(plan.numeric_error + plan.tail_error < Q(1, 1 << 20),
+            "uniform same-reference inverse target")
+    prep_bill = M.Bill()
+    table, height = M.prepare_table(plan, lambda r, c: S.source_entry(reference, r, c),
+                                   reference.description_hash, prep_bill)
+    setup = S.source_receipt(reference)
+    setup["band_source_calls"] = prep_bill.setup_entries
+    setup["stored_coefficient_height"] = height
+    setup["table_bits"] = table.tape.extent
+    setup["production_bill"] = prep_bill.record()
+    # All original source entries, not just the producer's asserted band.
+    matrix = [[S.source_entry(reference, r, c) for c in range(plan.period)]
+              for r in range(plan.period)]
+    omissions, wrap_entries = 0, 0
+    holes = tuple(reference.holes)
+    for r in range(plan.period):
+        for c in range(plan.period):
+            distance = min((r - c) % plan.period, (c - r) % plan.period)
+            if distance > plan.halfwidth:
+                require(matrix[r][c] == 0, "actual complete off-band support")
+                omissions += 1
+            if abs(r - c) > plan.period // 2 and matrix[r][c]:
+                wrap_entries += 1
+            if r in holes or c in holes:
+                require(matrix[r][c] == 0, "actual identity holes")
+    require(wrap_entries > 0 and holes, "actual wrap and holes exercised")
+    scale = 1 << plan.bits
+    data = tuple(((1 if r % 3 else -1) * (scale // 3 + 17 * r),
+                  (-1 if r % 2 else 1) * (scale // 7 - 11 * r))
+                 for r in range(plan.period))
+    receipts = []
+    for lower in (-2, 5, 18):
+        output, error, bill, extents = run_line(matrix, data, plan, lower, 5,
+                                               table=table, bill=M.Bill())
+        require(error > 0, "actual source nonzero numerical error")
+        receipts.append(dict(lower=lower, output=list(output), bill=bill.record(),
+                             resident_extents=list(extents), nonzero_error=True))
+    # An executed wrong branch: suppress genuine across-period E entries.
+    dropped = [[Q(0) if abs(r - c) > plan.period // 2 else matrix[r][c]
+                for c in range(plan.period)] for r in range(plan.period)]
+    wrong, _, _, _ = run_line(dropped, data, plan, -2, 5)
+    require(wrong != tuple(map(tuple, receipts[0]["output"])), "dropped-wrap control discriminates")
+    # Fresh retained producers, not the dense checker's indexed matrix, supply
+    # both actual tensor band tables. They share the same immutable spec.
+    producer_reference = S.make_reference(raw, (32, 8, 2, 1, 8, 32))
+    producer = lambda r, c: S.source_entry(producer_reference, r, c)
+    tensor = tensor_case((matrix, matrix), (plan, plan), ((-1, 4), (5, 3)), "actual-reference-2d",
+                         entry_services=(producer, producer),
+                         source_ids=(producer_reference.description_hash,) * 2)
+    tensor["source_setup"] = S.source_receipt(producer_reference)
+    S.clear_reference(producer_reference)
+    S.clear_reference(reference)
+    require(not reference.entries and not reference.weights and not reference.kernel,
+            "setup cache release")
+    return dict(setup=setup, period=plan.period, gap=str(gap), holes=list(holes),
+                original_matrix_entries=plan.period ** 2, checked_off_band_entries=omissions,
+                nonzero_wrap_entries=wrap_entries, target_bits=20,
+                numerical_bound=str(plan.numeric_error), tail_bound=str(plan.tail_error),
+                lines=receipts, tensor=tensor, dropped_wrap_detected=True)
+
+
+def negative_controls():
+    controls = []
+    p = M.Plan(29, 1, 10, 3, 3, Q(1, 8))
+    controls.append(rejected(lambda: replace(p, normalizer_shift=2), "unfunded normalization"))
+    controls.append(rejected(lambda: replace(p, bits=2), "lost normalized-source precision"))
+    controls.append(rejected(lambda: replace(p, halfwidth=15), "nonunique cyclic offsets"))
+    controls.append(rejected(lambda: replace(p, gap=0), "missing contraction gap"))
+    controls.append(rejected(lambda: M.prepare_table(p, lambda r, c: Q(1, 2),
+                                                     "invalid row", M.Bill()), "bad original row gap"))
+    controls.append(rejected(lambda: M.input_tape(p, ((1024, 1),), M.Bill()), "oversized actual input"))
+    table, _ = M.prepare_table(p, lambda r, c: Q(1, 4) if c == (r + 1) % p.period else Q(0),
+                              "control", M.Bill())
+    controls.append(rejected(lambda: M.extract_page(table, 0, p.period, M.Bill()),
+                             "repeated canonical page coordinate"))
+    page = M.extract_page(table, 0, 7, M.Bill())
+    source = M.input_tape(p, ((100, -100),) * 7, M.Bill())
+    controls.append(rejected(lambda: page.tape.write(1), "immutable coefficient page"))
+    controls.append(rejected(lambda: source.write(1), "immutable fixed source"))
+    controls.append(rejected(lambda: M.apply_line(page, source, 3, 3, M.Bill()),
+                             "prematurely cropped dependency interval"))
+    bad = M.input_tape(p, ((0, 0),) * 7, M.Bill())
+    bad.readonly = False; bad.write(1); bad.rewind(); bad.readonly = True
+    controls.append(rejected(lambda: M.apply_line(page, bad, 2, 3, M.Bill()),
+                             "noncanonical negative zero"))
+    # Real source-text changes of the consumer, tested against the independent oracle.
+    text = (PACKAGE / "engine.py").read_text()
+    mutations = [
+        ("real += product_real; imag += product_imag", "real -= product_real; imag -= product_imag", "wrong recurrence sign"),
+        ("current.walk(-2 * p.halfwidth * record_bits)", "current.walk(-(2 * p.halfwidth + 1) * record_bits)", "wrong neighbor rewind"),
+        ("current.clear(); following.rewind()", "current.rewind(); following.rewind()", "missing scratch erasure"),
+    ]
+    case = matrix_cases()[3]
+    for old, new, name in mutations:
+        require(text.count(old) == 1, "unique mutation site")
+        module = types.ModuleType("_shrinking_mutation_" + str(len(controls)))
+        sys.modules[module.__name__] = module
+        exec(compile(text.replace(old, new), "<intentional negative control>", "exec"), module.__dict__)
+        # Reconstruct the plan in the mutated module; other data stay exact.
+        matrix, data, p0, lower, length = case
+        pp = module.Plan(**p0.__dict__)
+        controls.append(rejected(lambda: run_line(matrix, data, pp, lower, length, module), name))
+    tensor_text = (PACKAGE / "tensor.py").read_text()
+    for old, new, name in [
+        ("order = (axis,) + tuple(j for j in range(len(layout.lengths) - 1, -1, -1) if j != axis)",
+         "order = tuple(range(len(layout.lengths)))", "wrong sparse axis exposure"),
+        ("emit = catalog_axis == axis and begin <= row < end",
+         "emit = catalog_axis == 0 and begin <= row < end", "stale axis coefficient page"),
+        ("coordinate = target_lower - layout.lowers[axis] + offset",
+         "coordinate = target_lower - layout.lowers[axis] + offset + 1", "shifted returned tensor key"),
+    ]:
+        require(tensor_text.count(old) == 1, "unique tensor mutation site")
+        module = types.ModuleType("_shrinking_tensor_mutation_" + str(len(controls)))
+        sys.modules[module.__name__] = module
+        exec(compile(tensor_text.replace(old, new), "<intentional tensor control>", "exec"), module.__dict__)
+        controls.append(rejected(lambda: synthetic_tensors(module), name))
+    return controls
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--write-receipt", action="store_true")
+    args = parser.parse_args()
+    raw = S.authenticated_inputs(PACKAGE)
+    finite, nonzero = finite_cases()
+    tensors = synthetic_tensors()
+    gaussian = gaussian_cases(raw)
+    controls = negative_controls()
+    history = backing_history_control()
+    rectangle_history = rectangle_reuse_history()
+    result = dict(schema_version=1, seed=72, claim="scoped written proof and finite tape corroboration",
+                  no_new_kappa=True, finite_lines=len(finite), finite_target_outputs=3 * len(finite),
+                  nonzero_rounding_lines=nonzero, finite=finite, tensors=tensors, gaussian=gaussian,
+                  controls=controls, control_count=len(controls),
+                  backing_reuse=history, rectangle_reuse=rectangle_history,
+                  program_sha256={name: sha256((PACKAGE/name).read_bytes()).hexdigest()
+                                  for name in ("engine.py", "source.py", "tensor.py", "verify.py")},
+                  source_sha256={path: sha256(content).hexdigest() for path, content in sorted(raw.items())})
+    encoded = json.dumps(result, sort_keys=True, indent=2) + "\n"
+    receipt = PACKAGE / "RESULT.json"
+    if args.write_receipt:
+        receipt.write_text(encoded)
+    else:
+        require(receipt.is_file(), "mandatory exact receipt")
+        # Canonical serialization distinguishes booleans from integers recursively.
+        require(json.dumps(json.loads(receipt.read_text()), sort_keys=True, separators=(",", ":")) ==
+                json.dumps(result, sort_keys=True, separators=(",", ":")), "exact typed receipt")
+    print("PASS_SHRINKING_REFERENCE_HALO " + json.dumps(
+        dict(finite_lines=len(finite), gaussian_rows=gaussian["period"],
+             controls=len(controls), source_entries=gaussian["original_matrix_entries"],
+             receipt_sha256=sha256(encoded.encode()).hexdigest(), no_new_kappa=True), sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/sparse-halo-tape-transaction/EXPECTED.json b/research/sparse-halo-tape-transaction/EXPECTED.json
new file mode 100644
index 0000000000..9b2fe8ab73
--- /dev/null
+++ b/research/sparse-halo-tape-transaction/EXPECTED.json
@@ -0,0 +1,159 @@
+{
+  "arithmetic_pairs": 1364,
+  "claim": "physical gather/sort/return only; numerical halo consumer is an explicit contract; no new kappa",
+  "controls": [
+    "missing_target",
+    "duplicate_target",
+    "kept_row_return",
+    "core_before_copy",
+    "return_before_core",
+    "nonunit_head_jump",
+    "reversed_bucket_order_detected",
+    "duplicate_key_stability",
+    "copy_after_core_detected",
+    "no_observer_call_in_program"
+  ],
+  "fixtures": [
+    {
+      "B": 5,
+      "C": 16,
+      "K": 14,
+      "M": 32,
+      "Q": 8,
+      "after_erase": {
+        "actions": 356848,
+        "moves": 141644,
+        "retained_cells": 2077,
+        "roles": 30
+      },
+      "before_erase": {
+        "actions": 350261,
+        "moves": 138849,
+        "retained_cells": 2077,
+        "roles": 30
+      },
+      "gather": {
+        "actions": 50995,
+        "moves": 19768,
+        "retained_cells": 970,
+        "roles": 30
+      },
+      "gather_and_sparse_sort": {
+        "actions": 296152,
+        "moves": 117816,
+        "retained_cells": 1776,
+        "roles": 30
+      },
+      "geometry": {
+        "P": 8,
+        "a": 2,
+        "b": 1,
+        "ell": 4,
+        "ks": [
+          1
+        ],
+        "spectator_width": 0
+      },
+      "maximum_fanout": 2,
+      "output_sha256": "37197df41278fb5df945780e0e7c928ff7e52bb29672b78faeb914ddc44d9339",
+      "zero_copy_sources": 20
+    },
+    {
+      "B": 10,
+      "C": 1024,
+      "K": 27,
+      "M": 1024,
+      "Q": 448,
+      "after_erase": {
+        "actions": 55924621,
+        "moves": 22322760,
+        "retained_cells": 124785,
+        "roles": 30
+      },
+      "before_erase": {
+        "actions": 55530902,
+        "moves": 22154055,
+        "retained_cells": 124785,
+        "roles": 30
+      },
+      "gather": {
+        "actions": 3764179,
+        "moves": 1479250,
+        "retained_cells": 56287,
+        "roles": 30
+      },
+      "gather_and_sparse_sort": {
+        "actions": 50076447,
+        "moves": 20004132,
+        "retained_cells": 115551,
+        "roles": 30
+      },
+      "geometry": {
+        "P": 8,
+        "a": 2,
+        "b": 1,
+        "ell": 4,
+        "ks": [
+          1,
+          1
+        ],
+        "spectator_width": 0
+      },
+      "maximum_fanout": 4,
+      "output_sha256": "86ee13722bf69bdc41109add08e1df31b8a99afcd81ef1f72bb7039fe8b00c32",
+      "zero_copy_sources": 400
+    },
+    {
+      "B": 10,
+      "C": 448,
+      "K": 27,
+      "M": 1024,
+      "Q": 448,
+      "after_erase": {
+        "actions": 28502162,
+        "moves": 11345158,
+        "retained_cells": 70305,
+        "roles": 30
+      },
+      "before_erase": {
+        "actions": 28257705,
+        "moves": 11240422,
+        "retained_cells": 70305,
+        "roles": 30
+      },
+      "gather": {
+        "actions": 2597732,
+        "moves": 1010032,
+        "retained_cells": 34959,
+        "roles": 30
+      },
+      "gather_and_sparse_sort": {
+        "actions": 22860400,
+        "moves": 9115074,
+        "retained_cells": 61071,
+        "roles": 30
+      },
+      "geometry": {
+        "P": 8,
+        "a": 1,
+        "b": 0,
+        "ell": 3,
+        "ks": [
+          1,
+          2
+        ],
+        "spectator_width": 1
+      },
+      "maximum_fanout": 1,
+      "output_sha256": "068ca865a3002e52455f2406829f94fbc4c56bf9cae91fc27ba44eb3581739e0",
+      "zero_copy_sources": 576
+    }
+  ],
+  "python": "3.12.14",
+  "source_bindings": [
+    "research/halo-copy-enumeration/README.md",
+    "research/unconditional-batched-crt/HALO.md",
+    "research/unconditional-batched-crt/GAUSSIAN.md"
+  ],
+  "status": "PASS"
+}
diff --git a/research/sparse-halo-tape-transaction/OVERLAP.json b/research/sparse-halo-tape-transaction/OVERLAP.json
new file mode 100644
index 0000000000..8d2268e0fa
--- /dev/null
+++ b/research/sparse-halo-tape-transaction/OVERLAP.json
@@ -0,0 +1,33 @@
+{
+  "checked_on": "2026-11-08",
+  "canonical_base": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "source_scope": "Bounded lead archive synthesis and scoped PR searches; no exhaustive novelty claim. Discussion posting/access limitations retained in README.",
+  "contextual_sources": [
+    {
+      "path": "research/rounded-core-halo-splice/PROOF.md",
+      "usage": "provenance",
+      "pin": "head:e212af981b49c299de515f8c23dfb0e5b73e2e95:research/rounded-core-halo-splice/PROOF.md",
+      "git_blob": "d9440b8c90f8663057c3266ccbfe348cfcc52140",
+      "sha256": "dc8b3d58086bbe208320ece31a19080afecd687ac3be554935db3f091b423f24"
+    }
+  ],
+  "contextual_source_policy": "Exact nonexecuted source pins for attribution and compatibility discussion. These are not live runtime inputs or claims of canonical-base ancestry.",
+  "new_obligation": "#4870 first Open next question: fixed-role physical first-face copy enumeration, full-key radix, paid rewind/erasure and unique return.",
+  "predecessors": [
+    {
+      "pr": 4100,
+      "path": "research/unconditional-batched-crt/HALO.md",
+      "credit": "Cinna Davis; original source-driven halo schedule and tariff."
+    },
+    {
+      "pr": 4870,
+      "path": "research/halo-copy-enumeration/README.md",
+      "credit": "Astra/OpenAI-assisted contribution; exact source membership and volume, physical implementation left open."
+    },
+    {
+      "pr": 6880,
+      "head": "e212af981b49c299de515f8c23dfb0e5b73e2e95",
+      "credit": "CubeJerry/OpenAI-assisted common-reference core/halo splice; pre-copy and unique-return chronology."
+    }
+  ]
+}
diff --git a/research/sparse-halo-tape-transaction/PROOF.md b/research/sparse-halo-tape-transaction/PROOF.md
new file mode 100644
index 0000000000..2f69b5b082
--- /dev/null
+++ b/research/sparse-halo-tape-transaction/PROOF.md
@@ -0,0 +1,427 @@
+# A sequential tape transaction for first-face halo copies
+
+## 1. Statement, input contract, and contribution boundary
+
+This note supplies the physical enumeration/sort/return obligation left open
+in [the first open question of #4870](../halo-copy-enumeration/README.md).
+The first-face partition, its source-membership predicates, and its volume
+formula are inherited results. The new object is the fixed-role sequential
+program in `tapes.py`, with the complete dense and sparse movement bill below.
+It uses no numerical inverse oracle. An independently supplied halo consumer
+remains responsible for producing correct returned *values*.
+
+Fix integers
+
+\[
+ g\ge1,\quad \ell\ge1,\quad k_i\ge1,\quad E\ge0,\quad P\ge1,
+ \qquad L=2^\ell,\quad S_i=2^{k_i}L,
+\]
+
+and integers \(0\le b<A\), \(L>4A\). There are \(2^E\) independent
+spectator blocks. In a block, a point has coordinates
+\(x_i=q_iL+r_i\), with \(0\le q_i<2^{k_i}\), \(0\le r_i<L\).
+Put
+
+\[
+ B=E+\sum_i(k_i+\ell),\qquad M=2^B,\qquad
+ K=2B+3g+1.
+\]
+
+The dense input is the complete lexicographic coordinate stream, containing
+one opaque \(P\)-bit value per point. Every record has the same width. The
+coordinate schema is a spectator field followed by the \(q_i,r_i\) fields;
+the field widths are represented by delimiters and zero bits, not by
+unbounded integers in control. The constants \(L,A,b\) are supplied as
+\(w=\ell+2\)-bit unsigned fields. Well-formedness, the dyadic domain, and
+the displayed inequalities are caller premises. This is not a parser for
+arbitrary corrupted schemas. The program does check dense cardinality and
+the semantic completeness of the final return stream.
+
+For a core \(c\), face \(f\in\{0,\ldots,g-1\}\), and side
+\(s\in\{0,1\}\), let
+
+\[
+ I=[A,L-A),\quad B_0=[0,A),\quad B_1=[L-A,L),
+\]
+
+\[
+ T(c,f,s)=cL+I^f\times B_s\times[0,L)^{g-f-1}.
+\]
+
+Its saved domain \(D(c,f,s)\) expands each interval by \(b\) on both
+sides, with coordinates reduced modulo the corresponding \(S_i\).
+Each local offset is measured from the *unreduced lower endpoint* of this
+expanded interval. Since every expanded length is at most \(L+2b<2L\le
+S_i\), a local offset determines one distinct periodic coordinate.
+
+Let \(C\) be the total number of saved records, counting copies to distinct
+rectangles separately, and \(Q\) the number of target coordinates. For
+\(N=2^{E+\sum k_i}\), the inherited identities are
+
+\[
+ C=N\sum_{f=0}^{g-1}2(L-2A+2b)^f(A+2b)(L+2b)^{g-f-1},
+ \quad Q=N\{L^g-(L-2A)^g\}\le C.
+\]
+
+**Transport theorem.** There is one program with 30 tape roles, independent
+of all these parameters, that:
+
+1. Saves exactly one original input for every pair consisting of a rectangle
+   and a point of its expanded domain, with its full destination/local key.
+2. Stable-sorts the saved copies into rectangle and local lexicographic order.
+3. Permits the dense core stream to be changed only after saving is complete.
+4. Given an arbitrary-order stream of \(P\)-bit halo values with canonical
+   \(B\)-bit global keys, rejects unless there is exactly one returned record
+   for each target and none for a kept interior. On acceptance it keeps the
+   current core value at every interior and installs the returned value at
+   every target.
+5. Erases its work with all movement charged, without claiming that erased
+   backing becomes unallocated.
+
+The transport performs
+
+\[
+ O\bigl(M(P+B)+C K(P+K)\bigr)
+ \tag{1}
+\]
+
+finite-alphabet read/write/unit-move actions and retains
+
+\[
+ O\bigl(MP+C(P+K)+B+P\bigr)
+ \tag{2}
+\]
+
+cells. Any numerical core/halo consumer work, coefficient pages, or extra
+consumer backing must be added to (1)–(2). This theorem does not establish
+correctness of arbitrary returned numerical values.
+
+The common \(b\), complete dyadic periods, and supplied canonical input
+stream are explicit restrictions. Nonbinary periods from the more general
+combinatorial theorem in #4870 are outside this implementation. A dense
+permutation needed to obtain this input stream is an additional caller cost.
+
+## 2. What the physical program counts
+
+Each tape has a left sentinel, finite content, and a right terminator. A head
+reads one symbol, writes one symbol, or moves by one cell. There are 14 symbols:
+blank, two bits, the sentinels, delimiters, and the finite descriptor marks.
+`Tape` alone implements the simulator's cell map and integer head position;
+neither the program nor any arithmetic/scheduling helper reads those private
+objects. Its `inspect` and `ledger` methods are external observers only.
+
+Program locals are booleans, individual symbols, one of three comparison
+states, a finite phase, or one of a fixed set of tape handles. No growing
+Python integer, coordinate tuple, list of records, input-sized recursive
+stack, or array index is an execution resource. The fixed 30-role loop in
+erasure can be unrolled. Procedure call depth is bounded independently of the
+input; loops test current symbols. Thus all host control has a fixed finite
+control compilation. The reported action counts are the actual tape
+reads/writes/unit moves, not the count of Python instructions or a published
+transition table.
+
+For a binary-tape version, encode the 14 symbols in four-bit blocks and keep
+each simulated head aligned with a block's first cell. A read or write uses
+at most four binary reads/writes plus six unit head moves; a logical move
+uses four unit moves. Therefore ten times the displayed action count is a
+conservative bound for the tape primitives in this block simulation, before
+a further fixed finite-control compilation factor. Four times the retained
+logical-cell count suffices for the encoded backing. We do not call the raw
+logical-cell counts exact binary transition counts.
+
+The simulator initializes each input role with its supplied contents and
+includes those cells in retained backing. Loading or generating caller
+inputs is not a hidden subroutine in (1); it is the stated input contract.
+An external numerical result stream may be loaded for tests, but it is
+explicitly a consumer input, not a computed Gaussian answer.
+
+`clear` first returns to the left sentinel, walks through the *current*
+content to its terminator while erasing, returns, and places the terminator
+at cell one. It does not traverse historical high-water backing. Every visit
+is metered, and the high-water ledger never decreases. Reusing a tape after
+a long record therefore pays that long erasure once, rather than imposing
+its historical length on every later short record. This distinction is
+needed for both (1) and (2).
+
+## 3. Dense source work and admitted face records
+
+The physical coordinate tape contains
+
+```text
+spectator bits & @ core bits # local bits ; @ core bits # local bits ; ...
+```
+
+All numerical bits start at zero. Increment scans backward with one carry
+bit and skips delimiters. It is exactly the increment of the concatenated
+\(B\)-bit address, so it visits the admitted lexicographic stream once,
+including all periodic cuts. There is no quotient, long division, product,
+or lookup per source value. Every increment plus repositioning takes
+\(O(B+g)=O(B)\) actions. Overflow after the last coordinate resets it to
+zero, supplying the starting counter for return. An early/late source end
+is rejected.
+
+One payload is copied to a reusable tape. The coordinate pass creates a
+descriptor with the core and zero-extended local fields, a flat canonical
+source key, and the following finite flags for each axis:
+
+| Flag | Predicate |
+|---|---|
+| expanded interior | \(A-b\le r<L-A+b\) |
+| previous full core | \(r<b\) |
+| next full core | \(r\ge L-b\) |
+| same-core lower face | \(r<A+b\) |
+| same-core upper face | \(r\ge L-A-b\) |
+
+The program computes the constant thresholds once by equal-width ripple
+arithmetic. At a source it uses a fixed number of comparisons on each
+\(\ell+2\)-bit local field. A one-bit prefix conjunction says whether all
+earlier axes lie in their expanded interiors. Only while that conjunction
+holds does it admit a lower face (same-core lower or next full) or an upper
+face (same-core upper or previous full).
+
+The next/previous candidates use only binary increment/decrement of the
+\(k_i\)-bit core field. Arithmetic wraps modulo \(2^{k_i}\), which is
+exactly the needed periodic core wrap. Under the strict parameter bounds,
+the two alternatives for a *given side* are mutually exclusive. At most two
+sides are admitted at an axis; every admitted side has at least one suffix
+choice and thus at least one emitted copy.
+
+An admitted face is stored as its unary axis number, a terminator, and its
+side. If a source has \(f_x\) admitted faces and \(c_x\) copies, storing
+and later clearing these unary records costs \(O(g f_x)\). This is **not**
+claimed to fit in the dense \(O(B)\) work. Since \(f_x\le c_x\) and
+\(g\le B\), it is charged to \(O(Bc_x)\). A source in the middle of
+every core may have \(c_x=0\); it still pays the one payload/coordinate scan,
+and no per-face or sparse-key processing is attempted.
+
+The remaining descriptor construction, constant comparisons, counter work,
+and current-content scratch clearing cost \(O(P+B)\) per source. Erasing
+the previous source's face list is assigned to those previous emitted
+copies. Consequently the total gather cost is
+
+\[
+ O\bigl(M(P+B)+C(P+B)\bigr),
+ \tag{3}
+\]
+
+including all preparatory work below. There is no \(g\) multiplier on the
+payload scan, and no fresh \(B\)-bit multiplication/division or \(B^2\)
+key operation on all \(M\) sources.
+
+## 4. Suffix choices and exact emitted keys
+
+For one admitted face the program scans the descriptor to reset prior marks
+and choices, follows its unary axis field by sequential traversal, marks
+the face, and marks the later axes that have a neighboring full-core choice.
+Every axis after the face always has its current core. It has a second
+choice exactly when \(r<b\) or \(r\ge L-b\); these conditions are disjoint.
+The marked binary choice fields form a physical odometer.
+
+The initial all-zero choice is emitted. Backward descriptor scans increment
+the marked choice bits, and the process stops at their overflow. No branch
+has zero leaves. Thus, for a face with \(h\) eligible suffix axes, the
+program emits its \(2^h\) choices exactly once. Both an emission and an
+odometer step cost \(O(B+P)\), including descriptor head restoration. A
+zero-bit odometer emits its one required leaf and stops.
+
+For each leaf, the physical ripple routines form the destination core and
+the following offsets. Here \(r\) is the source's local coordinate and
+“previous/next” describes its *destination* core relative to its source core.
+
+| Axis role and destination | Offset from expanded lower endpoint |
+|---|---|
+| Earlier expanded interior, current core | \(r-A+b\) |
+| Lower face, current core | \(r+b\) |
+| Lower face, next core | \(r+b-L\) |
+| Upper face, current core | \(r+A+b-L\) |
+| Upper face, previous core | \(r+A+b\) |
+| Later full interval, current core | \(r+b\) |
+| Later full interval, previous core | \(r+b+L\) |
+| Later full interval, next core | \(r+b-L\) |
+
+Each admitted value is nonnegative and less than its expanded interval
+length, hence less than \(2L\). Intermediate sums are less than \(4L\).
+The \(w=\ell+2\)-bit ripple routines are therefore exact for these
+formulas; their modular truncation does not discard a needed high bit.
+The core increment/decrement is deliberately modular, as required.
+
+The complete binary key is
+
+```text
+spectator || destination core fields || one-hot face || side
+          || expanded-rectangle local offsets || canonical source address
+```
+
+The face has \(g\) one-hot bits, the side one bit, the local offsets
+\(g(\ell+2)\) bits, and the redundant canonical source suffix \(B\) bits.
+Its width is
+
+\[
+ E+\sum k_i+g+1+g(\ell+2)+B=2B+3g+1=K=O(B).
+\]
+
+All fields are emitted by sequential scans; the \(P\)-bit payload follows
+the key and a delimiter. No variable-length integer key is held in control.
+The source suffix records provenance and does not alter the rectangle/local
+order, since an expanded offset already determines a unique source.
+
+For correctness, membership in a rectangle factors by axes. The inherited
+source predicates above enumerate precisely the possible destinations on
+each axis. The prefix conjunction supplies exactly the earlier interiors,
+the marked face supplies the appropriate boundary interval, and the suffix
+odometer supplies their full Cartesian product. Each choice sequence has a
+different destination rectangle or local offset. Conversely any rectangle
+containing the source supplies exactly one such sequence. This proves
+equality with destination-first expanded-interval membership without any
+finite-search premise.
+
+## 5. Sparse stable radix on complete keys
+
+For a stream of fixed \(h\)-bit keys and \(P\)-bit payloads, copy a unary
+pass clock from the first key. One pass scans every record once, saves it
+on a single reusable record tape, and remembers its final key bit in finite
+control. It appends the record to bucket zero or one, rotating its key one
+place to the right. The previous key bit is held only as a one-symbol
+lookahead; the payload is copied unchanged. Concatenate bucket zero followed
+by bucket one and advance the unary clock by one cell.
+
+One pass preserves order among equal chosen bits. After \(t\) passes it
+orders records by the original last \(t\) bits, most significant of those
+bits first, with stable ordering on ties. Rotation exposes the original
+next bit as the current last bit. After exactly \(h\) passes the key has
+returned to its original position and the stream is stably sorted by the
+entire original key. This proves the algorithm for all widths and record
+counts, including duplicate keys. Empty input is handled separately.
+
+Each pass costs \(O(R(h+P))\) for \(R\) records: record clearing,
+distribution, every rewind, main-stream clearing, and bucket concatenation
+are all complete sequential scans of at most a constant number of streams.
+The pass clock costs \(O(h)\) to construct and erase and moves one cell per
+pass. Thus the bill is \(O(Rh(h+P)+h)\), with no random lookup or hidden
+host sort. Each of the two buckets and the main role retains at most
+\(O(R(h+P))\) cells. Repeated passes reuse their origins; they do not need
+\(h\) distinct backing regions.
+
+Apply this first with \((R,h)=(C,K)\), then to returned target records
+with \((R,h)=(Q,B)\). Since \(Q\le C\) and \(B\le K\), their sum is
+the sparse term of (1). Local sorting or exposure required by the numerical
+consumer is additional work until explicitly composed with that consumer.
+
+## 6. Chronology and unique return
+
+`gather` never writes the dense source. All its saved payloads therefore
+belong to the input before any core mutation. A finite phase gate allows
+the supplied test core to mutate the dense role only after gather. The test
+core merely complements bits and is intentionally not a Gaussian inverse.
+It witnesses the ownership distinction: saved source copies and current
+core results occupy different roles.
+
+The actual consumer contract has three parts: it reads the saved copies
+without altering their numerical meaning, it returns a correctly computed
+\(P\)-bit value for each target under the desired numerical contract, and
+it finishes before the saved backing is erased. Numerical accuracy and
+coefficient/reference consistency belong to that consumer. The transport
+itself checks the target-domain part of the contract.
+
+After sorting the returned \(B\)-bit global keys, retain only the next
+return record on two small roles. Scan the current dense core stream once,
+using the reset physical coordinate odometer. For each point, compare its
+canonical key to the pending return key and check the unexpanded interior
+condition \(A\le r_i<L-A\) for all axes. At a discarded target equality
+is required, the returned value is emitted, and the next return is loaded.
+At a kept interior, any pending key less than or equal to the current key
+is rejected; otherwise the current core value is emitted. At dense end no
+pending return may remain.
+
+The first-face output rectangles form a disjoint partition of the discarded
+set: choose the first axis whose local coordinate is outside \(I\), then
+its unique lower/upper side. Thus the above keyed merge enforces exactly the
+required target set. A missing key fails at its target. A duplicate remains
+pending after its first occurrence and fails at a later coordinate or at
+end. An interior return fails at that interior or earlier when it blocks
+the next required target. No wrong target can be silently skipped. The
+returned value replaces the current core value only on this partition.
+
+The merge and its target tests cost \(O(M(P+B))\), plus loading \(Q\)
+small return records, already covered by (1). The final erasure costs at
+most the sum of current live lengths. Its touches are counted, and all
+previously touched cells remain in the retained-backing bill.
+
+## 7. Space, caller substitution, and compatible numerical consumers
+
+The dense source and final stream each occupy \(O(MP)\). Saved copies and
+their two radix buckets occupy \(O(C(P+K))\); the return stream occupies
+\(O(Q(P+B))\), absorbed by that bound. Reusing buckets for later returns
+does not add their lifetimes as disjoint storage. Descriptor/key/record
+scratch is \(O(B+P)\). The largest unary face list is bounded by
+\(O(gf_x)\le O(BC)\), also absorbed. Constants and the unary axis number
+are \(O(B)\). The sum over the 30 high-water extents proves (2), even if
+each bucket reaches its maximum on a different radix pass and even after
+erasure.
+
+In the source caller's admitted representation, \(P=\Theta(p)\) and
+\(B=O(p)\), and the dense bit volume is \(V=MP\). The inherited volume
+bound is
+
+\[
+ C\le 6M(gA/L)(1+2A/L)^{g-1}.
+\]
+
+When \(gA/L\) is bounded, the product factor is bounded. Equations
+(1)–(2) give a per-group transport cost
+
+\[
+ O\bigl(V+C p^2\bigr)
+   =O\bigl(V[1+(gA/L)p]\bigr),
+\]
+
+and retained backing \(O(V[1+gA/L])\). The source's deliberately looser
+allowance \(O(V[1+(gA/L)p^2]\operatorname{polylog}p)\) therefore covers
+this transaction. No dense \(Vp\) or \(gV\) term was absorbed into that
+sparse allowance. Generic parameters retain the displayed \(C\) term;
+one cannot call storage linear in \(V\) without bounding the copy ratio.
+
+The dyadic core side and periods come from #4100's HALO/GAUSSIAN setting.
+For the direct-Neumann splice in #6880, set the saved radius to any common
+\(b\) with \(\max_i(J_i-1)W_i\le b<A\). Copies precede core mutation
+as its theorem requires. If a numerical axis consumer needs a smaller
+\(b_i\), a sparse pass retains offsets
+
+\[
+ b-b_i\le u_i < m_i+b+b_i
+\]
+
+and replaces them by \(u_i-(b-b_i)\), where \(m_i\) is the unexpanded
+target length. This order-preserving filter yields exactly its original
+expanded domain; its cost must be added, not assumed free. The constant
+\(\ell+2\)-bit offsets may likewise be shortened by dropping checked
+leading zeros. Payloads may be the consumer's full sign-magnitude complex
+words because the transport treats them as opaque bits.
+
+A returned local coordinate is lifted by its core origin and expanded
+lower endpoint, then reduced modulo \(S_i\). Binary shift/concatenation,
+ripple addition/subtraction, and truncation to the \(k_i+\ell\)-bit axis
+field implement this conversion with a linear scan of the total coordinate
+fields. Where rectangle descriptors or widths need production or decoding,
+retain a conservative \(O(C(B+P)^2)\) sparse codec bill until an explicit
+implementation is linked. That extra bill still belongs to sparse copies;
+this package's tested transaction accepts the already canonical return
+stream. A comparison with another consumer is not itself an executed join.
+
+## 8. Evidence and remaining obligations
+
+`verify.py` compares full emitted keys/payloads against a separate
+destination-first Cartesian-interval oracle. It also checks exact source
+preservation through a destructive core test double, sorted unique return,
+work erasure with retained backing, and malformed return/chronology/radix
+controls. Bit arithmetic is exhaustively checked for 1–5-bit fields.
+These are finite corroborations of the universal invariants above, not a
+formal proof kernel or a numerical inverse implementation.
+
+The complete selected multiplication proof still retains its five
+assumptions. This work addresses one explicit physical sub-obligation of
+`precision_tape` and `analytic_recovery`; it changes neither the selected
+certificate nor κ. Global reference generation, numerical consumer
+admission, core correctness, outer transformations, full precision/recovery
+budgets, and production of the canonical caller inputs remain outside this
+transport theorem. **No new κ.**
diff --git a/research/sparse-halo-tape-transaction/README.md b/research/sparse-halo-tape-transaction/README.md
new file mode 100644
index 0000000000..ded77314ae
--- /dev/null
+++ b/research/sparse-halo-tape-transaction/README.md
@@ -0,0 +1,169 @@
+# Sequential first-face halo transport and unique return
+
+**Result:** a fixed-role sequential tape implementation of the sparse halo
+transport left open by [#4870](../halo-copy-enumeration/README.md). It copies
+the original values before core mutation, constructs complete destination
+keys without dense long arithmetic, stably sorts the sparse records, and
+checks an exact boundary-only return transaction. The numerical halo values
+remain the responsibility of an explicitly supplied consumer.
+
+**No new κ.** This addresses a physical sub-obligation of `precision_tape`
+and `analytic_recovery`; all five selected assumptions remain. It is not an
+unconditional integer multiplier or a numerical inverse implementation.
+
+## Technical result and scope
+
+On the dyadic caller domain, let `L=2^ell`, `S_i=2^(k_i+ell)`, `k_i>=1`,
+`0<=b<A`, and `L>4A`. There are `g` active coordinates and an optional
+complete binary spectator prefix. Let `M` count dense scalar records, `P`
+their opaque payload width, `B` their complete coordinate width, and `C`
+the inherited copied-input volume. The emitted key width is
+
+```text
+K = 2 B + 3 g + 1.
+```
+
+The written theorem in [PROOF.md](PROOF.md) establishes
+
+```text
+time:              O(M(P+B) + C K(P+K))
+retained backing:  O(MP + C(P+K) + B + P)
+physical roles:    30, independent of g, M, P, and key width.
+```
+
+The dense scan maintains physical binary core/local odometers. Comparisons
+inspect all coordinate fields only a bounded number of times; no full-key
+division or multiplication is paid per dense scalar. Unary face descriptors
+and repeated full descriptor scans are charged to actual emitted copies,
+because every admitted face has at least one leaf. Empty-center sources
+still pay their one dense scan. Full-key radix sorting is paid only on
+sparse copies and returned targets.
+
+The program uses a 14-symbol tape alphabet. Reported actions are individual
+symbol reads, writes, and unit head moves. A four-bit block encoding gives
+a constant-factor binary-tape simulation; the raw action totals are not
+claimed to be exact binary transition counts. Only the simulator backend
+uses host cell indexes. Program control consists of a fixed set of tape
+handles, finite flags and symbols, with no input-sized host record array or
+integer key. This is a reviewed executable tape program with an all-size
+proof, not a formal transition-table certificate.
+
+Every scratch clear scans its current live extent. Historical erased cells
+remain in the retained high-water bill, but do not get rescanned after every
+later short record. The two radix buckets and all other roles reuse their
+origins. These details prevent both an uncharged rewind and a hidden
+dimension/history multiplier.
+
+The input is a complete canonical lexicographic stream with equal-width
+payloads and a well-formed dyadic coordinate schema. Arbitrary nonbinary
+periods, caller layout production, numerical coefficient generation, and
+the numerical core/halo algorithms are outside this standalone theorem.
+It rejects missing, duplicate, and kept-row returns on the admitted schema;
+it is not a hardened parser for every malformed binary input.
+
+## Relation to earlier and concurrent work
+
+Cinna Davis's #4100 proposed the first-face Gaussian schedule and its dense
+scan/sparse correction budget. The source combinatorics, volume formula,
+zero-copy centers, and corner fanout were already proved and checked by
+#4870. Its explicit next question asks for the physical short-field
+enumerator, full-key radix distribution, and paid movement/retention.
+This package supplies that implementation obligation on the actual dyadic
+period domain; it does not claim those earlier lemmas again.
+
+The numerical locality questions studied in Nick Petalas's #4217 and #5986
+are distinct. The pending #6880 common-reference rounded core/halo splice
+requires copies before mutation and target-only return, which this
+transaction enforces. Its exact nonexecuted head/blob/SHA is retained in `OVERLAP.json`, separately
+from live source inputs and canonical-base ancestry. A concurrent
+shrinking-domain reference-band consumer can use the emitted local offsets,
+after an explicitly priced sparse codec; compatibility alone is not an
+executed or accepted complete Gaussian caller.
+
+The lead's bounded canonical archive survey and a focused PR search for
+`4870` and `"halo" "tape"` located no later implementation of this exact
+obligation. Related #486 and #3935 use other physical halo/layout schedules;
+generic sequential sorting is not novel. Discussion access and historical
+diff coverage were incomplete. This records the evidence used for task
+selection, not exhaustive novelty or literature priority.
+
+## Reproduce and evidence
+
+Base: `7c49fe32c55de02c2c873655c804b16e4c3fef0a`.
+`SOURCES.json` gives exact Git blobs and SHA256 values. The three live
+predecessor text inputs are checked even in a Git-free source export.
+
+From the repository root, with Python 3.12 and the standard library:
+
+```sh
+python3 -B scripts/research_package.py --package research/sparse-halo-tape-transaction
+```
+
+Expected: `PASS_REGISTERED_RESEARCH_PACKAGE`. `VERIFY.json` registers the
+normal and optimized complete transaction replay and the normal and
+optimized separately written geometry/radix review. Direct transaction
+replay prints a JSON receipt with `"status": "PASS"`; the review prints
+`PASS_INDEPENDENT_HALO_GEOMETRY_AND_RADIX`. No assertions are used as
+acceptance gates, and no third-party dependencies are required.
+
+The full transaction fixtures are:
+
+| Fixture | Dense M | Copies C | Targets Q | Max fanout | Zero-copy sources | Metered actions including erase |
+|---|---:|---:|---:|---:|---:|---:|
+| One axis, L16/A2/b1 | 32 | 16 | 8 | 2 | 20 | 356,848 |
+| Two axes, L16/A2/b1 | 1,024 | 1,024 | 448 | 4 | 400 | 55,924,621 |
+| Spectator and unequal periods, L8/A1/b0 | 1,024 | 448 | 448 | 1 | 576 | 28,502,162 |
+
+All emitted keys and payloads are compared with a destination-first interval
+oracle, independent of the source predicates and suffix odometer. The
+largest fixture retains 124,785 finite-alphabet cells across 30 roles,
+including blank cells after erasure. Exact arithmetic checks cover 1,364
+pairs of 1–5-bit operands for comparison, addition, subtraction and modular
+increment/decrement. The exact observed receipts are in `EXPECTED.json`.
+
+Controls reject a missing target, duplicated target, unexpected interior
+return, core mutation before copying, return before core mutation, and a
+nonunit head jump. They also detect reversed radix bucket concatenation and
+copying after a destructive core change, and check duplicate-key stability.
+A static check excludes observer calls from the program; that check is
+limited and is not runtime enforcement of private simulator fields.
+
+The separately assigned source-aware AI review in `independent_review.py`
+uses direct modular membership in every destination-core face interval.
+It imports the author program but neither the author's geometric oracle nor
+fixture builder. It checks 366 selected source points in dimensions one
+through four, 830 emitted copies, and five stable-radix/idempotence cases
+with duplicate keys. Its independence concerns the membership oracle and
+sort expectations; replay of the implementation is not an independently
+written tape program. Human and proof-kernel acceptance are unclaimed.
+
+The core operation in transaction fixtures complements payload bits. It is
+a destructive ownership test double, not execution of the fast Gaussian
+core circuit. Return values are supplied as explicit consumer-contract
+inputs. Numerical accuracy is therefore not inferred from these tests.
+
+## Open next questions
+
+Structured versions and blockers are in `TASK.json`.
+
+The former numerical-consumer join question is resolved within the explicit
+source/plan hypotheses by [the integrated first-face reference
+transaction](../first-face-reference-join/README.md). That package proves the
+codec/cost compatibility and executes an actual dyadic reference fixture
+with wrap and holes, plus independent unequal-halo tests. It retains the
+separate actual-core and outer-proof obligations.
+
+1. Bind the transaction to the selected outer caller's actual dense layout,
+   core supplier, normalization, and recovery scales. A standalone transport
+   result cannot discharge the complete analytic or machine assumptions.
+
+## Attribution
+
+Prepared for **@CubeJerry** with substantial OpenAI Codex assistance in
+mathematical construction, implementation, source investigation and a
+separately assigned adversarial AI review. Credit Cinna Davis (#4100), the
+@codyw912's Astra/OpenAI-assisted #4870 contribution, Nick Petalas (#4217), the #6880
+contributors and their retained source lineage. Douglas Colkitt/OpenAI's
+tape framework, Vlado Vojdanovski's Gaussian layouts, and Chafik Boukhalfa's
+constructions are predecessor work; no claim to those mechanisms is made.
+Apache-2.0, following the repository license.
diff --git a/research/sparse-halo-tape-transaction/SOURCES.json b/research/sparse-halo-tape-transaction/SOURCES.json
new file mode 100644
index 0000000000..890cc22c00
--- /dev/null
+++ b/research/sparse-halo-tape-transaction/SOURCES.json
@@ -0,0 +1,36 @@
+{
+  "schema_version": 1,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "files": [
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "path": "research/halo-copy-enumeration/README.md",
+      "usage": "input",
+      "git_blob": "0abc1a3c3d41d218cafc939312e22d685be1681d",
+      "sha256": "bbca3842b354ce7f699559e1b3d2a57a2714548096f028acaf20bf061d0d9ddc"
+    },
+    {
+      "path": "research/unconditional-batched-crt/HALO.md",
+      "usage": "input",
+      "git_blob": "5f601b3c8ac368aa79aa1007effe5933a360237b",
+      "sha256": "a2adcf18614983e9255def6d3f5e59be0018a392e418d65e94323722838289cc"
+    },
+    {
+      "path": "research/unconditional-batched-crt/GAUSSIAN.md",
+      "usage": "input",
+      "git_blob": "adfb28c93e6b06178c901caaac39ede41a9e541b",
+      "sha256": "2f63c91c58f2d1cf31294812c75970ea390c61866a8da7ed700d4316a033a242"
+    }
+  ]
+}
diff --git a/research/sparse-halo-tape-transaction/TASK.json b/research/sparse-halo-tape-transaction/TASK.json
new file mode 100644
index 0000000000..dd37ab41d2
--- /dev/null
+++ b/research/sparse-halo-tape-transaction/TASK.json
@@ -0,0 +1,93 @@
+{
+  "schema_version": 1,
+  "task_id": "uniform-transfer-audit",
+  "priority_revision": 8,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "original_card": {
+    "id": "uniform-transfer-audit",
+    "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?",
+    "starting_points": [
+      "docs/research/current-priorities.md",
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md"
+    ],
+    "methods": [
+      "Construct and independently check one source-bound instance of the stated first experiment.",
+      "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+    ],
+    "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_selected_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+      "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+    },
+    "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.",
+    "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+    "allowed_variations": [
+      "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+    ],
+    "scope_change_triggers": [
+      "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+      "Treating an archived proposal or local numerical pass as complete supplier admission."
+    ],
+    "overlap_terms": [
+      "native_all_columns",
+      "owned_erasure",
+      "compiler",
+      "precision_tape",
+      "analytic_recovery"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.",
+        "evidence": "research/unconditional-batched-crt/README.md",
+        "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.",
+        "status": "author-checked",
+        "source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+        "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+        "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+        "status": "reviewed",
+        "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+        "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+      }
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "Resolve the fixed-tape first-face halo enumeration and unique-return transport sub-obligation explicitly left open by #4870, on the dyadic period domain of #4100, compatible with #6880. Numerical consumer correctness remains an explicit contract.",
+  "scope_change_reason": "User and lead explicitly assigned the physical transport obligation. First-face combinatorics, volume and inverse locality were already proved; the new object is a fixed-role finite-alphabet sequential program with complete dense/sparse time and retained backing accounting.",
+  "bottleneck_link": "Supports precision_tape and analytic_recovery at one named Gaussian sparse interface; does not discharge either complete retained assumption.",
+  "budget_minutes": 120,
+  "stop_rule": "Stop after a universal transport proof, complete modest physical fixtures, independent geometry/radix review, and required packaging checks; no parameter search or supplier optimization.",
+  "outcome": "completed",
+  "evidence": "PROOF.md; tapes.py literal finite-alphabet program; verify.py destination-first oracle, metered transactions and controls; independent_review.py separate modular-membership and stable-radix oracle; EXPECTED.json.",
+  "author": "CubeJerry",
+  "ai_assistance": "Substantial OpenAI Codex assistance in construction, implementation, proof, and separately assigned source-aware AI review. No human or formal-kernel acceptance claimed.",
+  "open_questions": [
+    {
+      "question": "Can the complete selected outer caller supply the canonical dyadic dense stream and admitted numerical core under the full recovery budget?",
+      "why_it_matters": "This local physical sub-obligation does not discharge all five assumptions or prove an unconditional multiplier.",
+      "first_step": "Pin the actual group layout, pre-copy entry point, core mutation and final normalization/recovery scales.",
+      "blocked_by": "Full source transforms, core supplier and production outer admission remain outside this package."
+    }
+  ],
+  "resolved_questions": [
+    {
+      "question": "Can the numerical rectangle consumer and this transaction be joined against one source Reference with completely paid codec and setup?",
+      "why_it_matters": "Transport alone cannot establish correctness or cost of halo numerical values.",
+      "first_step": "Stream sorted copies into shrinking-domain global-band Horner, retain immutable input through all lines, and canonicalize only target returns in a sparse pass.",
+      "blocked_by": "The consumer, page producer and source/precision contracts require their own pinned proof and replay; a standalone transaction run does not execute them.",
+      "resolution": "Resolved under the explicit source/plan hypotheses by research/first-face-reference-join: universal codec/chronology/cost composition, actual Reference64 transaction, independent whole-grid unequal-halo/spectator checks. Actual core and complete outer admission remain open."
+    }
+  ],
+  "integration_package": "research/first-face-reference-join"
+}
diff --git a/research/sparse-halo-tape-transaction/VERIFY.json b/research/sparse-halo-tape-transaction/VERIFY.json
new file mode 100644
index 0000000000..47f6024aaf
--- /dev/null
+++ b/research/sparse-halo-tape-transaction/VERIFY.json
@@ -0,0 +1,55 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/halo-copy-enumeration/README.md",
+    "research/unconditional-batched-crt/HALO.md",
+    "research/unconditional-batched-crt/GAUSSIAN.md"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Complete metered transaction, exact arithmetic, destination-first oracle and rejection controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Complete metered transaction, exact arithmetic, destination-first oracle and rejection controls with assertions disabled."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/independent_review.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Separate modular-membership and stable-radix oracle."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/independent_review.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Separate modular-membership and stable-radix oracle with assertions disabled."
+    }
+  ]
+}
diff --git a/research/sparse-halo-tape-transaction/independent_review.py b/research/sparse-halo-tape-transaction/independent_review.py
new file mode 100644
index 0000000000..2945d92d0b
--- /dev/null
+++ b/research/sparse-halo-tape-transaction/independent_review.py
@@ -0,0 +1,86 @@
+"""Independent modular-membership and stable-radix oracle.
+
+Prepared for @CubeJerry by a separately assigned source-aware AI reviewer,
+with substantial OpenAI Codex assistance. Apache-2.0. Imports the author
+program, but no author geometry oracle or fixture builder.
+"""
+from pathlib import Path
+from hashlib import sha256
+import importlib.util
+import itertools
+import json
+
+SOURCE=Path(__file__).with_name('tapes.py')
+spec=importlib.util.spec_from_file_location('reviewed_halo_tapes',SOURCE)
+p=importlib.util.module_from_spec(spec);spec.loader.exec_module(p)
+
+def bitword(n,width):
+    if not 0<=n<2**width: raise ValueError('word range')
+    return bin(n)[2:].rjust(width,'0')
+
+def rows(text):
+    words=text.split('#')
+    if words[-1]!='' or len(words)%2!=1: raise ValueError('record grammar')
+    return list(zip(words[:-1:2],words[1:-1:2]))
+
+def check_point(ks,ell,a,b,cores,locals_,z=0,zwidth=0):
+    L=2**ell;g=len(ks);W=ell+2
+    prefix=bitword(z,zwidth) if zwidth else ''
+    coordinate=prefix+'&'+''.join('@'+bitword(q,k)+'#'+bitword(r,ell)+';' for q,r,k in zip(cores,locals_,ks))
+    machine=p.Program('1010#',coordinate,bitword(L,W),bitword(a,W),bitword(b,W))
+    machine.setup();p.home(machine.source);machine.load_payload(machine.source,machine.payload)
+    p.end(machine.saved);machine.build_descriptor();p.home(machine.faces)
+    while machine.faces.read()!='!':
+        machine.prepare_face();machine.emit()
+        while machine.next_choice(): machine.emit()
+    actual=rows(machine.saved.inspect())
+    point=tuple(q*L+r for q,r in zip(cores,locals_))
+    sourcekey=prefix+''.join(bitword(x,k+ell) for x,k in zip(point,ks))
+    expected=[]
+    # Scan all destination core faces and test direct modular interval membership.
+    # No source predicates, prefix eligibility, or suffix-choice formula is used.
+    for target in itertools.product(*(range(2**k) for k in ks)):
+        for face in range(g):
+            for side in (0,1):
+                offsets=[]
+                for axis,(x,q,k) in enumerate(zip(point,target,ks)):
+                    lo,hi=((a,L-a) if axis<face else
+                           ((0,a) if side==0 else (L-a,L)) if axis==face else (0,L))
+                    offset=(x-(q*L+lo-b))%(2**k*L)
+                    if offset>=hi-lo+2*b: break
+                    offsets.append(offset)
+                if len(offsets)==g:
+                    key=prefix+''.join(bitword(q,k) for q,k in zip(target,ks))
+                    key+=''.join('1' if axis==face else '0' for axis in range(g))+str(side)
+                    key+=''.join(bitword(x,W) for x in offsets)+sourcekey
+                    expected.append((key,'1010'))
+    if sorted(actual)!=sorted(expected):
+        raise ValueError(('geometric mismatch',ks,ell,a,b,cores,locals_,actual,expected))
+    return len(actual)
+
+checked=0;copies=0
+for ks,ell,a,b in [((1,),4,2,1),((1,2),4,2,1),((2,1,1),4,2,1),((1,1,1,1),3,1,0)]:
+    L=2**ell;g=len(ks)
+    boundary=sorted({r for r in (0,b-1,b,a-b-1,a-b,a+b-1,a+b,L-a-b-1,L-a-b,L-a+b-1,L-a+b,L-b-1,L-b,L-1) if 0<=r<L})
+    points=list(itertools.product(boundary,repeat=g))
+    if g>=3: points=[point for i,point in enumerate(points) if i%7==0]
+    for core in [tuple(0 for _ in ks),tuple(2**k-1 for k in ks)]:
+        for point in points:
+            copies+=check_point(ks,ell,a,b,core,point,z=1,zwidth=1)
+            checked+=1
+
+sort_cases=[]
+for width in range(1,6):
+    data=[(bitword((i*5+3)%(2**width),width),bitword(i,8)) for i in range(3*2**width)]
+    text=''.join(key+'#'+value+'#' for key,value in data)
+    machine=p.Program('','&@0#0000;','010000','000010','000001')
+    machine.saved=p.Tape('independent_sort_input',text)
+    machine.sort(machine.saved)
+    actual=rows(machine.saved.inspect())
+    expected=sorted(data,key=lambda row:row[0])
+    if actual!=expected: raise ValueError(('radix mismatch',width))
+    machine.sort(machine.saved)
+    if rows(machine.saved.inspect())!=expected: raise ValueError(('radix idempotence',width))
+    sort_cases.append({'width':width,'records':len(data)})
+print('PASS_INDEPENDENT_HALO_GEOMETRY_AND_RADIX')
+print(json.dumps({'source_sha256':sha256(SOURCE.read_bytes()).hexdigest(),'local_geometry_cases':checked,'copies':copies,'stable_radix_cases':sort_cases},sort_keys=True))
diff --git a/research/sparse-halo-tape-transaction/tapes.py b/research/sparse-halo-tape-transaction/tapes.py
new file mode 100644
index 0000000000..b3dfa43ba0
--- /dev/null
+++ b/research/sparse-halo-tape-transaction/tapes.py
@@ -0,0 +1,644 @@
+"""Sequential bit-tape halo transport; no numerical halo solver is hidden here.
+
+Only Tape's simulator backend uses positions or random-access storage.  Program
+methods observe one symbol, write one symbol, or move one cell.  Python locals
+in those methods range over finite alphabets/booleans, except fixed tape handles.
+Fixture construction, inspection, and instrumentation are outside the machine.
+"""
+
+from collections import Counter
+
+
+class Reject(ValueError):
+    pass
+
+
+class Tape:
+    """Simulator backend. Erased cells still count toward retained backing."""
+
+    def __init__(self, name, contents=""):
+        self.name = name
+        self._cells = dict(enumerate("^" + contents + "!"))
+        self._head = 0
+        self._high = len(contents) + 1
+        self.actions = Counter()
+
+    def read(self):
+        self.actions["read"] += 1
+        return self._cells.get(self._head, "_")
+
+    def write(self, symbol):
+        if len(symbol) != 1:
+            raise Reject("non-symbol write")
+        self.actions["write"] += 1
+        self._cells[self._head] = symbol
+        self._high = max(self._high, self._head)
+
+    def move(self, direction):
+        if direction not in (-1, 1):
+            raise Reject("nonunit head move")
+        self.actions["move"] += 1
+        self._head += direction
+        if self._head < 0:
+            raise Reject("crossed left sentinel")
+        self._high = max(self._high, self._head)
+
+    def inspect(self):
+        """Unmetered *test observer*: never called by Program or its helpers."""
+        chars = []
+        pos = 1
+        while self._cells.get(pos) != "!":
+            chars.append(self._cells.get(pos, "_"))
+            pos += 1
+            if pos > self._high:
+                raise Reject("observer found no terminator")
+        return "".join(chars)
+
+    def bill(self):
+        return {**self.actions, "retained_cells": self._high + 1}
+
+
+def home(t):
+    while t.read() != "^":
+        t.move(-1)
+    t.move(1)
+
+
+def end(t):
+    while t.read() != "!":
+        t.move(1)
+
+
+def append(t, ch):
+    # Caller owns the right-end head. No length or append index is available.
+    t.write(ch)
+    t.move(1)
+    t.write("!")
+
+
+def clear(t):
+    home(t)
+    while t.read() != "!":
+        t.write("_")
+        t.move(1)
+    t.write("_")
+    home(t)
+    t.write("!")
+
+
+def copy_bits(src, dst):
+    while src.read() in "01":
+        append(dst, src.read())
+        src.move(1)
+
+
+def copy_whole(src, dst):
+    home(src)
+    while src.read() != "!":
+        append(dst, src.read())
+        src.move(1)
+
+
+def clone(src, dst):
+    clear(dst)
+    copy_whole(src, dst)
+
+
+def skip_to(t, ch):
+    while t.read() != ch:
+        if t.read() == "!":
+            raise Reject("missing field delimiter")
+        t.move(1)
+
+
+def compare(a, b):
+    """Equal-width unsigned binary comparison; result is a three-state value."""
+    home(a)
+    home(b)
+    relation = "equal"
+    while a.read() != "!":
+        if b.read() not in "01" or a.read() not in "01":
+            raise Reject("unequal or malformed comparison fields")
+        if relation == "equal":
+            if a.read() == "0" and b.read() == "1":
+                relation = "less"
+            elif a.read() == "1" and b.read() == "0":
+                relation = "greater"
+        a.move(1)
+        b.move(1)
+    if b.read() != "!":
+        raise Reject("unequal comparison widths")
+    return relation
+
+
+def add_mod(a, b, subtract=False):
+    """Binary ripple addition/subtraction, truncated to the common field width."""
+    home(a)
+    end(a)
+    home(b)
+    end(b)
+    a.move(-1)
+    b.move(-1)
+    carry = subtract
+    while a.read() != "^":
+        x = a.read() == "1"
+        y = b.read() == "1"
+        if b.read() not in "01":
+            raise Reject("unequal arithmetic widths")
+        if subtract:
+            y = not y
+        a.write("1" if x ^ y ^ carry else "0")
+        carry = (x and y) or (carry and (x or y))
+        a.move(-1)
+        b.move(-1)
+    if b.read() != "^":
+        raise Reject("unequal arithmetic widths")
+
+
+def step_binary(t, down=False):
+    """Modulo 2**width increment/decrement of a plain binary field."""
+    home(t)
+    end(t)
+    t.move(-1)
+    while t.read() != "^":
+        old = t.read()
+        t.write("0" if old == "1" else "1")
+        if (old == "1") == down:
+            return
+        t.move(-1)
+
+
+def coordinate_next(t):
+    """Increment concatenated coordinate bits, skipping only schema delimiters."""
+    home(t)
+    end(t)
+    t.move(-1)
+    carrying = True
+    while t.read() != "^":
+        if t.read() in "01" and carrying:
+            if t.read() == "0":
+                t.write("1")
+                carrying = False
+            else:
+                t.write("0")
+        t.move(-1)
+    return not carrying
+
+
+def flatten(t, dst):
+    clear(dst)
+    home(t)
+    while t.read() != "!":
+        if t.read() in "01":
+            append(dst, t.read())
+        t.move(1)
+
+
+class Program:
+    """A fixed collection of tape roles, independent of dimension or volume."""
+
+    def __init__(self, source, coordinates, length, width_a, width_b, returns=""):
+        # Loading caller-supplied binary inputs is outside the program's bill;
+        # their cells are included in retained backing from the beginning.
+        self.source = Tape("source", source)
+        self.x = Tape("coordinates", coordinates)
+        self.L = Tape("L", length)
+        self.A = Tape("A", width_a)
+        self.b = Tape("b", width_b)
+        self.returns = Tape("returns", returns)
+        self.saved = Tape("saved")
+        self.final = Tape("final")
+        self.d = Tape("descriptor")
+        self.faces = Tape("faces")
+        self.unary = Tape("axis_index")
+        self.q = Tape("core_field")
+        self.r = Tape("local_field")
+        self.payload = Tape("payload")
+        self.kcore = Tape("key_core")
+        self.kface = Tape("key_face")
+        self.klocal = Tape("key_local")
+        self.ksource = Tape("key_source")
+        self.retkey = Tape("return_key")
+        self.retval = Tape("return_value")
+        self.bucket0 = Tape("radix_zero")
+        self.bucket1 = Tape("radix_one")
+        self.record = Tape("radix_record")
+        self.passes = Tape("radix_passes")
+        self.Am = Tape("A_minus_b")
+        self.Ap = Tape("A_plus_b")
+        self.LAm = Tape("L_minus_A_minus_b")
+        self.LAp = Tape("L_minus_A_plus_b")
+        self.Lb = Tape("L_minus_b")
+        self.LA = Tape("L_minus_A")
+        # This tuple is a fixed schema, never sized using input data.
+        self.roles = (
+            self.source, self.x, self.L, self.A, self.b, self.returns,
+            self.saved, self.final, self.d, self.faces, self.unary, self.q,
+            self.r, self.payload, self.kcore, self.kface, self.klocal,
+            self.ksource, self.retkey, self.retval, self.bucket0, self.bucket1,
+            self.record, self.passes, self.Am, self.Ap, self.LAm, self.LAp,
+            self.Lb, self.LA,
+        )
+        self.phase = "input"
+
+    def setup(self):
+        clone(self.A, self.Am)
+        add_mod(self.Am, self.b, subtract=True)
+        clone(self.A, self.Ap)
+        add_mod(self.Ap, self.b)
+        clone(self.L, self.LA)
+        add_mod(self.LA, self.A, subtract=True)
+        clone(self.LA, self.LAm)
+        add_mod(self.LAm, self.b, subtract=True)
+        clone(self.LA, self.LAp)
+        add_mod(self.LAp, self.b)
+        clone(self.L, self.Lb)
+        add_mod(self.Lb, self.b, subtract=True)
+
+    def load_payload(self, source, dest):
+        clear(dest)
+        copy_bits(source, dest)
+        if source.read() != "#":
+            raise Reject("bad payload delimiter")
+        source.move(1)
+
+    def face_record(self, side):
+        home(self.unary)
+        copy_bits(self.unary, self.faces)
+        append(self.faces, "0")
+        append(self.faces, side)
+        append(self.faces, "#")
+
+    def build_descriptor(self):
+        clear(self.d)
+        clear(self.faces)
+        clear(self.unary)
+        clear(self.ksource)
+        home(self.x)
+        while self.x.read() != "&":
+            append(self.d, self.x.read())
+            append(self.ksource, self.x.read())
+            self.x.move(1)
+        append(self.d, "&")
+        self.x.move(1)
+        prefix = True
+        while self.x.read() != "!":
+            if self.x.read() != "@":
+                raise Reject("bad coordinate schema")
+            append(self.d, "@")
+            self.x.move(1)
+            while self.x.read() != "#":
+                append(self.d, self.x.read())
+                append(self.ksource, self.x.read())
+                self.x.move(1)
+            append(self.d, "#")
+            self.x.move(1)
+            clear(self.r)
+            append(self.r, "0")
+            append(self.r, "0")
+            while self.x.read() != ";":
+                append(self.r, self.x.read())
+                append(self.ksource, self.x.read())
+                self.x.move(1)
+            self.x.move(1)
+            copy_whole(self.r, self.d)
+            append(self.d, "#")
+            interior = compare(self.r, self.Am) != "less"
+            interior = interior and compare(self.r, self.LAp) == "less"
+            low = compare(self.r, self.b) == "less"
+            high = compare(self.r, self.Lb) != "less"
+            lower = compare(self.r, self.Ap) == "less"
+            upper = compare(self.r, self.LAm) != "less"
+            append(self.d, "1" if interior else "0")
+            append(self.d, "1" if low else "0")
+            append(self.d, "1" if high else "0")
+            append(self.d, "1" if lower else "0")
+            append(self.d, "1" if upper else "0")
+            append(self.d, "e" if low or high else "n")
+            append(self.d, "0")
+            append(self.d, ";")
+            if prefix and (lower or high):
+                self.face_record("0")
+            if prefix and (upper or low):
+                self.face_record("1")
+            prefix = prefix and interior
+            end(self.unary)
+            append(self.unary, "1")
+
+    def prepare_face(self):
+        # Reset old face and suffix choices; all scans are through tape cells.
+        home(self.d)
+        skip_to(self.d, "&")
+        self.d.move(1)
+        while self.d.read() != "!":
+            self.d.write("@")
+            skip_to(self.d, "#")
+            self.d.move(1)
+            skip_to(self.d, "#")
+            self.d.move(1)
+            self.d.move(1)
+            self.d.move(1)
+            self.d.move(1)
+            self.d.move(1)
+            self.d.move(1)
+            if self.d.read() == "*":
+                self.d.write("e")
+            self.d.move(1)
+            self.d.write("0")
+            self.d.move(1)
+            self.d.move(1)
+        home(self.d)
+        skip_to(self.d, "&")
+        self.d.move(1)
+        while self.faces.read() == "1":
+            skip_to(self.d, ";")
+            self.d.move(1)
+            self.faces.move(1)
+        if self.faces.read() != "0":
+            raise Reject("bad face index")
+        self.faces.move(1)
+        self.d.write("<" if self.faces.read() == "0" else ">")
+        self.faces.move(1)
+        if self.faces.read() != "#":
+            raise Reject("bad face delimiter")
+        self.faces.move(1)
+        skip_to(self.d, ";")
+        self.d.move(1)
+        while self.d.read() != "!":
+            skip_to(self.d, ";")
+            self.d.move(-1)
+            self.d.move(-1)
+            if self.d.read() == "e":
+                self.d.write("*")
+            self.d.move(1)
+            self.d.move(1)
+            self.d.move(1)
+
+    def next_choice(self):
+        home(self.d)
+        end(self.d)
+        self.d.move(-1)
+        while self.d.read() != "^":
+            if self.d.read() == "*":
+                self.d.move(1)
+                if self.d.read() == "0":
+                    self.d.write("1")
+                    return True
+                self.d.write("0")
+                self.d.move(-1)
+            self.d.move(-1)
+        return False
+
+    def emit(self):
+        clear(self.kcore)
+        clear(self.kface)
+        clear(self.klocal)
+        home(self.d)
+        while self.d.read() != "&":
+            append(self.kcore, self.d.read())
+            self.d.move(1)
+        self.d.move(1)
+        after = False
+        side = "0"
+        while self.d.read() != "!":
+            marker = self.d.read()
+            self.d.move(1)
+            clear(self.q)
+            copy_bits(self.d, self.q)
+            self.d.move(1)
+            clear(self.r)
+            copy_bits(self.d, self.r)
+            self.d.move(1)
+            self.d.move(1)  # interior flag
+            low = self.d.read() == "1"
+            self.d.move(1)
+            high = self.d.read() == "1"
+            self.d.move(1)
+            lower = self.d.read() == "1"
+            self.d.move(1)
+            upper = self.d.read() == "1"
+            self.d.move(1)  # eligibility
+            self.d.move(1)
+            alternative = self.d.read() == "1"
+            self.d.move(1)
+            self.d.move(1)
+            if marker == "<":
+                side = "0"
+                append(self.kface, "1")
+                add_mod(self.r, self.b)
+                if not lower:
+                    if not high:
+                        raise Reject("inadmissible lower face")
+                    step_binary(self.q)
+                    add_mod(self.r, self.L, subtract=True)
+                after = True
+            elif marker == ">":
+                side = "1"
+                append(self.kface, "1")
+                add_mod(self.r, self.Ap)
+                if upper:
+                    add_mod(self.r, self.L, subtract=True)
+                else:
+                    if not low:
+                        raise Reject("inadmissible upper face")
+                    step_binary(self.q, down=True)
+                after = True
+            elif not after:
+                append(self.kface, "0")
+                add_mod(self.r, self.Am, subtract=True)
+            else:
+                append(self.kface, "0")
+                add_mod(self.r, self.b)
+                if alternative:
+                    if low:
+                        step_binary(self.q, down=True)
+                        add_mod(self.r, self.L)
+                    elif high:
+                        step_binary(self.q)
+                        add_mod(self.r, self.L, subtract=True)
+                    else:
+                        raise Reject("inadmissible suffix alternative")
+            copy_whole(self.q, self.kcore)
+            copy_whole(self.r, self.klocal)
+        append(self.kface, side)
+        copy_whole(self.kcore, self.saved)
+        copy_whole(self.kface, self.saved)
+        copy_whole(self.klocal, self.saved)
+        copy_whole(self.ksource, self.saved)
+        append(self.saved, "#")
+        copy_whole(self.payload, self.saved)
+        append(self.saved, "#")
+
+    def gather(self):
+        if self.phase != "input":
+            raise Reject("gather must precede every core mutation")
+        self.setup()
+        home(self.source)
+        end(self.saved)
+        more = True
+        while self.source.read() != "!":
+            if not more:
+                raise Reject("more payloads than coordinates")
+            self.load_payload(self.source, self.payload)
+            self.build_descriptor()
+            home(self.faces)
+            while self.faces.read() != "!":
+                self.prepare_face()
+                self.emit()
+                while self.next_choice():
+                    self.emit()
+            more = coordinate_next(self.x)
+        if more:
+            raise Reject("fewer payloads than coordinates")
+        self.phase = "saved"
+
+    def sort(self, tape, reverse_buckets=False):
+        """Stable binary LSD radix; rotate keys to expose each next digit.
+
+        A unary pass clock is copied from the first key on tape. After exactly
+        that many right rotations, the complete key is restored. No host key
+        length, pass index, record array, integer key, or comparison sort occurs.
+        """
+        clear(self.passes)
+        home(tape)
+        if tape.read() == "!":
+            return
+        while tape.read() in "01":
+            append(self.passes, "1")
+            tape.move(1)
+        if tape.read() != "#":
+            raise Reject("bad radix key")
+        home(self.passes)
+        while self.passes.read() == "1":
+            clear(self.bucket0)
+            clear(self.bucket1)
+            home(tape)
+            while tape.read() != "!":
+                clear(self.record)
+                last = "0"
+                while tape.read() in "01":
+                    last = tape.read()
+                    append(self.record, last)
+                    tape.move(1)
+                if tape.read() != "#":
+                    raise Reject("bad radix key delimiter")
+                append(self.record, "#")
+                tape.move(1)
+                copy_bits(tape, self.record)
+                if tape.read() != "#":
+                    raise Reject("bad radix payload delimiter")
+                append(self.record, "#")
+                tape.move(1)
+                target = self.bucket0 if last == "0" else self.bucket1
+                append(target, last)
+                home(self.record)
+                previous = self.record.read()
+                self.record.move(1)
+                while self.record.read() != "#":
+                    append(target, previous)
+                    previous = self.record.read()
+                    self.record.move(1)
+                append(target, "#")
+                self.record.move(1)
+                copy_bits(self.record, target)
+                append(target, "#")
+            clear(tape)
+            if reverse_buckets:
+                copy_whole(self.bucket1, tape)
+                copy_whole(self.bucket0, tape)
+            else:
+                copy_whole(self.bucket0, tape)
+                copy_whole(self.bucket1, tape)
+            self.passes.write("0")
+            self.passes.move(1)
+        clear(self.bucket0)
+        clear(self.bucket1)
+        clear(self.record)
+        clear(self.passes)
+
+    def core_complement_test_double(self):
+        """Physical mutation for chronology controls; not a Gaussian core."""
+        if self.phase != "saved":
+            raise Reject("core mutation before copies are complete")
+        home(self.source)
+        while self.source.read() != "!":
+            if self.source.read() == "0":
+                self.source.write("1")
+            elif self.source.read() == "1":
+                self.source.write("0")
+            self.source.move(1)
+        self.phase = "core"
+
+    def pending_return(self):
+        if self.returns.read() == "!":
+            clear(self.retkey)
+            clear(self.retval)
+            return False
+        self.load_payload(self.returns, self.retkey)
+        self.load_payload(self.returns, self.retval)
+        return True
+
+    def discarded(self):
+        home(self.x)
+        skip_to(self.x, "&")
+        self.x.move(1)
+        boundary = False
+        while self.x.read() != "!":
+            skip_to(self.x, "#")
+            self.x.move(1)
+            clear(self.r)
+            append(self.r, "0")
+            append(self.r, "0")
+            copy_bits(self.x, self.r)
+            if compare(self.r, self.A) == "less":
+                boundary = True
+            if compare(self.r, self.LA) != "less":
+                boundary = True
+            if self.x.read() != ";":
+                raise Reject("bad coordinate local field")
+            self.x.move(1)
+        return boundary
+
+    def merge_returns(self):
+        if self.phase != "core":
+            raise Reject("return requires completed core phase")
+        self.sort(self.returns)
+        home(self.returns)
+        pending = self.pending_return()
+        home(self.source)
+        clear(self.final)
+        more = True
+        while self.source.read() != "!":
+            if not more:
+                raise Reject("more core values than coordinates")
+            self.load_payload(self.source, self.payload)
+            flatten(self.x, self.ksource)
+            boundary = self.discarded()
+            relation = compare(self.retkey, self.ksource) if pending else "none"
+            if boundary:
+                if relation != "equal":
+                    raise Reject("missing, duplicate, or misplaced boundary return")
+                copy_whole(self.retval, self.final)
+                pending = self.pending_return()
+            else:
+                if pending and relation != "greater":
+                    raise Reject("duplicate or kept-row return")
+                copy_whole(self.payload, self.final)
+            append(self.final, "#")
+            more = coordinate_next(self.x)
+        if more or pending:
+            raise Reject("incomplete source cube or extra return")
+        self.phase = "returned"
+
+    def erase_work(self):
+        if self.phase != "returned":
+            raise Reject("erase before return completion")
+        # Roles remain allocated. The ledger deliberately does not reset peaks.
+        for tape in self.roles:
+            if tape is not self.final:
+                clear(tape)
+        self.phase = "erased"
+
+    def ledger(self):
+        """Observer, not part of the machine."""
+        return {tape.name: tape.bill() for tape in self.roles}
diff --git a/research/sparse-halo-tape-transaction/verify.py b/research/sparse-halo-tape-transaction/verify.py
new file mode 100644
index 0000000000..6a967b432f
--- /dev/null
+++ b/research/sparse-halo-tape-transaction/verify.py
@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+"""Independent destination-first oracle and physical transaction controls.
+
+The oracle, fixture loader, and observers may use ordinary Python arithmetic.
+Only tapes.Program is the claimed sequential algorithm. No oracle is called
+from that algorithm. Assertions are deliberately not used as acceptance gates.
+"""
+
+import argparse
+import hashlib
+import importlib.util
+import itertools
+import json
+import platform
+from pathlib import Path
+
+_spec = importlib.util.spec_from_file_location("halo_tape_program", Path(__file__).with_name("tapes.py"))
+_tapes = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_tapes)
+Program, Reject, Tape = _tapes.Program, _tapes.Reject, _tapes.Tape
+
+
+def require(condition, reason):
+    if not condition:
+        raise RuntimeError(reason)
+
+
+def bits(value, width):
+    if value < 0 or value >= 1 << width:
+        raise ValueError("fixture value outside binary field")
+    return format(value, f"0{width}b")
+
+
+def records(text):
+    fields = text.split("#")
+    require(fields[-1] == "", "missing record terminator")
+    require(len(fields) % 2 == 1, "odd record field count")
+    return list(zip(fields[0:-1:2], fields[1:-1:2]))
+
+
+def fixture(ks, ell, a, b, payload_width=8, spectator_width=0):
+    length = 1 << ell
+    require(0 <= b < a and length > 4 * a, "inadmissible test geometry")
+    require(all(k >= 1 for k in ks), "period contains fewer than two cores")
+    periods = tuple(1 << (k + ell) for k in ks)
+    spectators = range(1 << spectator_width)
+    width = spectator_width + sum(k + ell for k in ks)
+    local_width = ell + 2
+    mask = (1 << payload_width) - 1
+    positions = list(itertools.product(spectators, *map(range, periods)))
+    index = {position: i for i, position in enumerate(positions)}
+
+    def global_key(position):
+        z, *point = position
+        return (bits(z, spectator_width) if spectator_width else "") + "".join(
+            bits(x, k + ell) for x, k in zip(point, ks)
+        )
+
+    payloads = [bits((i * 37 + 11) & mask, payload_width) for i in range(len(positions))]
+    source = "".join(value + "#" for value in payloads)
+    coordinates = "0" * spectator_width + "&" + "".join(
+        "@" + "0" * k + "#" + "0" * ell + ";" for k in ks
+    )
+    expected_copies = []
+    targets = {}
+    fanout = {position: 0 for position in positions}
+    # This is destination-first interval expansion, independent of source
+    # predicates, first-face prefix flags, and suffix odometers in Program.
+    for z in spectators:
+        for core in itertools.product(*(range(1 << k) for k in ks)):
+            for face in range(len(ks)):
+                for side in (0, 1):
+                    intervals = []
+                    for axis in range(len(ks)):
+                        if axis < face:
+                            intervals.append((a, length - a))
+                        elif axis == face:
+                            intervals.append((0, a) if side == 0 else (length - a, length))
+                        else:
+                            intervals.append((0, length))
+                    for local in itertools.product(*(range(hi - lo + 2 * b) for lo, hi in intervals)):
+                        point = tuple(
+                            (c * length + lo - b + off) % period
+                            for c, (lo, _), off, period in zip(core, intervals, local, periods)
+                        )
+                        position = (z, *point)
+                        key = (bits(z, spectator_width) if spectator_width else "")
+                        key += "".join(bits(c, k) for c, k in zip(core, ks))
+                        key += "".join("1" if axis == face else "0" for axis in range(len(ks)))
+                        key += str(side)
+                        key += "".join(bits(off, local_width) for off in local)
+                        key += global_key(position)
+                        expected_copies.append((key, payloads[index[position]]))
+                        fanout[position] += 1
+                    for point_local in itertools.product(*(range(lo, hi) for lo, hi in intervals)):
+                        position = (z, *(c * length + x for c, x in zip(core, point_local)))
+                        key = global_key(position)
+                        require(key not in targets, "destination partition repeated target")
+                        targets[key] = bits((index[position] * 19 + 7) & mask, payload_width)
+    # Deliberately reverse the input: physical radix must restore global order.
+    returns = "".join(key + "#" + value + "#" for key, value in reversed(sorted(targets.items())))
+    final = "".join(
+        targets.get(global_key(position), "".join("1" if x == "0" else "0" for x in payload)) + "#"
+        for position, payload in zip(positions, payloads)
+    )
+    constants = tuple(bits(x, local_width) for x in (length, a, b))
+    return {
+        "ks": ks, "ell": ell, "a": a, "b": b, "P": payload_width,
+        "spectator_width": spectator_width, "source": source,
+        "coordinates": coordinates, "constants": constants, "returns": returns,
+        "copies": sorted(expected_copies), "final": final, "targets": targets,
+        "M": len(positions), "B": width, "K": 2 * width + 3 * len(ks) + 1,
+        "C": len(expected_copies), "Q": len(targets), "fanout": fanout,
+    }
+
+
+def program(case, returns=None):
+    return Program(
+        case["source"], case["coordinates"], *case["constants"],
+        returns=case["returns"] if returns is None else returns,
+    )
+
+
+def totals(machine):
+    bill = machine.ledger()
+    return {
+        "actions": sum(sum(row.get(key, 0) for key in ("read", "write", "move")) for row in bill.values()),
+        "moves": sum(row.get("move", 0) for row in bill.values()),
+        "retained_cells": sum(row["retained_cells"] for row in bill.values()),
+        "roles": len(bill),
+    }
+
+
+def run_case(case):
+    machine = program(case)
+    require(machine.phase == "input", "wrong phase at entry")
+    machine.gather()
+    gathered = records(machine.saved.inspect())
+    require(sorted(gathered) == case["copies"], "physical gather differs from destination-first oracle")
+    dense_and_emit = totals(machine)
+    # Include exact zero-copy and wrap behavior, not just total copy counts.
+    require(any(n == 0 for n in case["fanout"].values()), "fixture has no center control")
+    if case["b"]:
+        require(max(case["fanout"].values()) == 2 ** len(case["ks"]), "corner fanout not exercised")
+    machine.sort(machine.saved)
+    require(records(machine.saved.inspect()) == case["copies"], "physical radix output is not sorted exactly")
+    sorted_bill = totals(machine)
+    snapshot = machine.saved.inspect()
+    machine.core_complement_test_double()
+    require(machine.source.inspect() != case["source"], "core control did not mutate source")
+    require(machine.saved.inspect() == snapshot, "core mutation contaminated saved copies")
+    machine.merge_returns()
+    require(machine.final.inspect() == case["final"], "unique return did not preserve core interior")
+    before_erase = totals(machine)
+    retained = before_erase["retained_cells"]
+    machine.erase_work()
+    after_erase = totals(machine)
+    require(machine.final.inspect() == case["final"], "erasure damaged final output")
+    require(after_erase["retained_cells"] >= retained, "erasure falsely reclaimed retained backing")
+    require(all(t.inspect() == "" for t in machine.roles if t is not machine.final), "work erasure incomplete")
+    return {
+        "geometry": {key: case[key] for key in ("ks", "ell", "a", "b", "P", "spectator_width")},
+        "M": case["M"], "B": case["B"], "K": case["K"], "C": case["C"], "Q": case["Q"],
+        "maximum_fanout": max(case["fanout"].values()),
+        "zero_copy_sources": sum(n == 0 for n in case["fanout"].values()),
+        "gather": dense_and_emit, "gather_and_sparse_sort": sorted_bill,
+        "before_erase": before_erase, "after_erase": after_erase,
+        "output_sha256": hashlib.sha256(machine.final.inspect().encode()).hexdigest(),
+    }
+
+
+def expect_reject(action, label):
+    try:
+        action()
+    except Reject:
+        return label
+    raise RuntimeError("negative control was not rejected: " + label)
+
+
+def controls(case):
+    passed = []
+    # These malformed return streams exercise the actual physical merge.
+    target_rows = sorted(case["targets"].items())
+    def run_bad(rows):
+        stream = "".join(key + "#" + value + "#" for key, value in rows)
+        machine = program(case, stream)
+        machine.gather()
+        machine.core_complement_test_double()
+        machine.merge_returns()
+    passed.append(expect_reject(lambda: run_bad(target_rows[1:]), "missing_target"))
+    passed.append(expect_reject(lambda: run_bad(target_rows + target_rows[:1]), "duplicate_target"))
+    interior_key = next(bits(i, case["B"]) for i in range(case["M"]) if bits(i, case["B"]) not in case["targets"])
+    passed.append(expect_reject(lambda: run_bad(target_rows + [(interior_key, "0" * case["P"])]), "kept_row_return"))
+    machine = program(case)
+    passed.append(expect_reject(machine.core_complement_test_double, "core_before_copy"))
+    passed.append(expect_reject(machine.merge_returns, "return_before_core"))
+    passed.append(expect_reject(lambda: machine.source.move(2), "nonunit_head_jump"))
+    # Reverse bucket concatenation is a genuine radix mutation, not an oracle
+    # perturbation. Duplicate keys additionally check stable payload order.
+    sort_machine = program(case)
+    sort_machine.saved = Tape("mutant_sort", "10#00#01#01#10#10#00#11#")
+    sort_machine.sort(sort_machine.saved)
+    require(records(sort_machine.saved.inspect()) == [("00", "11"), ("01", "01"), ("10", "00"), ("10", "10")], "stable radix duplicate-key check")
+    mutant = program(case)
+    mutant.saved = Tape("mutant_sort", "10#00#01#01#10#10#00#11#")
+    mutant.sort(mutant.saved, reverse_buckets=True)
+    require(records(mutant.saved.inspect()) != records(sort_machine.saved.inspect()), "reversed-bucket mutation survived")
+    passed.append("reversed_bucket_order_detected")
+    passed.append("duplicate_key_stability")
+    # A stale-copy mutation after a core change has precisely different bytes.
+    stale = program(case)
+    stale.gather()
+    old = stale.saved.inspect()
+    stale.core_complement_test_double()
+    changed = Program(stale.source.inspect(), case["coordinates"], *case["constants"])
+    changed.gather()
+    require(changed.saved.inspect() != old, "copy-after-core mutation not detected")
+    passed.append("copy_after_core_detected")
+    # This static check excludes the test observer convenience call. It is not
+    # runtime enforcement of backend privacy; that boundary also needs review.
+    require(".inspect(" not in Path(__file__).with_name("tapes.py").read_text().split("class Program:", 1)[1].split("def ledger", 1)[0], "observer leaked into Program")
+    passed.append("no_observer_call_in_program")
+    return passed
+
+
+def arithmetic_controls():
+    add_mod, compare, step_binary = _tapes.add_mod, _tapes.compare, _tapes.step_binary
+    checked = 0
+    for width in range(1, 6):
+        for a in range(1 << width):
+            for b in range(1 << width):
+                left, right = Tape("a", bits(a, width)), Tape("b", bits(b, width))
+                got = compare(left, right)
+                require(got == ("less" if a < b else "greater" if a > b else "equal"), "bit comparison failure")
+                add_mod(left, right)
+                require(left.inspect() == bits((a + b) % (1 << width), width), "bit addition failure")
+                add_mod(left, right, subtract=True)
+                require(left.inspect() == bits(a, width), "bit subtraction failure")
+                step_binary(left)
+                require(left.inspect() == bits((a + 1) % (1 << width), width), "binary step failure")
+                step_binary(left, down=True)
+                require(left.inspect() == bits(a, width), "binary reverse-step failure")
+                checked += 1
+    return checked
+
+
+def source_bindings():
+    package = Path(__file__).resolve().parent
+    root = package.parents[1]
+    sources = json.loads((package / "SOURCES.json").read_text())
+    checked = []
+    for row in sources["files"]:
+        if row["usage"] == "input":
+            content = (root / row["path"]).read_bytes()
+            require(hashlib.sha256(content).hexdigest() == row["sha256"], "live source SHA256 mismatch: " + row["path"])
+            git_blob = hashlib.sha1(b"blob " + str(len(content)).encode() + b"\0" + content).hexdigest()
+            require(git_blob == row["git_blob"], "live source Git blob mismatch: " + row["path"])
+            checked.append(row["path"])
+    return checked
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--quick", action="store_true", help="only the first complete fixture")
+    parser.add_argument("--output", type=Path)
+    args = parser.parse_args()
+    cases = [fixture((1,), 4, 2, 1, 8)]
+    if not args.quick:
+        cases += [fixture((1, 1), 4, 2, 1, 8), fixture((1, 2), 3, 1, 0, 8, 1)]
+    result = {
+        "status": "PASS", "python": platform.python_version(),
+        "source_bindings": source_bindings(),
+        "arithmetic_pairs": arithmetic_controls(),
+        "fixtures": [run_case(case) for case in cases],
+        "controls": controls(cases[0]),
+        "claim": "physical gather/sort/return only; numerical halo consumer is an explicit contract; no new kappa",
+    }
+    payload = json.dumps(result, indent=2, sort_keys=True) + "\n"
+    if args.output:
+        args.output.write_text(payload)
+    print(payload, end="")
+
+
+if __name__ == "__main__":
+    main()