diff --git a/research/crt-address-streams/EXPECTED.json b/research/crt-address-streams/EXPECTED.json
new file mode 100644
index 0000000000..02b5a7c63e
--- /dev/null
+++ b/research/crt-address-streams/EXPECTED.json
@@ -0,0 +1,154 @@
+{
+  "base": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "complete_columns": [
+    [
+      {
+        "axes": [
+          [
+            3,
+            4
+          ]
+        ],
+        "columns": 3,
+        "directions": 2,
+        "rows": 2
+      },
+      {
+        "axes": [
+          [
+            3,
+            4
+          ],
+          [
+            5,
+            8
+          ]
+        ],
+        "columns": 15,
+        "directions": 2,
+        "rows": 2
+      },
+      {
+        "axes": [
+          [
+            5,
+            8
+          ],
+          [
+            3,
+            4
+          ]
+        ],
+        "columns": 15,
+        "directions": 2,
+        "rows": 1
+      },
+      {
+        "axes": [
+          [
+            3,
+            4
+          ],
+          [
+            5,
+            8
+          ],
+          [
+            7,
+            8
+          ]
+        ],
+        "columns": 105,
+        "directions": 2,
+        "rows": 1
+      }
+    ],
+    39
+  ],
+  "cost": {
+    "Phi": "99827619697/100000000000",
+    "beta": "41544341/41616125",
+    "gaps": {
+      "Phi_minus_beta": "36798102513/33292900000000000",
+      "beta_minus_D": "84903/66585800"
+    },
+    "multiplication_conversions": 3,
+    "padding_passes": 6,
+    "tau": "332353/332929"
+  },
+  "descriptor_and_prefix": [
+    {
+      "axes": [
+        [
+          3,
+          4
+        ],
+        [
+          5,
+          8
+        ]
+      ],
+      "peak_roles": 30
+    },
+    {
+      "axes": [
+        [
+          5,
+          8
+        ],
+        [
+          3,
+          4
+        ]
+      ],
+      "peak_roles": 30
+    },
+    {
+      "axes": [
+        [
+          3,
+          4
+        ],
+        [
+          5,
+          8
+        ],
+        [
+          7,
+          8
+        ]
+      ],
+      "peak_roles": 30
+    }
+  ],
+  "inverse_units": {
+    "cases": 2176,
+    "peak_roles": 9
+  },
+  "rejection_controls": {
+    "controls": 16,
+    "peak_roles": 39
+  },
+  "runtime_files": 8,
+  "schema": 1,
+  "shear_geometry": [
+    {
+      "inverse": false,
+      "peak_roles": 10
+    },
+    {
+      "inverse": true,
+      "peak_roles": 10
+    }
+  ],
+  "source_controls": 4,
+  "source_head": "240597ed313fc2854c0462b23c89dc3bae72aaf5",
+  "typed_plan": {
+    "address_bits": 5,
+    "padded_records": 32,
+    "peak_roles": 39,
+    "production": false,
+    "record_bits": 36,
+    "source_records": 15
+  }
+}
diff --git a/research/crt-address-streams/NETWORK-SOURCES.json b/research/crt-address-streams/NETWORK-SOURCES.json
new file mode 100644
index 0000000000..efd965ec0f
--- /dev/null
+++ b/research/crt-address-streams/NETWORK-SOURCES.json
@@ -0,0 +1,56 @@
+{
+  "head": "240597ed313fc2854c0462b23c89dc3bae72aaf5",
+  "files": [
+    {
+      "path": "research/physical-gaussian-tensor/tensor_sources.py",
+      "sha256": "cba69b2bc93b7dabbffdbdf07fb41130fde5d65a8f4d344ade52d3a326e30ac0",
+      "size": 9250,
+      "git_blob": "00edf5a03fad4ed69891dd0ca4a6909bd68ef4cf"
+    },
+    {
+      "path": "research/physical-gaussian-tensor/tensor_router.py",
+      "sha256": "cf6d7c58396517d15a28f836676d1da679b68796b48b0f780f6131c8a1d2b2fa",
+      "size": 7709,
+      "git_blob": "6f5177cfa1bd03f145527c6ad5ca1ddef74716fd"
+    },
+    {
+      "path": "research/physical-gaussian-tensor/tensor_fixture.py",
+      "sha256": "f699d1c52334f42fe548b71c199a79381a980fb351c77515acd107f848cf100b",
+      "size": 3429,
+      "git_blob": "83a40a9ada87ae94cadc1ed2ddaa11c482c1d318"
+    },
+    {
+      "path": "research/physical-gaussian-tensor/inputs/chirp-export.tar.gz",
+      "sha256": "931ed8c764ea6cc592cb59ae93f8284184139a4d174752fb80f7a42762b2c0ad",
+      "size": 19129822,
+      "git_blob": "6087d9a1b3d7dd6c74fe2f9d37ca8aa52ae30fed"
+    },
+    {
+      "path": "research/physical-gaussian-tensor/inputs/expansion-export.tar.gz",
+      "sha256": "05146ca4feabe3dde0ab57aaea3eff9f218933562ba5b5c80bb256a247c144c7",
+      "size": 19199290,
+      "git_blob": "cde9ea4f1103de30e035eaaad4402f69769ae76d"
+    },
+    {
+      "path": "research/physical-gaussian-tensor/inputs/headroom-source.tar",
+      "sha256": "49fd9c1d28809795d109003b4af8d667e22bbc950a75820cf7fb9986d8ac74c6",
+      "size": 153600,
+      "git_blob": "c6feb0678519269b7e3156ba8ea48a40840017f2"
+    },
+    {
+      "path": "research/physical-gaussian-tensor/tensor_plan.py",
+      "sha256": "474730f42fcd2bd24720af4e08c71fb51cc374c3e16b8b6d7e565900f1a9e7c3",
+      "size": 12079,
+      "git_blob": "239caba2d2ccf2640c36d377949df3fb6a920cf0"
+    },
+    {
+      "path": "research/physical-gaussian-tensor/PROOF.md",
+      "size": 13933,
+      "sha256": "1e3450344552e744e0187cf1115c7b470bbe1babc9a2414586ff8ffc8f84476e",
+      "git_blob": "0f59178830599efa2c689627664245f0ac04f959"
+    }
+  ],
+  "repository": "CrocSwap/integer-mult-bounds",
+  "source_pr": 3935,
+  "policy": "Exact frozen source bytes; download outside the checkout or supply the same authenticated offline source tree. Never regenerate or modify these predecessors."
+}
diff --git a/research/crt-address-streams/PROOF.md b/research/crt-address-streams/PROOF.md
new file mode 100644
index 0000000000..479a2b727b
--- /dev/null
+++ b/research/crt-address-streams/PROOF.md
@@ -0,0 +1,178 @@
+# Encoded coefficient-address conversion
+
+Tekalign (tekuuu), with substantial OpenAI Codex assistance. Apache-2.0.
+Base: `20ecf2891d80b5acf18d980b2164fb44ea7faa90`.
+
+## Statement and exact interface
+
+Let D≥1, pairwise coprime odd integers s_i≥3, and powers of two t_i>s_i
+be given on canonical little-endian Count tapes. Put S=∏s_i, T=∏t_i,
+n=log₂T, P_i=∏_{j<i}s_j and μ_i=P_i⁻¹ mod s_i. A payload contains C≥1
+rows, each of S consecutive opaque R≥1-bit records. Borrowed ports stand at
+their left origin. Forward conversion moves record k to the natural tensor
+address with digits b_i=μ_i k mod s_i; the final axis is contiguous. Inverse
+conversion moves that record back to ordinary coefficient k. All R bits of
+every record and every row are carried together. Output is a distinct owned
+port, which the consumer must clear and erase before reuse. The implementation
+restores borrowed bytes/heads and empties its scratch and routing descendants
+on successful return. Checked malformed metadata/payload exits also clean their
+owned scratch. This is not an interrupted-child recovery protocol.
+
+`Converter.run_plan` accepts the actual, unchanged PR3935 `TensorPlan`, compiled
+at `240597ed313fc2854c0462b23c89dc3bae72aaf5`. It extracts its packed axis rows
+and checks its source product, padded product and address width against the
+computed shape. The default record width is exactly `plan.record_bits`.
+This is a typed layout bridge, not a call of the numerical tensor engine.
+A TensorPlan need not have coprime source lengths; the new adapter rejects such
+a plan. The executable typed witness has s=(3,5), t=(4,8), p=16 and is explicitly
+nonproduction. Its 15 source records and 32 padded records match the real plan.
+
+## Algebra and padded extension
+
+This algebra is inherited from source08 (lines 216–283), following
+Agarwal–Cooley; the new result is the encoded implementation and its complete
+routing bill. The map x↦∏x_i^μ_i is a cyclic-group isomorphism because each μ_i
+is a unit and the s_i are coprime. Therefore it preserves cyclic convolution.
+Writing k=Σa_iP_i, its i-th coordinate is
+
+    b_i = a_i + μ_i Σ_{j<i} a_j P_j (mod s_i).
+
+Terms with j>i vanish modulo s_i; μ_iP_i=1. Forward updates run in descending
+i, so lower coordinates are still original. Inverse updates run in ascending
+i and subtract the same expression from already recovered lower coordinates.
+
+On the full padded box, use offset zero whenever a lower control is invalid.
+For a valid lower prefix, rotate only [0,s_i), fixing [s_i,t_i). Each step is
+a bijection preserving the valid box and its complement, including arbitrary
+nonzero payloads on invalid prefixes and target tails. Consequently initially
+zero padding stays zero. Cropping checks every discarded bit is zero; it does
+not silently throw away nonzero information.
+
+The offset producer enumerates physical lower prefixes in natural axis order
+(the last lower axis varies fastest), using a single packed address tape.
+Its integer arithmetic forms Σa_jP_j and multiplies by μ_i before taking its
+residue. No metadata cardinality is decoded into a host integer. Modular inverse
+uses the binary extended-gcd invariants u≡ax, v≡ay mod m, 0≤x,y<m for odd m.
+Even operands halve, adding m before halving an odd coefficient; odd differences
+subtract modulo m. Each subtraction followed by halving reduces the positive
+operands. A unit reaches 1. A nonunit reaches equal operands greater than 1
+and rejects. Computing inverses for every prefix checks precisely the needed
+coprimality, rather than assuming primality of the supplied s_i.
+
+## Physical composition
+
+Ordinary k order is colexicographic a order. Padding first enumerates the full
+colex box. A single full-support router then reverses the order of the axis
+fields, retaining little-endian bit order inside each field. It moves old bit
+position P+j to n-P-width+j. The descriptor is sorted by old position and uses
+the unchanged fixed-width `router_metadata.write_pair` codec. The inverse
+map is separately compiled and sorted: unequal field widths do not in general
+give an involution on bit positions.
+
+In natural padded order, each controlled shift splits its target into the
+first s_i-offset positions, the remaining offset positions, and the invalid
+tail. A first sequential pass writes three bucket tapes. A second emits the
+second, first and invalid buckets in that order, carrying each complete
+spectator suffix as a block. Inverse splits at offset instead. It prepares
+actual encoded offsets; there is no free shift or address oracle.
+
+The actual tensor interface is compact, so a complete conversion is:
+
+* forward: colex compact → colex padded → global field permutation →
+  descending triangular shifts → natural compact;
+* inverse: natural compact → natural padded → ascending inverse shifts →
+  inverse global permutation → colex compact.
+
+Thus each conversion pays one global router call, D shifts and **two** padding
+passes. Integer multiplication would use three conversions (two forward inputs
+and one inverse output), hence **three**, not two, global router calls. The final
+S² normalization, rounding/carry recovery and integer wrapper are not supplied.
+
+## Time invoice, including setup and restoration
+
+Write V=CTR and r_min=min t_i. With n=Θ(p), R=Θ(p), the complete conditional
+invoice per conversion is
+
+    O(V p^β log^(1+τ)p + D V + CT(n+R)
+      + C D T poly(n)/r_min + poly(p)) + fixed native compilation F_q + source setup F_src,
+
+where τ=332353/332929 and β=41544341/41616125. The polynomial degrees are fixed,
+independent of D,C and the input values. F_q is charged once to a fixed compiled
+native instance; it is not silently reconstructed at each conversion. F_src
+pays authentication, copying and extraction of the fixed pinned local source
+artifacts once per cold cohort, with their fixed storage retained separately.
+Network transport is a replay prerequisite, not a numerical tape operation.
+
+The first term is the full-support PR3935 router theorem at the exact source
+pin above (PROOF.md, “four canonical gathers”). It includes factorization into
+two involutions, sorted batches, all unchanged spectators, interval/reservoir
+selection, metadata, child recompilation and restoration. Its polynomial setup
+is retained, then absorbed only under its stated n=Θ(p) caller hypothesis.
+We inherit its B1/sparse endpoint, all-size/compiler, universal cost and bounded
+fallback premises. We neither certify those premises here nor execute its
+production-sized selected native program in the q=2 literal fixtures.
+
+Each shear pays O(V) movement, including bucket copying/erasure, full suffixes,
+row-offset copying and counter restoration. The copied offset has O(log t_i)
+length, at most a constant times the t_i target records it controls. There are
+B_i=∏_{j<i}t_j≤T/t_i prefixes. Packed metadata lookup and binary arithmetic cost
+a fixed polynomial in n per prefix, so total offset preparation is bounded by
+D T poly(n)/r_min; the displayed C factor safely includes row replication and
+row-extent setup. Shape compilation, modular inverses and descriptor compilation
+cost poly(n). Canonical binary countdowns have amortized ripple cost; fixed-role
+Count products and their explicit rewinds are charged. Logarithmic C/R setup
+is dominated by the full packet bill, since C,R≥1 and T=2^n.
+
+Padding uses a packed (s_i,width_i) page, never a fresh scan of the full six-field
+plan for each digit. Extracting all address fields, comparing bounds and returning
+the heads costs O(n) per address. Handling the opaque record costs O(R).
+Both scans therefore cost O(CT(n+R)); when n,R=Θ(p), this is O(V). Final compact
+output copies and all successful erasures add O(V+poly(n)).
+
+For the *conditional* newer caller laws D=Θ(p^(997/1000)), ell=Θ(p^(3/1000)),
+t_i∈{2^ell,2^(ell-1)}, n=Θ(p), R=Θ(p), r_min exceeds every fixed polynomial.
+Thus offset preparation is o(V), and .997 < β < Φ=.99827619697. The router's
+extra factor log^τ p is absorbed by the strictly positive gap Φ-β. The complete
+conversion is consequently O(V p^Φ log p). Three conversions obey the same
+order, but their constant and F_q/setup costs remain paid. These inequalities
+are conditional cost comparisons, not a new κ or a complete multiplication
+algorithm. The pairwise coprime lengths are explicit inputs: no claim is made
+that an old prime-generation cutoff proves their existence under newer laws.
+Source08's adjacent-swap *upper bound* O(V D²(1+ell^τ)) does not certify this
+allowance under these laws; it is not a lower bound or an impossibility theorem.
+
+## Fixed roles and backing
+
+The wrapper has 192 scratch roles and one protected output, allocated before
+entry; all numerical execution runs under sealed constructors. There are no
+D-sized host lists of runtime tapes. Axis metadata occupies O(Dn)≤O(n²) cells
+on two packed tapes. Buckets, current data, offset copies and output occupy
+O(V+n²) live cells. The finite maximum wrapper lease count is reported as an
+observation, not an all-parameter role proof. A lexically fixed inventory bounds
+simultaneous roles: shape/page ≤6, one six-field axis plus enclosing counters
+≤16, prefix preparation plus its nested axis/arithmetic ≤64, or shear/copy
+≤32, descriptor/padding ≤32, and conversion staging ≤16; even their conservative
+sum is <192. Nested arithmetic uses fixed tuples of Counts, independent of D.
+The child has its own fixed inventories, retained from its authenticated source.
+
+`Tape.clear()` erases cells but does not shrink its Python bytearray. For a
+sequence of calls, each fixed wrapper role therefore retains its largest past
+extent. Wrapper *backing* is O(max_history(V+n²)), not merely current live space.
+Add the inherited child high-water backing (including polynomial planning) and
+fixed native storage and fixed source/extraction storage separately. This is not a quantified production memory
+coefficient or a claim that all retained native backing is O(current V).
+
+## Verification scope and unresolved work
+
+The replay checks every coefficient column simultaneously as independent opaque
+basis bits, forward and inverse, on four complete shapes (including unequal
+widths and three axes), and compares directly to kμ_i mod s_i. It checks every
+padded prefix, separate descriptor directions against the unchanged codec,
+nonzero invalid shear geometry, the actual typed TensorPlan, 2,176 unit/nonunit
+inverse cases, source and receipt integrity, protected outputs, malformed inputs,
+zero-padding checks, aliases, dirty prior work and wrong-algebra/order controls.
+It checks exact exponent arithmetic independently. These are finite implementation
+checks alongside the scoped argument above, not formal verification of the
+all-size multiplication theorem. Native compilation/execution at production q,
+the inherited router theorem assumptions, prime supply, actual numerical tensor
+composition and final integer recovery remain distinct obligations.
diff --git a/research/crt-address-streams/README.md b/research/crt-address-streams/README.md
new file mode 100644
index 0000000000..63648c961b
--- /dev/null
+++ b/research/crt-address-streams/README.md
@@ -0,0 +1,96 @@
+# Encoded CRT address conversion for the physical tensor
+
+This package implements the CRT coefficient-order entrance and exit left open
+by Jose Manuel's [PR3935](https://github.com/CrocSwap/integer-mult-bounds/pull/3935),
+pinned at `240597ed313fc2854c0462b23c89dc3bae72aaf5`. It preserves source08's
+triangular CRT algebra and substitutes one **paid full-support router** for a
+quadratic sequence of adjacent-axis exchanges. Both directions include the
+two padding/cropping scans required by the actual compact tensor interface,
+all encoded offsets, complete spectator records, copies and cleanup.
+
+Under the pinned router premises and the explicit newer many-axis caller laws,
+the complete conditional conversion bill fits `O(V p^Φ log p)`,
+Φ=.99827619697. [PROOF.md](PROOF.md) states the full invoice and backing bound.
+Integer multiplication requires **three** conversions; its numerical tensor,
+prime supply, final normalization and integer recovery remain separate.
+There is **no new κ claim**, production-sized native execution or formal proof
+of the complete multiplication theorem.
+
+The implementation uses canonical Count tapes and a fixed 192-role wrapper.
+`Converter.run_plan` accepts the actual PR3935 `TensorPlan` and verifies its
+products and address width. Coprimality is checked rather than inferred from
+the type; the predecessor's repeated-(7,7) fixture is not a CRT witness.
+
+## Reproduce
+
+Base: `20ecf2891d80b5acf18d980b2164fb44ea7faa90`; Python 3.12, standard library.
+From the repository root:
+
+```sh
+python3.12 scripts/research_package.py --package research/crt-address-streams
+```
+
+The registered command explicitly downloads about 38.5 MB of **pinned external
+predecessor sources** into temporary storage. Every size, SHA256 and Git blob
+is checked; no GitHub credentials are needed. Network availability is required
+for that command. The exact files and source commit are in
+[NETWORK-SOURCES.json](NETWORK-SOURCES.json). This avoids duplicating large
+frozen predecessor archives in the PR. Only declared source files enter a private import tree, with a fresh bytecode
+namespace; unpinned siblings and cached bytecode in an offline tree are ignored.
+The predecessor loader independently
+checks the complete embedded exports, receipts and source-specific notices.
+
+For an already downloaded, authenticated tree with paths matching that manifest:
+
+```sh
+python3.12 -B research/crt-address-streams/verify.py --source-root /path/to/dependencies
+```
+
+Expected: `PASS_CRT_ADDRESS_STREAMS ...`. Direct replay also works from a Git-free
+source export. Neither mode writes into the package or modifies predecessors.
+Dependency source authentication/setup is outside the numerical macro and is
+explicitly disclosed; it is not free runtime arithmetic.
+
+## Evidence and limits
+
+[EXPECTED.json](EXPECTED.json) records deterministic replay coverage: every basis
+column for four complete shapes, both descriptor/conversion directions, all
+padded lower prefixes, arbitrary nonzero invalid shear cells, 2,176 independent
+unit/nonunit inverse cases, the actual compact typed-plan fixture, failure
+controls and exact cost-gap arithmetic. The wrapper peak in these fixtures is
+39 scratch leases. Finite observations do not replace the all-parameter role,
+cost or router assumptions. Python backing retains past high-water lengths;
+the proof distinguishes that from current live space.
+
+Wrong offsets, wrong shift direction and wrong field permutation are checked
+against the direct `k μ_i mod s_i` oracle. Malformed extents/metadata, nonzero
+padding, dirty prior work, internal-port aliases and unconsumed outputs reject.
+The tests use the unchanged full router with its q=2 **literal** native fixture;
+they do not execute the enormous production native instance or establish its
+universal cost premise.
+
+## Open next questions
+
+The two structured questions in [TASK.json](TASK.json) are actual numerical
+tensor composition and final integer normalization/rounding. Each names its
+first experiment and inherited blockers. Neither is discharged by this layout
+contribution. Pairwise coprime near-one lengths under the newer asymptotic laws
+also remain an explicit source premise, rather than an assertion about an old
+prime-generation cutoff.
+
+## Credit and license
+
+Prepared by Tekalign (tekuuu), with substantial OpenAI Codex assistance in design,
+code, proof and verification. New work is Apache-2.0. CRT algebra follows
+Agarwal and Cooley and the retained source08 construction; the full router and
+physical tensor interface are Jose Manuel (`jmbarrancoml`)'s PR3935, building on
+PR3619 and the predecessors pinned within its complete exports, including the original
+OpenAI manuscript, RaD/hipotures reports and Douglas Colkitt's retained work. Those sources,
+licenses and notices are unchanged. This contribution adds the actual encoded
+layout composition and full conditional cost/backing argument; it does not
+claim the predecessor's algebra or routing theorem as new work.
+
+Jose Manuel's concurrent [interface clarification](https://github.com/CrocSwap/integer-mult-bounds/discussions/3664#discussioncomment-19036660)
+confirms the direction convention, actual scalar-axis notation and the two final
+S factors for the eventual numerical sandwich. Its prospective recovery work is
+separate; this package pins the published tensor head above.
diff --git a/research/crt-address-streams/SOURCES.json b/research/crt-address-streams/SOURCES.json
new file mode 100644
index 0000000000..47203dc21d
--- /dev/null
+++ b/research/crt-address-streams/SOURCES.json
@@ -0,0 +1,24 @@
+{
+  "schema_version": 1,
+  "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "files": [
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5",
+      "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0"
+    },
+    {
+      "path": "upstream/build/sections/08-assembly.tex",
+      "usage": "input",
+      "git_blob": "337810a1d9a58a2ecf14123420923c039ba322a6",
+      "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81",
+      "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+    }
+  ]
+}
diff --git a/research/crt-address-streams/TASK.json b/research/crt-address-streams/TASK.json
new file mode 100644
index 0000000000..fa5955be74
--- /dev/null
+++ b/research/crt-address-streams/TASK.json
@@ -0,0 +1,75 @@
+{
+  "schema_version": 1,
+  "task_id": "coverage-law-change",
+  "priority_revision": 6,
+  "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "original_card": {
+    "id": "coverage-law-change",
+    "question": "Can a template or call contract leave two or more unpaid coordinates per live family?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "research/complex-local-word-ceiling/README.md",
+      "research/idle-axis-hosting/PROOF.md",
+      "certificates/selected-result.json"
+    ],
+    "methods": [
+      "State a replacement for the coverage identity (mass = 72W + 64N) and the contract change that realizes it, with its implementation cost.",
+      "Find an obstruction: show which data-endpoint obligation forces exactly one unpaid coordinate in the current template."
+    ],
+    "acceptance_gate": "An explicit replacement identity, verified on a small complete instance with dirty inputs, priced with ceiling.ceiling(unpaid=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/complex-local-word-ceiling/verify.py"
+      ],
+      "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING",
+      "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.",
+      "scope": "Positive control and planning budget only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Explain where the single unpaid coordinate per family comes from in the hosted template; propose one change and price it. Ideal budget: two unpaid coordinates per family is 3.77x (levers.py).",
+    "bottleneck_link": "The deficit is one coordinate per family minus the centre charge; doubling unpaid coordinates per family scales it directly.",
+    "allowed_variations": [
+      "One template change or one endpoint-contract change.",
+      "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."
+    ],
+    "scope_change_triggers": [
+      "Counting a coordinate as unpaid while leaving it unadvanced in the data endpoint.",
+      "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts."
+    ],
+    "overlap_terms": [
+      "coverage identity",
+      "unpaid coordinate",
+      "deficit law",
+      "W - 64N"
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Complete encoded CRT coefficient-address conversion for the actual PR3935 compact physical tensor interface, replacing quadratic adjacent-axis field reversal with one paid global router per conversion.",
+  "scope_change_reason": "OS seed44 selects structural decoder/layout research. The coverage-law card is retained as catalogue provenance; this distinct layout obligation is explicitly left open in PR3935 and fits the live physical-completion handoff.",
+  "bottleneck_link": "Close the CRT entrance and exit layout obligation under the newer many-axis caller laws while retaining all physical router costs; this does not supply the numerical tensor or integer recovery.",
+  "budget_minutes": 120,
+  "stop_rule": "Stop after one complete encoded bidirectional converter, independent coefficient/geometry controls, a full conditional invoice and source/export verification. If the favorable full cost misses the retained allowance, record that failure instead of extending construction.",
+  "outcome": "completed",
+  "evidence": "PROOF.md; EXPECTED.json; verify.py",
+  "author": "Tekalign (tekuuu)",
+  "ai_assistance": "Substantial OpenAI Codex assistance in design, implementation, proof drafting, independent finite oracles and verification.",
+  "open_questions": [
+    {
+      "question": "Compose the encoded converter with the actual numerical Tensor input/output rather than only its typed layout plan.",
+      "why_it_matters": "The layout bridge alone does not execute a complete numerical convolution.",
+      "first_step": "Feed two converted coprime-axis compact inputs through the pinned tensor and compare the returned inverse layout with a direct cyclic convolution on a finite fixture.",
+      "blocked_by": "Inherited numerical tensor and native endpoint premises; no production execution claimed here."
+    },
+    {
+      "question": "Supply final integer normalization and exact rounding/carry return.",
+      "why_it_matters": "CRT address conversion preserves coefficients but does not finish integer multiplication.",
+      "first_step": "Bind the source08 two S scalings to the actual returned word format and derive the complete error/rounding invoice.",
+      "blocked_by": "Actual numerical tensor output error and scaling contracts."
+    }
+  ],
+  "assignment_seed": 44,
+  "track": "structural-decoder",
+  "source_pr": 3935,
+  "source_head": "240597ed313fc2854c0462b23c89dc3bae72aaf5"
+}
diff --git a/research/crt-address-streams/VALIDATION.md b/research/crt-address-streams/VALIDATION.md
new file mode 100644
index 0000000000..91f0f31c0d
--- /dev/null
+++ b/research/crt-address-streams/VALIDATION.md
@@ -0,0 +1,37 @@
+# Author replay receipts
+
+Base: `20ecf2891d80b5acf18d980b2164fb44ea7faa90`.
+Scientific code freeze: `bfa957212107a9c772ce9ca3f96dade8efdbe988`.
+External cohort: PR3935, `240597ed313fc2854c0462b23c89dc3bae72aaf5`;
+all eight files have size, SHA256 and Git blob pins in NETWORK-SOURCES.json.
+Python: CPython 3.12.14, Linux. No scientific input or predecessor was changed.
+
+Passed the direct cold replay using the authenticated offline source tree:
+
+```sh
+python3.12 -B research/crt-address-streams/verify.py --source-root /path/to/dependencies
+```
+
+Result: `PASS_CRT_ADDRESS_STREAMS {"columns": 138, "controls": 20,
+"inverse_cases": 2176, "wrapper_peak": 39}`. EXPECTED.json is the complete
+replay receipt, including the actual typed TensorPlan and finite domains.
+
+The committed scientific export passed the repository's export integrity check.
+The same replay passed with `-O -B`, an empty executable PATH, no Git repository,
+a read-only package/dependency tree, and a deliberate unpinned `crt_shape.py`
+import-shadow trap in the dependency tree. All 33 frozen files, including the
+trap and unrelated cached predecessor bytecode, were unchanged afterward.
+This checks the source isolation as well as the finite numerical obligations.
+
+The ready registered command uses `--fetch` and independently authenticates the
+same source bytes. Fresh local network attempts encountered a truncated large
+response and TLS handshake timeouts before completing the source download.
+They did **not** reach or fail a mathematical check. The bounded range downloader
+retains exact per-range checks, complete hashes and failure propagation. Hosted
+CI transport/replay status must be read separately; it is not asserted here.
+An authenticated offline source-tree replay is supported for this reason.
+
+The metadata/pin check passed. No repository-wide historical suite was needed:
+this isolated package changes neither shared runtime nor selected construction.
+Finite certificates and the scoped argument do not prove the inherited universal
+router/native premises or the complete integer multiplication theorem.
diff --git a/research/crt-address-streams/VERIFY.json b/research/crt-address-streams/VERIFY.json
new file mode 100644
index 0000000000..a0e510f13d
--- /dev/null
+++ b/research/crt-address-streams/VERIFY.json
@@ -0,0 +1,21 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "upstream/build/sections/08-assembly.tex"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py",
+        "--fetch"
+      ],
+      "timeout_seconds": 600,
+      "checks": "Exact pinned actual tensor cohort; all source columns in both directions, padded geometry, modular inverses, typed plan, failure controls and exact cost arithmetic. Downloads pinned external source files into temporary storage."
+    }
+  ]
+}
diff --git a/research/crt-address-streams/check_crt_cost.py b/research/crt-address-streams/check_crt_cost.py
new file mode 100644
index 0000000000..bbee94cc1d
--- /dev/null
+++ b/research/crt-address-streams/check_crt_cost.py
@@ -0,0 +1,12 @@
+"""Exact exponent identities; all-size cost argument is in PROOF.md."""
+from fractions import Fraction as F
+
+
+def check():
+    a=F(997,1000);e=F(3,1000);tau=F(332353,332929)
+    beta=F(41544341,41616125);phi=F('0.99827619697')
+    if beta!=1-a*(1-tau) or not a<beta<phi or a+e!=1:
+        raise ValueError('complete caller exponent arithmetic')
+    gaps={'beta_minus_D':str(beta-a),'Phi_minus_beta':str(phi-beta)}
+    return dict(tau=str(tau),beta=str(beta),Phi=str(phi),gaps=gaps,
+                multiplication_conversions=3,padding_passes=6)
diff --git a/research/crt-address-streams/check_crt_runtime.py b/research/crt-address-streams/check_crt_runtime.py
new file mode 100644
index 0000000000..9651a3ca38
--- /dev/null
+++ b/research/crt-address-streams/check_crt_runtime.py
@@ -0,0 +1,331 @@
+"""Independent finite oracles; host decoding occurs only in this checker."""
+from contextlib import contextmanager
+from itertools import product
+from math import prod, gcd
+from unittest.mock import patch
+from cardinal_counts import Count
+from records import Tape
+from words import BLANK, LEFT, RIGHT, need
+from scratch_pool import ScratchPool
+from session import OuterScope, erase_marker, initialize_marker, sealed_constructors
+from tensor_router import FullRouter
+from tensor_fixture import literal_native
+from crt_converter import Converter
+from crt_shape import Shape
+from crt_descriptor import compile_descriptor
+from crt_offsets import compile_offsets
+from crt_shear import shifted
+from encoded_crt import inverse, read_offset, write_count
+
+
+def tape(bits=()):
+    out = Tape()
+    for bit in bits:
+        out.append(bit)
+    out.rewind()
+    return out
+
+
+def image(value):
+    return bytes(value.cells), value.head
+
+
+def read(t):
+    t.rewind()
+    out = []
+    while t.read() != BLANK:
+        out.append(t.read())
+        t.step(1)
+    t.rewind()
+    return out
+
+
+def value(count):
+    return sum(b << i for i, b in enumerate(read(count.tape)[:-1]))
+
+
+def consume(t):
+    t.clear()
+    erase_marker(t)
+
+
+@contextmanager
+def counts(*values):
+    objects = [Count.literal(v) for v in values]
+    try:
+        yield objects
+    finally:
+        for obj in reversed(objects):
+            obj.close()
+
+
+def shape_tape(axes):
+    result = tape()
+    for pair in axes:
+        with counts(*pair) as fields:
+            for field in fields:
+                write_count(field, result)
+    result.rewind()
+    return result
+
+
+def expect_failure(operation, phrase=None):
+    try:
+        operation()
+    except ValueError as error:
+        need(phrase is None or phrase in str(error), 'expected scoped rejection: '+str(error))
+        return
+    raise ValueError('negative control accepted')
+
+
+def blank_engine(engine):
+    need(engine.closed and not engine.pool.live and engine.current is None, 'complete CRT ownership return')
+    engine.idle()
+    for obj in (engine, engine.router, engine.router.router):
+        need(not obj.pool.live and obj.closed, 'complete physical descendant return')
+        for t in obj.pool.tapes:
+            need(t.head == 1 and all(b == BLANK for b in t.cells), 'blank scratch including owned origin')
+
+
+def oracle_map(axes):
+    lengths = [s for s, _ in axes]
+    prefixes = [prod(lengths[:i]) for i in range(len(axes))]
+    mapping = []
+    for k in range(prod(lengths)):
+        b = [(k*pow(P, -1, s)) % s for P, s in zip(prefixes, lengths)]
+        target = 0
+        for digit, s in zip(b, lengths):
+            target = target*s+digit
+        mapping.append(target)
+    need(sorted(mapping) == list(range(prod(lengths))), 'independent CRT bijection')
+    # Direct group law, not a forward/inverse roundtrip.
+    for k in range(prod(lengths)):
+        for l in range(prod(lengths)):
+            need(all(((k+l)*pow(P,-1,s))%s ==
+                     ((k*pow(P,-1,s))%s+(l*pow(P,-1,s))%s)%s
+                     for P,s in zip(prefixes,lengths)), 'independent cyclic group law')
+    return mapping
+
+
+def mapped(bits, mapping, width, rows, reverse=False):
+    S = len(mapping)
+    out = [0]*len(bits)
+    for row in range(rows):
+        for old,new in enumerate(mapping):
+            a,b = (new,old) if reverse else (old,new)
+            out[(row*S+b)*width:(row*S+b+1)*width] = bits[(row*S+a)*width:(row*S+a+1)*width]
+    return out
+
+
+def complete_columns():
+    receipts = []
+    engine = Converter(FullRouter(literal_native()))
+    for axes, rows in ((((3,4),),2), (((3,4),(5,8)),2),
+                       (((5,8),(3,4)),1), (((3,4),(5,8),(7,8)),1)):
+        mapping = oracle_map(axes)
+        S = len(mapping)
+        # All S basis columns are opaque record bits in one complete invocation.
+        raw = [int(j == (k+row)%S) for row in range(rows) for k in range(S) for j in range(S)]
+        for direction in (False,True):
+            source, shape = tape(raw), shape_tape(axes)
+            with counts(len(axes),16,S,rows) as params:
+                borrowed = [source,shape,*(c.tape for c in params)]
+                before = [image(t) for t in borrowed]
+                output = engine.run(source,shape,*params,inverse=direction)
+                actual = read(output)
+                need(actual == mapped(raw,mapping,S,rows,direction), 'all independent CRT source columns')
+                need(before == [image(t) for t in borrowed], 'exact borrowed CRT bytes and heads')
+                need(engine.last_counts['global_routes'] == 1 and
+                     engine.last_counts['padding_passes'] == 2 and
+                     engine.last_counts['triangular_shifts'] == len(axes), 'complete conversion obligations')
+                expect_failure(lambda: engine.run(source,shape,*params), 'consume prior CRT output')
+                consume(output)
+                blank_engine(engine)
+                source.clear();shape.clear()
+        receipts.append(dict(axes=axes,rows=rows,columns=S,directions=2))
+    return receipts,engine.pool.peak
+
+
+def descriptor_and_prefix():
+    receipts=[]
+    for axes in (((3,4),(5,8)),((5,8),(3,4)),((3,4),(5,8),(7,8))):
+        pool=ScratchPool(96)
+        source=shape_tape(axes)
+        with counts(len(axes)) as (D,):
+            with sealed_constructors(),OuterScope(pool).installed():
+                shape=Shape(source,D,pool.acquire)
+                try:
+                    widths=[t.bit_length()-1 for s,t in axes]
+                    n=sum(widths);w=max(1,(n-1).bit_length())
+                    forward={}
+                    for axis,width in enumerate(widths):
+                        lo=sum(widths[:axis]);hi=n-lo-width
+                        for j in range(width):forward[lo+j]=hi+j
+                    from router_metadata import Pairs,write_pair
+                    for inv in (False,True):
+                        desc,width=compile_descriptor(shape,pool.acquire,inv)
+                        direct={b:a for a,b in forward.items()} if inv else forward
+                        frozen=pool.acquire()
+                        for a,b in sorted(direct.items()):
+                            with counts(a,b,w) as (ca,cb,cw):write_pair(frozen,ca,cb,cw)
+                        frozen.rewind()
+                        need(read(desc)==read(frozen), 'exact frozen descriptor codec')
+                        Pairs(desc,shape.bits,width).validate(shape.bits)
+                        frozen.clear();desc.clear();width.close()
+                    for index in range(len(axes)):
+                        with counts(index) as (I,):
+                            B,offsets=compile_offsets(shape,I,pool.acquire)
+                        lower=axes[:index]
+                        expected=[]
+                        for digits in product(*(range(t) for s,t in lower)):
+                            valid=all(a<s for a,(s,t) in zip(digits,lower))
+                            P=prod(s for s,t in lower)
+                            a=sum(digit*prod(s for s,t in lower[:j]) for j,digit in enumerate(digits))
+                            expected.append((a*pow(P,-1,axes[index][0]))%axes[index][0] if valid else 0)
+                        need(value(B)==len(expected), 'complete padded lower-prefix extent')
+                        with counts(index) as (I,):
+                            modulus=shape.axis(I)
+                        for amount in expected:
+                            c=read_offset(offsets,modulus[0]);need(value(c)==amount,'independent original prefix offset');c.close()
+                        need(offsets.read()==BLANK,'complete offset control page')
+                        for c in modulus:c.close()
+                        B.close();offsets.clear()
+                finally:shape.close()
+            pool.empty()
+        source.clear();receipts.append(dict(axes=axes,peak_roles=pool.peak))
+    return receipts
+
+
+def shear_geometry():
+    # Every padded prefix/target/spectator has a distinct multi-bit record.
+    B,s,t,R=4,5,8,9
+    amounts=[1,0,4,0]
+    raw=[(record>>bit)&1 for record in range(B*t) for bit in range(R)]
+    receipts=[]
+    for reverse in (False,True):
+        pool=ScratchPool(64);source=tape(raw);offset=tape()
+        for flag,amount in zip((1,0,1,0),amounts):
+            offset.append(flag)
+            with counts(amount) as (v,):write_count(v,offset)
+        offset.rewind()
+        with counts(B,s,t,R) as params:
+            with sealed_constructors(),OuterScope(pool).installed():
+                result=shifted(source,offset,*params,pool.acquire,inverse=reverse)
+                actual=read(result);expected=[0]*len(raw)
+                for prefix in range(B):
+                    for target in range(t):
+                        new=((target+(-1 if reverse else 1)*amounts[prefix])%s) if target<s else target
+                        expected[(prefix*t+new)*R:(prefix*t+new+1)*R]=raw[(prefix*t+target)*R:(prefix*t+target+1)*R]
+                need(actual==expected,'complete shear with nonzero invalid prefixes and tails')
+                result.clear()
+            pool.empty()
+        receipts.append(dict(inverse=reverse,peak_roles=pool.peak))
+        source.clear();offset.clear()
+    return receipts
+
+
+def inverse_units():
+    total=0
+    pool=ScratchPool(64)
+    with sealed_constructors(),OuterScope(pool).installed():
+        for modulus in range(3,66,2):
+            for a in range(2*modulus):
+                with counts(a,modulus) as (A,M):
+                    if gcd(a,modulus)==1:
+                        x=inverse(A,M);need(value(x)==pow(a,-1,modulus),'independent modular inverse');x.close()
+                    else:expect_failure(lambda:inverse(A,M),'coprime CRT prefix')
+                total+=1
+    pool.empty()
+    return dict(cases=total,peak_roles=pool.peak)
+
+
+def typed_plan():
+    from tensor_plan import TensorPlan
+    source=tape([1,1,0,1,0,1])  # little-endian 3,5; ell=3
+    flags=tape([0])
+    with counts(1,3,16,2,1,16,0,1,2,1,1) as parameters:
+        plan=TensorPlan(source,flags,*parameters,Tape,production=False)
+    try:
+        need((value(plan.source_product),value(plan.target_product),value(plan.address_bits))==(15,32,5),
+             'actual TensorPlan fixture dimensions')
+        width=value(plan.record_bits)
+        raw=[(k>>j)&1 for k in range(15) for j in range(width)]
+        payload=tape(raw)
+        ports=[plan.sources,plan.flags,plan.axis_rows,*(v.tape for v in plan.fields.values()),payload]
+        before=[image(t) for t in ports]
+        engine=Converter(FullRouter(literal_native()))
+        with counts(1) as (rows,):
+            output=engine.run_plan(payload,plan,rows)
+            expected=mapped(raw,oracle_map(((3,4),(5,8))),width,1)
+            need(read(output)==expected,'actual typed tensor bridge')
+            need([image(t) for t in ports]==before,'all actual plan ports restored')
+            consume(output);blank_engine(engine)
+        payload.clear()
+        return dict(source_records=15,padded_records=32,address_bits=5,record_bits=width,
+                    peak_roles=engine.pool.peak,production=False)
+    finally:
+        plan.close();source.clear();flags.clear()
+
+
+def rejection_controls():
+    engine=Converter(FullRouter(literal_native()));total=0
+    with counts(2,16,1,1) as params:
+        good_shape=shape_tape(((3,4),(5,8)));good=tape([int(i==1) for i in range(15)])
+        def rejected(source,shape,phrase):
+            nonlocal total
+            expect_failure(lambda:engine.run(source,shape,*params),phrase)
+            blank_engine(engine);total+=1
+        for axes,phrase in ((((3,4),(3,4)),'coprime'),(((2,4),(5,8)),'odd CRT'),
+                            (((3,6),(5,8)),'power-of-two'),(((5,4),(3,4)),'strict padded')):
+            shape=shape_tape(axes);rejected(good,shape,phrase);shape.clear()
+        for raw,phrase in (([0]*14,'complete Boolean'),([0]*16,'complete CRT padding source'),
+                           ([0]*7+[RIGHT]+[0]*7,'complete Boolean')):
+            payload=tape(raw);rejected(payload,good_shape,phrase);payload.clear()
+        malformed=tape([0,0,RIGHT]);rejected(good,malformed,'canonical');malformed.clear()
+        extended=shape_tape(((3,4),(5,8)));extended.clear()
+        for bit in read(good_shape)+[1]:extended.append(bit)
+        extended.rewind();rejected(good,extended,'complete CRT source shape');extended.clear()
+        expect_failure(lambda:engine.run(good,good,*params),'external complete CRT ports');total+=1
+        expect_failure(lambda:engine.run(engine.output,good_shape,*params),'external complete CRT ports');total+=1
+        # Wrong algebra and wrong axis order are caught by a direct coefficient oracle.
+        from crt_converter import Converter as Actual
+        original=Actual.triangular
+        from crt_offsets import residue as actual_residue
+        def check_wrong():
+            out=None
+            try:
+                out=engine.run(good,good_shape,*params)
+                need(read(out)==mapped(read(good),oracle_map(((3,4),(5,8))),1,1),
+                     'direct mutant coefficient mismatch')
+            finally:
+                if out is not None:consume(out)
+        with patch('crt_offsets.residue',lambda a,m:Count.literal(0)):
+            expect_failure(check_wrong,'direct mutant');total+=1
+        with patch.object(Actual,'triangular',lambda self,shape,rows,R,inv:original(self,shape,rows,R,not inv)):
+            expect_failure(check_wrong,'direct mutant');total+=1
+        from crt_converter import compile_descriptor as actual_descriptor
+        with patch('crt_converter.compile_descriptor',lambda s,f,inv:actual_descriptor(s,f,not inv)):
+            expect_failure(check_wrong);total+=1
+        blank_engine(engine)
+        good_shape.clear();good.clear()
+    # Nonzero padding is a rejection, not silently discarded information.
+    pool=ScratchPool(64);shape_source=shape_tape(((3,4),(5,8)))
+    from crt_padding import padded
+    with counts(2,1,1) as (D,C,R):
+        payload=tape([1]*32)
+        with sealed_constructors(),OuterScope(pool).installed():
+            shape=Shape(shape_source,D,pool.acquire)
+            try:
+                expect_failure(lambda:padded(payload,shape,C,R,pool.acquire,remove=True),'zero CRT address padding')
+                total+=1
+            finally:shape.close()
+        pool.empty();payload.clear()
+    shape_source.clear()
+    # Dirty prior work is not accepted as an empty workspace.
+    dirty=Converter(FullRouter(literal_native()))
+    dirty.pool.tapes[0].write(1)
+    with counts(2,16,1,1) as params:
+        source=tape([0]*15);shape=shape_tape(((3,4),(5,8)))
+        expect_failure(lambda:dirty.run(source,shape,*params),'empty body');total+=1
+        source.clear();shape.clear()
+    return dict(controls=total,peak_roles=engine.pool.peak)
diff --git a/research/crt-address-streams/crt_converter.py b/research/crt-address-streams/crt_converter.py
new file mode 100644
index 0000000000..eec21ef3e6
--- /dev/null
+++ b/research/crt-address-streams/crt_converter.py
@@ -0,0 +1,266 @@
+"""Complete CRT coefficient order <-> compact actual tensor order.
+
+All numerical metadata stays encoded. The full-support field permutation is
+executed by the authenticated, unchanged PR3935 FullRouter, never a free oracle.
+"""
+import crt_sources
+crt_sources.activate()
+from cardinal_counts import Count, positive
+from encoded import compare, subtract
+from records import Tape
+from scratch_pool import ScratchPool
+from session import (OuterScope, borrowed_count, borrowed_tape, erase_marker,
+                     initialize_marker, sealed_constructors)
+from stream import Counter
+from tensor_router import FullRouter
+from words import BLANK, RIGHT, need
+from crt_descriptor import compile_descriptor
+from crt_offsets import compile_offsets
+from crt_padding import padded
+from crt_shape import Shape, power_two
+from crt_shear import shifted
+from crt_streams import copy_rows
+from encoded_crt import write_count
+
+
+def shape_from_plan(plan, factory):
+    from tensor_plan import TensorPlan
+    need(isinstance(plan, TensorPlan), 'actual PR3935 tensor plan')
+    output = index = remaining = None
+    try:
+        output = factory()
+        index = Count.literal(0)
+        remaining = Counter(plan.dimensions)
+        while not remaining.finished:
+            row = plan.axis(index)
+            try:
+                write_count(row.s, output)
+                write_count(row.t, output)
+            finally:
+                row.close()
+            index.increment()
+            remaining.decrement()
+        output.rewind()
+        result, output = output, None
+        return result
+    finally:
+        if output is not None:
+            output.clear()
+        if remaining is not None:
+            remaining.close()
+        if index is not None:
+            index.close()
+
+
+def repeated_offsets(source, rows, factory):
+    output = counter = None
+    source.rewind()
+    try:
+        output = factory()
+        counter = Counter(rows)
+        while not counter.finished:
+            while source.read() != BLANK:
+                symbol = source.read()
+                need(symbol in (0, 1, RIGHT), 'complete serialized CRT offset metadata')
+                output.append(symbol)
+                source.step(1)
+            source.rewind()
+            counter.decrement()
+        output.rewind()
+        result, output = output, None
+        return result
+    finally:
+        source.rewind()
+        if counter is not None:
+            counter.close()
+        if output is not None:
+            output.clear()
+
+
+class Converter:
+    def __init__(self, router):
+        need(isinstance(router, FullRouter), 'actual complete full-support CRT router')
+        self.router = router
+        self.pool = ScratchPool(192)
+        self.scope = OuterScope(self.pool)
+        self.output = Tape()
+        self.closed = True
+        self.current = None
+        self.last_counts = None
+        for tape in (*self.pool.tapes, self.output):
+            erase_marker(tape)
+
+    def idle(self):
+        self.router.idle()
+        need(self.router.closed and not self.router.pool.live and self.router.output.read() == BLANK,
+             'consumed CRT full-router output')
+
+    def replace(self, output):
+        need(output is not self.current, 'distinct owned CRT stage output')
+        self.current.clear()
+        self.current = output
+        self.current.rewind()
+
+    def route(self, shape, p, R, rows, inverse):
+        descriptor = width = returned = following = records = None
+        try:
+            descriptor, width = compile_descriptor(shape, self.pool.acquire, inverse)
+            with self.scope.suspended():
+                returned = self.router.run(borrowed_tape(self.current), borrowed_tape(descriptor),
+                    *(borrowed_count(v) for v in (shape.bits, p, shape.bits, width, R, rows)))
+            following = self.pool.acquire()
+            records = Count.product(rows, shape.padded_total)
+            copy_rows(returned, following, records, R)
+            need(returned.read() == BLANK, 'complete CRT full-router return')
+            following.rewind()
+            self.replace(following)
+            following = None
+            self.last_counts['global_routes'] += 1
+            self.last_counts['router'] = dict(self.router.last_counts)
+        finally:
+            for count in (width, records):
+                if count is not None:
+                    count.close()
+            for tape in (descriptor, following):
+                if tape is not None:
+                    tape.clear()
+            if returned is not None:
+                returned.clear()
+                erase_marker(returned)
+        self.idle()
+
+    def triangular(self, shape, rows, R, inverse):
+        index = remaining = one = None
+        try:
+            one = Count.literal(1)
+            index = Count.literal(0) if inverse else subtract(shape.dimensions, one)
+            remaining = Counter(shape.dimensions)
+            while not remaining.finished:
+                row = shape.axis(index)
+                s, t, width, _P, _mu, prior = row
+                prefix = offsets = all_offsets = before = suffix_bits = tail_bits = following = None
+                try:
+                    prefix, offsets = compile_offsets(shape, index, self.pool.acquire)
+                    all_offsets = repeated_offsets(offsets, rows, self.pool.acquire)
+                    before = Count.product(rows, prefix)
+                    after_prefix = subtract(shape.bits, prior)
+                    try:
+                        tail_bits = subtract(after_prefix, width)
+                    finally:
+                        after_prefix.close()
+                    tail = power_two(tail_bits)
+                    try:
+                        suffix_bits = Count.product(tail, R)
+                    finally:
+                        tail.close()
+                    following = shifted(self.current, all_offsets, before, s, t, suffix_bits,
+                                        self.pool.acquire, inverse)
+                    self.replace(following)
+                    following = None
+                    self.last_counts['triangular_shifts'] += 1
+                    remaining.decrement()
+                    if not remaining.finished:
+                        if inverse:
+                            index.increment()
+                        else:
+                            next_index = subtract(index, one)
+                            index.close()
+                            index = next_index
+                finally:
+                    for count in (*row, prefix, before, suffix_bits, tail_bits):
+                        if count is not None:
+                            count.close()
+                    for tape in (offsets, all_offsets, following):
+                        if tape is not None:
+                            tape.clear()
+        finally:
+            if remaining is not None:
+                remaining.close()
+            for count in (index, one):
+                if count is not None:
+                    count.close()
+
+    def run(self, payload, source_shape, dimensions, precision, record_bits, rows,
+            inverse=False, tensor_plan=None):
+        need(type(inverse) is bool, 'literal complete CRT direction')
+        source = borrowed_tape(payload)
+        shape_source = None if source_shape is None else borrowed_tape(source_shape)
+        parameters = tuple(borrowed_count(v) for v in (dimensions, precision, record_bits, rows))
+        dimensions, p, R, C = parameters
+        forbidden = (*self.pool.tapes, self.output, *self.router.pool.tapes, self.router.output,
+                     *self.router.router.pool.tapes, self.router.router.output)
+        need(source not in forbidden and (shape_source is None or shape_source not in forbidden)
+             and source is not shape_source and all(v.tape not in forbidden
+                 and v.tape is not source and v.tape is not shape_source for v in parameters),
+             'external complete CRT ports')
+        need((shape_source is None) == (tensor_plan is not None), 'one CRT shape source contract')
+        for count in parameters:
+            positive(count)
+        need(self.closed and not self.pool.live and self.output.read() == BLANK, 'consume prior CRT output')
+        self.idle()
+        for tape in (*self.pool.tapes, self.output):
+            initialize_marker(tape)
+        self.closed = False
+        self.last_counts = dict(global_routes=0, triangular_shifts=0, padding_passes=0)
+        shape = owned_shape_source = records = None
+        succeeded = False
+        try:
+            with sealed_constructors(), self.scope.installed():
+                try:
+                    if tensor_plan is not None:
+                        owned_shape_source = shape_from_plan(tensor_plan, self.pool.acquire)
+                        shape_source = owned_shape_source
+                    shape = Shape(shape_source, dimensions, self.pool.acquire)
+                    if tensor_plan is not None:
+                        need(compare(shape.bits, tensor_plan.address_bits) == 0
+                             and compare(shape.source_total, tensor_plan.source_product) == 0
+                             and compare(shape.padded_total, tensor_plan.target_product) == 0,
+                             'complete actual tensor shape binding')
+                        owned_shape_source.clear()
+                        owned_shape_source = None
+                    self.current = padded(source, shape, C, R, self.pool.acquire, natural=inverse)
+                    self.last_counts['padding_passes'] += 1
+                    if inverse:
+                        self.triangular(shape, C, R, True)
+                        self.route(shape, p, R, C, True)
+                    else:
+                        self.route(shape, p, R, C, False)
+                        self.triangular(shape, C, R, False)
+                    following = padded(self.current, shape, C, R, self.pool.acquire, remove=True, natural=not inverse)
+                    self.replace(following)
+                    self.last_counts['padding_passes'] += 1
+                    records = Count.product(C, shape.source_total)
+                    copy_rows(self.current, self.output, records, R)
+                    need(self.current.read() == BLANK, 'complete compact CRT output')
+                    self.idle()
+                    succeeded = True
+                finally:
+                    if records is not None:
+                        records.close()
+                    if self.current is not None:
+                        self.current.clear()
+                        self.current = None
+                    if owned_shape_source is not None:
+                        owned_shape_source.clear()
+                    if shape is not None:
+                        shape.close()
+                    source.rewind()
+                    if shape_source is not None and owned_shape_source is None and tensor_plan is None:
+                        shape_source.rewind()
+                    for count in parameters:
+                        count.rewind()
+                    self.pool.empty()
+        finally:
+            for tape in self.pool.tapes:
+                erase_marker(tape)
+            self.output.rewind()
+            if not succeeded:
+                self.output.clear()
+                erase_marker(self.output)
+            self.closed = True
+        return self.output
+
+    def run_plan(self, payload, plan, rows, inverse=False, record_bits=None):
+        return self.run(payload, None, plan.dimensions, plan.p,
+                        plan.record_bits if record_bits is None else record_bits, rows,
+                        inverse=inverse, tensor_plan=plan)
diff --git a/research/crt-address-streams/crt_descriptor.py b/research/crt-address-streams/crt_descriptor.py
new file mode 100644
index 0000000000..867505afc5
--- /dev/null
+++ b/research/crt-address-streams/crt_descriptor.py
@@ -0,0 +1,112 @@
+"""Exact fixed-width old-bit/new-bit descriptors for the FullRouter port."""
+import crt_sources
+crt_sources.activate()
+from cardinal_counts import Count, positive
+from encoded import subtract
+from stream import Counter
+from words import RIGHT, need
+
+
+def position_width(value):
+    positive(value)
+    one = Count.literal(1)
+    current = result = None
+    try:
+        current = subtract(value, one)
+        result = Count.literal(0)
+        while not current.zero():
+            current.divide_small(2)
+            result.increment()
+        if result.zero():
+            result.increment()
+        answer, result = result, None
+        return answer
+    finally:
+        for count in (one, current, result):
+            if count is not None:
+                count.close()
+
+
+def write_fixed(value, output, width):
+    positive(width)
+    counter = Counter(width)
+    value.rewind()
+    try:
+        while not counter.finished:
+            symbol = value.read()
+            need(symbol in (0, 1, RIGHT), 'bounded router descriptor integer')
+            output.append(0 if symbol == RIGHT else symbol)
+            if symbol != RIGHT:
+                value.step(1)
+            counter.decrement()
+        need(value.read() == RIGHT, 'router descriptor position fits')
+    finally:
+        value.rewind()
+        counter.close()
+
+
+def compile_descriptor(shape, factory, inverse=False):
+    """Colex axes -> natural axes, or its separately sorted inverse map.
+
+    Each axis retains its internal bit order. Unequal-width field reversal
+    need not be an involution as a permutation of the fixed bit positions.
+    """
+    need(type(inverse) is bool, 'literal CRT descriptor direction')
+    output = width = one = index = remaining = None
+    try:
+        output = factory()
+        width = position_width(shape.bits)
+        one = Count.literal(1)
+        index = subtract(shape.dimensions, one) if inverse else Count.literal(0)
+        remaining = Counter(shape.dimensions)
+        while not remaining.finished:
+            row = shape.axis(index)
+            _s, _t, bits, _P, _mu, old_base = row
+            new_base = leading = bit = loop = None
+            try:
+                leading = subtract(shape.bits, old_base)
+                new_base = subtract(leading, bits)
+                first_base, second_base = (new_base, old_base) if inverse else (old_base, new_base)
+                bit = Count.literal(0)
+                loop = Counter(bits)
+                while not loop.finished:
+                    first = second = None
+                    try:
+                        first = Count(first_base)
+                        second = Count(second_base)
+                        first.add(bit)
+                        second.add(bit)
+                        write_fixed(first, output, width)
+                        write_fixed(second, output, width)
+                    finally:
+                        for count in (first, second):
+                            if count is not None:
+                                count.close()
+                    bit.increment()
+                    loop.decrement()
+                remaining.decrement()
+                if not remaining.finished:
+                    if inverse:
+                        following = subtract(index, one)
+                        index.close()
+                        index = following
+                    else:
+                        index.increment()
+            finally:
+                if loop is not None:
+                    loop.close()
+                for count in (*row, new_base, leading, bit):
+                    if count is not None:
+                        count.close()
+        output.rewind()
+        result = output, width
+        output = width = None
+        return result
+    finally:
+        if output is not None:
+            output.clear()
+        if remaining is not None:
+            remaining.close()
+        for count in (width, one, index):
+            if count is not None:
+                count.close()
diff --git a/research/crt-address-streams/crt_offsets.py b/research/crt-address-streams/crt_offsets.py
new file mode 100644
index 0000000000..efb054733b
--- /dev/null
+++ b/research/crt-address-streams/crt_offsets.py
@@ -0,0 +1,73 @@
+"""Actual encoded original-lower-coordinate offsets for one triangular CRT step."""
+import crt_sources
+crt_sources.activate()
+from cardinal_counts import Count
+from encoded import compare
+from stream import Counter
+from encoded_crt import residue, write_count
+from crt_shape import Address, power_two
+
+
+def compile_offsets(shape, index, factory):
+    """Return B,metadata for all padded prefixes in physical lower-axis order."""
+    row = shape.axis(index)
+    s, _t, _width, _prefix, mu, prior_bits = row
+    before = address = output = None
+    try:
+        before = power_two(prior_bits)
+        address = Address(prior_bits, factory)
+        output = factory()
+        while not address.finished:
+            value = position = remaining = amount = None
+            valid = True
+            try:
+                value = Count.literal(0)
+                position = Count.literal(0)
+                remaining = Counter(index)
+                address.msb()
+                while not remaining.finished:
+                    lower = shape.axis(position)
+                    digit = term = None
+                    try:
+                        source_length, _padded, width, prefix, _inverse, _bits = lower
+                        digit = address.field(width, reverse=True)
+                        valid = valid and compare(digit, source_length) < 0
+                        term = Count.product(digit, prefix)
+                        value.add(term)
+                    finally:
+                        for count in (digit, term, *lower):
+                            if count is not None:
+                                count.close()
+                    position.increment()
+                    remaining.decrement()
+                address.reset()
+                if valid:
+                    product = Count.product(value, mu)
+                    try:
+                        amount = residue(product, s)
+                    finally:
+                        product.close()
+                else:
+                    amount = Count.literal(0)
+                output.append(int(valid))
+                write_count(amount, output)
+                address.increment()
+            finally:
+                if remaining is not None:
+                    remaining.close()
+                for count in (value, position, amount):
+                    if count is not None:
+                        count.close()
+        output.rewind()
+        result = before, output
+        before = output = None
+        return result
+    finally:
+        for count in row:
+            count.close()
+        if before is not None:
+            before.close()
+        if address is not None:
+            address.close()
+        if output is not None:
+            output.clear()
diff --git a/research/crt-address-streams/crt_padding.py b/research/crt-address-streams/crt_padding.py
new file mode 100644
index 0000000000..3bffe14156
--- /dev/null
+++ b/research/crt-address-streams/crt_padding.py
@@ -0,0 +1,111 @@
+"""Actual source08 colex insertion/deletion with packed-address validity scans."""
+import crt_sources
+crt_sources.activate()
+from cardinal_counts import Count, positive
+from encoded import compare, subtract
+from stream import Counter
+from words import BLANK, need
+from crt_streams import copy_record, zero_record
+from encoded_crt import read_count, write_count
+from crt_shape import Address
+
+
+def reversed_bounds(shape, factory):
+    output = one = index = remaining = None
+    try:
+        output = factory()
+        one = Count.literal(1)
+        index = subtract(shape.dimensions, one)
+        remaining = Counter(shape.dimensions)
+        while not remaining.finished:
+            row = shape.axis(index)
+            try:
+                write_count(row[0], output)
+                write_count(row[2], output)
+            finally:
+                for count in row:
+                    count.close()
+            remaining.decrement()
+            if not remaining.finished:
+                following = subtract(index, one)
+                index.close()
+                index = following
+        output.rewind()
+        result, output = output, None
+        return result
+    finally:
+        if output is not None:
+            output.clear()
+        if remaining is not None:
+            remaining.close()
+        for count in (one, index):
+            if count is not None:
+                count.close()
+
+
+def valid_address(shape, address, bounds):
+    """One O(total address bits) bound scan, including its restoration."""
+    address.reset()
+    bounds.rewind()
+    dimensions = Counter(shape.dimensions)
+    valid = True
+    try:
+        while not dimensions.finished:
+            source_length = width = digit = None
+            try:
+                source_length = read_count(bounds)
+                width = read_count(bounds)
+                digit = address.field(width)
+                valid = valid and compare(digit, source_length) < 0
+                dimensions.decrement()
+            finally:
+                for count in (source_length, width, digit):
+                    if count is not None:
+                        count.close()
+        need(bounds.read() == BLANK, 'complete compact CRT bounds')
+        return valid
+    finally:
+        dimensions.close()
+        bounds.rewind()
+        address.reset()
+
+
+def padded(source, shape, rows, record_bits, factory, remove=False, natural=False):
+    """Compact records <-> padded records in colex or natural axis order."""
+    need(type(remove) is bool, 'literal CRT padding direction')
+    need(type(natural) is bool, 'literal CRT padding axis order')
+    positive(rows)
+    positive(record_bits)
+    output = address = outer = private_bounds = None
+    source.rewind()
+    try:
+        output = factory()
+        if natural:
+            private_bounds = reversed_bounds(shape, factory)
+        bounds = private_bounds if natural else shape.bounds
+        outer = Counter(rows)
+        while not outer.finished:
+            address = Address(shape.bits, factory)
+            while not address.finished:
+                if valid_address(shape, address, bounds):
+                    copy_record(source, output, record_bits)
+                else:
+                    zero_record(source, output, record_bits, remove)
+                address.increment()
+            address.close()
+            address = None
+            outer.decrement()
+        need(source.read() == BLANK, 'complete CRT padding source extent')
+        output.rewind()
+        result, output = output, None
+        return result
+    finally:
+        source.rewind()
+        if address is not None:
+            address.close()
+        if outer is not None:
+            outer.close()
+        if output is not None:
+            output.clear()
+        if private_bounds is not None:
+            private_bounds.clear()
diff --git a/research/crt-address-streams/crt_shape.py b/research/crt-address-streams/crt_shape.py
new file mode 100644
index 0000000000..23b6cd3fec
--- /dev/null
+++ b/research/crt-address-streams/crt_shape.py
@@ -0,0 +1,210 @@
+"""Packed encoded CRT shape, checked units and fixed-width address control."""
+import crt_sources
+crt_sources.activate()
+from cardinal_counts import Count, positive
+from encoded import compare
+from stream import Counter
+from session import borrowed_tape
+from words import BLANK, LEFT, RIGHT, need
+from encoded_crt import inverse, read_count, write_count
+
+
+def power_two(exponent):
+    result = Count.literal(1)
+    counter = Counter(exponent)
+    try:
+        while not counter.finished:
+            result.multiply_small(2)
+            counter.decrement()
+        answer, result = result, None
+        return answer
+    finally:
+        counter.close()
+        if result is not None:
+            result.close()
+
+
+def binary_exponent(value):
+    positive(value)
+    result = Count.literal(0)
+    try:
+        value.msb()
+        need(value.read() == 1, 'positive power-of-two CRT field')
+        value.step(-1)
+        while value.read() != LEFT:
+            need(value.read() == 0, 'power-of-two CRT field')
+            result.increment()
+            value.step(-1)
+        value.step(1)
+        value.rewind()
+        answer, result = result, None
+        return answer
+    finally:
+        if value.read() == LEFT:
+            value.step(1)
+        value.rewind()
+        if result is not None:
+            result.close()
+
+
+class Shape:
+    """Six Count fields per axis on one tape; no growing host list of roles."""
+    def __init__(self, source, dimensions, factory):
+        self.dimensions = self.bits = self.source_total = self.padded_total = self.page = self.bounds = None
+        positive(dimensions)
+        outer = None
+        source.rewind()
+        try:
+            self.dimensions = Count(dimensions)
+            self.bits = Count.literal(0)
+            self.source_total = Count.literal(1)
+            self.padded_total = Count.literal(1)
+            self.page = factory()
+            self.bounds = factory()
+            outer = Counter(dimensions)
+            while not outer.finished:
+                s = t = width = mu = one = None
+                try:
+                    s = read_count(source)
+                    t = read_count(source)
+                    one = Count.literal(1)
+                    need(s.read() == 1 and compare(s, one) > 0, 'odd CRT source length at least three')
+                    need(compare(s, t) < 0, 'CRT source fits strict padded field')
+                    width = binary_exponent(t)
+                    mu = inverse(self.source_total, s)
+                    for count in (s, t, width, self.source_total, mu, self.bits):
+                        write_count(count, self.page)
+                    write_count(s, self.bounds)
+                    write_count(width, self.bounds)
+                    following = Count.product(self.source_total, s)
+                    self.source_total.close()
+                    self.source_total = following
+                    following = Count.product(self.padded_total, t)
+                    self.padded_total.close()
+                    self.padded_total = following
+                    self.bits.add(width)
+                    outer.decrement()
+                finally:
+                    for count in (s, t, width, mu, one):
+                        if count is not None:
+                            count.close()
+            need(source.read() == BLANK, 'complete CRT source shape')
+            self.page.rewind()
+            self.bounds.rewind()
+        except BaseException:
+            self.close()
+            raise
+        finally:
+            if outer is not None:
+                outer.close()
+            source.rewind()
+
+    def axis(self, index):
+        need(compare(index, self.dimensions) < 0, 'CRT axis index in range')
+        self.page.rewind()
+        before = Counter(index)
+        values = []
+        try:
+            while not before.finished:
+                for _ in range(6):
+                    read_count(self.page).close()
+                before.decrement()
+            for _ in range(6):
+                values.append(read_count(self.page))
+            result, values = tuple(values), []
+            return result
+        finally:
+            before.close()
+            for value in values:
+                value.close()
+            self.page.rewind()
+
+    def close(self):
+        if self.page is not None:
+            self.page.clear()
+            self.page = None
+        if self.bounds is not None:
+            self.bounds.clear()
+            self.bounds = None
+        for name in ('dimensions', 'bits', 'source_total', 'padded_total'):
+            value = getattr(self, name)
+            if value is not None:
+                value.close()
+                setattr(self, name, None)
+
+
+class Address:
+    """Fixed-width little-endian binary counter; only a carry enters control."""
+    def __init__(self, width, factory):
+        self.tape = None
+        self.finished = False
+        counter = Counter(width)
+        try:
+            self.tape = factory()
+            while not counter.finished:
+                self.tape.append(0)
+                counter.decrement()
+            self.tape.append(RIGHT)
+            self.tape.rewind()
+        except BaseException:
+            self.close()
+            raise
+        finally:
+            counter.close()
+
+    def reset(self):
+        if self.tape.read() == LEFT:
+            self.tape.step(1)
+        self.tape.rewind()
+
+    def msb(self):
+        self.reset()
+        while self.tape.read() != RIGHT:
+            self.tape.step(1)
+        self.tape.step(-1)
+
+    def increment(self):
+        need(not self.finished, 'live CRT packed address')
+        self.reset()
+        while self.tape.read() == 1:
+            self.tape.write(0)
+            self.tape.step(1)
+        if self.tape.read() == RIGHT:
+            self.finished = True
+        else:
+            need(self.tape.read() == 0, 'binary CRT packed address')
+            self.tape.write(1)
+        self.reset()
+
+    def field(self, width, reverse=False):
+        result = Count.literal(0)
+        counter = Counter(width)
+        try:
+            if not reverse:
+                borrowed_tape(result.tape).clear()
+            while not counter.finished:
+                bit = self.tape.read()
+                need(bit in (0, 1), 'complete CRT address field')
+                if reverse:
+                    result.multiply_small(2)
+                    if bit:
+                        result.increment()
+                else:
+                    result.tape.append(bit)
+                self.tape.step(-1 if reverse else 1)
+                counter.decrement()
+            if not reverse:
+                result.tape.append(RIGHT)
+                result.normalize()
+            answer, result = result, None
+            return answer
+        finally:
+            counter.close()
+            if result is not None:
+                result.close()
+
+    def close(self):
+        if self.tape is not None:
+            self.reset()
+            self.tape.clear()
+            self.tape = None
diff --git a/research/crt-address-streams/crt_shear.py b/research/crt-address-streams/crt_shear.py
new file mode 100644
index 0000000000..229e3a42de
--- /dev/null
+++ b/research/crt-address-streams/crt_shear.py
@@ -0,0 +1,70 @@
+"""Complete variable-offset CRT field rotations with protected padding tails."""
+import crt_sources
+crt_sources.activate()
+from cardinal_counts import positive
+from encoded import compare, subtract
+from crt_streams import copy_rows
+from stream import Counter
+from words import BLANK, need
+from encoded_crt import read_offset
+
+
+def shifted(source, offsets, before, modulus, padded, suffix, factory, inverse=False):
+    """Borrow B*t*S bits and B encoded offsets; return a distinct owned image."""
+    need(type(inverse) is bool, 'literal CRT shear direction')
+    need(source is not offsets, 'separate CRT payload and offsets')
+    for count in (before, modulus, padded, suffix):
+        positive(count)
+    need(compare(modulus, padded) <= 0, 'CRT valid field fits padded field')
+    tail = left = right = invalid = output = None
+    try:
+        tail = subtract(padded, modulus)
+        left = factory()
+        right = factory()
+        invalid = factory()
+        output = factory()
+        source.rewind()
+        offsets.rewind()
+        for merging in (False, True):
+            outer = Counter(before)
+            try:
+                while not outer.finished:
+                    amount = complement = None
+                    try:
+                        amount = read_offset(offsets, modulus)
+                        complement = subtract(modulus, amount)
+                        first, second = (amount, complement) if inverse else (complement, amount)
+                        if merging:
+                            copy_rows(right, output, second, suffix)
+                            copy_rows(left, output, first, suffix)
+                            copy_rows(invalid, output, tail, suffix)
+                        else:
+                            copy_rows(source, left, first, suffix)
+                            copy_rows(source, right, second, suffix)
+                            copy_rows(source, invalid, tail, suffix)
+                        outer.decrement()
+                    finally:
+                        for count in (amount, complement):
+                            if count is not None:
+                                count.close()
+                need(offsets.read() == BLANK, 'complete CRT prefix offset stream')
+                offsets.rewind()
+            finally:
+                outer.close()
+            if not merging:
+                need(source.read() == BLANK, 'complete padded CRT shear source')
+                source.rewind()
+                for tape in (left, right, invalid):
+                    tape.rewind()
+        need(left.read() == right.read() == invalid.read() == BLANK, 'complete CRT shear buckets')
+        output.rewind()
+        result, output = output, None
+        return result
+    finally:
+        source.rewind()
+        offsets.rewind()
+        for tape in (left, right, invalid, output):
+            if tape is not None:
+                tape.clear()
+        if tail is not None:
+            tail.close()
diff --git a/research/crt-address-streams/crt_sources.py b/research/crt-address-streams/crt_sources.py
new file mode 100644
index 0000000000..fa0effe0bc
--- /dev/null
+++ b/research/crt-address-streams/crt_sources.py
@@ -0,0 +1,148 @@
+"""Authenticate and open the actual PR3935 physical tensor/router cohort."""
+from contextlib import contextmanager
+from concurrent.futures import ThreadPoolExecutor
+import base64
+from hashlib import sha1, sha256
+import importlib.util
+import http.client
+import json
+import shutil
+from pathlib import Path
+import sys
+import tempfile
+import urllib.request
+import urllib.error
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+_active = None
+
+
+def authenticate():
+    for row in json.loads((HERE/'SOURCES.json').read_text())['files']:
+        if row['usage'] == 'input' and sha256((ROOT/row['path']).read_bytes()).hexdigest() != row['sha256']:
+            raise ValueError('source changed: '+row['path'])
+
+
+def activate():
+    authenticate()
+    if _active is None:
+        raise ValueError('authenticated CRT tensor cohort required')
+    return _active
+
+
+def source_manifest():
+    manifest = json.loads((HERE/'NETWORK-SOURCES.json').read_text())
+    if manifest['repository'] != 'CrocSwap/integer-mult-bounds' or manifest['head'] != '240597ed313fc2854c0462b23c89dc3bae72aaf5':
+        raise ValueError('fixed CRT tensor source identity')
+    expected = {'tensor_sources.py', 'tensor_router.py', 'tensor_fixture.py', 'tensor_plan.py',
+                'inputs/chirp-export.tar.gz', 'inputs/expansion-export.tar.gz', 'inputs/headroom-source.tar', 'PROOF.md'}
+    paths = {row['path'] for row in manifest['files']}
+    if paths != {'research/physical-gaussian-tensor/'+name for name in expected} or len(paths) != len(manifest['files']):
+        raise ValueError('exact CRT tensor dependency inventory')
+    return manifest
+
+
+def check_tree(root, manifest):
+    root = Path(root)
+    for row in manifest['files']:
+        path = root/row['path']
+        if not path.is_file() or path.is_symlink() or path.stat().st_size != row['size']:
+            raise ValueError('complete frozen tensor source: '+row['path'])
+        body = path.read_bytes()
+        blob = sha1(b'blob '+str(len(body)).encode()+b'\0'+body).hexdigest()
+        if sha256(body).hexdigest() != row['sha256'] or blob != row['git_blob']:
+            raise ValueError('frozen tensor source changed: '+row['path'])
+
+
+def fetch_tree(root, manifest):
+    for row in manifest['files']:
+        path = Path(root)/row['path']
+        path.parent.mkdir(parents=True, exist_ok=True)
+        print('FETCH_PINNED_TENSOR '+row['path'],flush=True)
+        headers={'User-Agent':'integer-mult-crt-source-replay'}
+        if row['size'] > 1048576:
+            # Bounded public byte ranges avoid partially delivered large raw
+            # or base64 responses. Every range and the complete blob are checked.
+            def part_at(start):
+                end=min(row['size'],start+1048576)-1
+                url=('https://raw.githubusercontent.com/'+manifest['repository']+'/'+manifest['head']+'/'+row['path']
+                     +'?crt-bytes='+str(start)+'-'+str(end))
+                request=urllib.request.Request(url,headers={**headers,'Range':'bytes='+str(start)+'-'+str(end)})
+                for attempt in range(2):
+                    try:
+                        with urllib.request.urlopen(request,timeout=20) as response:
+                            if response.status!=206 or response.headers.get('Content-Range')!='bytes '+str(start)+'-'+str(end)+'/'+str(row['size']):
+                                raise ValueError('exact frozen tensor byte range')
+                            part=response.read(end-start+1)
+                        if len(part)!=end-start+1:
+                            raise ValueError('complete frozen tensor byte range')
+                        return part
+                    except (urllib.error.URLError,TimeoutError,http.client.IncompleteRead):
+                        if attempt:raise
+            # Four bounded, independent ranges preserve order and exact pins.
+            # Await every worker before publishing any source file.
+            with ThreadPoolExecutor(max_workers=4) as executor:
+                body=b''.join(executor.map(part_at,range(0,row['size'],1048576)))
+        else:
+            blob_url='https://api.github.com/repos/'+manifest['repository']+'/git/blobs/'+row['git_blob']
+            with urllib.request.urlopen(urllib.request.Request(blob_url,headers=headers),timeout=30) as response:
+                encoded=response.read(2*row['size']+16384)
+            item=json.loads(encoded)
+            if item.get('sha')!=row['git_blob'] or item.get('size')!=row['size'] or item.get('encoding')!='base64':
+                raise ValueError('exact public tensor blob metadata')
+            body=base64.b64decode(''.join(item['content'].split()),validate=True)
+        if len(body) != row['size'] or sha256(body).hexdigest() != row['sha256']:
+            raise ValueError('downloaded tensor source differs: '+row['path'])
+        path.write_bytes(body)
+    check_tree(root, manifest)
+
+
+@contextmanager
+def opened(source_root=None, fetch=False):
+    global _active
+    authenticate()
+    if _active is not None or 'tensor_sources' in sys.modules or 'cardinal_counts' in sys.modules:
+        raise ValueError('cold CRT tensor namespace')
+    if source_root is not None and fetch:
+        raise ValueError('choose an offline source root or a fresh fetched tree')
+    manifest = source_manifest()
+    if source_root is None and not fetch:
+        raise ValueError('supply --source-root or explicitly permit --fetch')
+    temporary = tempfile.TemporaryDirectory(prefix='crt-tensor-dependency-')
+    private_root = Path(temporary.name)/'sources'
+    old_path = sys.path[:]
+    old_cache, old_write = sys.pycache_prefix, sys.dont_write_bytecode
+    module = None
+    try:
+        if fetch:
+            fetch_tree(private_root, manifest)
+        else:
+            check_tree(source_root, manifest)
+            # Only declared source bytes enter sys.path. Ignore unpinned sibling
+            # modules/caches in an offline cache; never modify that cache.
+            for row in manifest['files']:
+                target=private_root/row['path']
+                target.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copyfile(Path(source_root)/row['path'], target)
+        check_tree(private_root, manifest)
+        sys.pycache_prefix = str(Path(temporary.name)/'empty-bytecode')
+        sys.dont_write_bytecode = True
+        package = private_root/'research/physical-gaussian-tensor'
+        spec = importlib.util.spec_from_file_location('tensor_sources', package/'tensor_sources.py')
+        module = importlib.util.module_from_spec(spec)
+        sys.modules['tensor_sources'] = module
+        spec.loader.exec_module(module)
+        with module.opened() as state:
+            _active = state
+            sys.path[:0] = [str(HERE), str(package)]
+            try:
+                yield state
+            finally:
+                _active = None
+    finally:
+        sys.path[:] = old_path
+        sys.pycache_prefix, sys.dont_write_bytecode = old_cache, old_write
+        if module is not None and sys.modules.get('tensor_sources') is module:
+            del sys.modules['tensor_sources']
+        if temporary is not None:
+            temporary.cleanup()
diff --git a/research/crt-address-streams/crt_streams.py b/research/crt-address-streams/crt_streams.py
new file mode 100644
index 0000000000..61d10d7e99
--- /dev/null
+++ b/research/crt-address-streams/crt_streams.py
@@ -0,0 +1,42 @@
+"""Owned countdowns on complete opaque Boolean records, including failure exit."""
+import crt_sources
+crt_sources.activate()
+from stream import Counter
+from words import need
+
+
+def copy_record(source, output, width):
+    counter = Counter(width)
+    try:
+        while not counter.finished:
+            bit = source.read()
+            need(bit in (0, 1), 'complete Boolean CRT payload record')
+            output.append(bit)
+            source.step(1)
+            counter.decrement()
+    finally:
+        counter.close()
+
+
+def copy_rows(source, output, rows, width):
+    counter = Counter(rows)
+    try:
+        while not counter.finished:
+            copy_record(source, output, width)
+            counter.decrement()
+    finally:
+        counter.close()
+
+
+def zero_record(source, output, width, remove=False):
+    counter = Counter(width)
+    try:
+        while not counter.finished:
+            if remove:
+                need(source.read() == 0, 'zero CRT address padding')
+                source.step(1)
+            else:
+                output.append(0)
+            counter.decrement()
+    finally:
+        counter.close()
diff --git a/research/crt-address-streams/encoded_crt.py b/research/crt-address-streams/encoded_crt.py
new file mode 100644
index 0000000000..054270cd82
--- /dev/null
+++ b/research/crt-address-streams/encoded_crt.py
@@ -0,0 +1,126 @@
+"""Fixed-role encoded metadata and odd-modulus inverse for the CRT layout.
+
+Tekalign, with substantial OpenAI Codex assistance. Apache-2.0.
+Uses the retained Count algorithms; no unbounded cardinality is decoded.
+"""
+import crt_sources
+crt_sources.activate()
+from cardinal_counts import Count, positive
+from encoded import compare, divide, subtract
+from session import borrowed_tape
+from words import BLANK, RIGHT, need
+
+
+def write_count(value, target):
+    value.rewind()
+    try:
+        while value.read() != RIGHT:
+            bit = value.read()
+            need(bit in (0, 1), 'binary CRT metadata count')
+            target.append(bit)
+            value.step(1)
+        target.append(RIGHT)
+    finally:
+        value.rewind()
+
+
+def read_count(source):
+    result = Count.literal(0)
+    first, multiple, last = True, False, 0
+    try:
+        borrowed_tape(result.tape).clear()
+        while source.read() in (0, 1):
+            last = source.read()
+            multiple = not first
+            first = False
+            result.tape.append(last)
+            source.step(1)
+        need(not first and (not multiple or last == 1) and source.read() == RIGHT,
+             'canonical complete CRT metadata count')
+        source.step(1)
+        result.tape.append(RIGHT)
+        result.rewind()
+        answer, result = result, None
+        return answer
+    finally:
+        if result is not None:
+            result.close()
+
+
+def residue(value, modulus):
+    quotient, remainder = divide(value, modulus)
+    quotient.close()
+    return remainder
+
+
+def difference(first, second, modulus):
+    if compare(first, second) >= 0:
+        return subtract(first, second)
+    delta = subtract(second, first)
+    try:
+        return subtract(modulus, delta)
+    finally:
+        delta.close()
+
+
+def inverse(value, modulus):
+    """Return a^(-1) mod m for odd m>=3, rejecting nonunits."""
+    positive(modulus)
+    need(modulus.read() == 1, 'odd CRT modulus')
+    u = v = x = y = one = None
+    try:
+        one = Count.literal(1)
+        need(compare(modulus, one) > 0, 'CRT modulus at least three')
+        u = residue(value, modulus)
+        v = Count(modulus)
+        need(not u.zero(), 'coprime CRT prefix')
+        x = Count.literal(1)
+        y = Count.literal(0)
+        while compare(u, one) != 0 and compare(v, one) != 0:
+            need(compare(u, v) != 0, 'coprime CRT prefix')
+            while u.read() == 0:
+                u.divide_small(2)
+                if x.read() == 1:
+                    x.add(modulus)
+                need(x.divide_small(2) == 0, 'exact CRT inverse halving')
+            while v.read() == 0:
+                v.divide_small(2)
+                if y.read() == 1:
+                    y.add(modulus)
+                need(y.divide_small(2) == 0, 'exact CRT inverse halving')
+            if compare(u, one) == 0 or compare(v, one) == 0:
+                break
+            need(compare(u, v) != 0, 'coprime CRT prefix')
+            if compare(u, v) > 0:
+                following = subtract(u, v)
+                u.close()
+                u = following
+                following = difference(x, y, modulus)
+                x.close()
+                x = following
+            else:
+                following = subtract(v, u)
+                v.close()
+                v = following
+                following = difference(y, x, modulus)
+                y.close()
+                y = following
+        return Count(x if compare(u, one) == 0 else y)
+    finally:
+        for count in (u, v, x, y, one):
+            if count is not None:
+                count.close()
+
+
+def read_offset(source, modulus):
+    flag = source.read()
+    need(flag in (0, 1), 'binary CRT prefix validity flag')
+    source.step(1)
+    value = read_count(source)
+    try:
+        need(compare(value, modulus) < 0 and (flag or value.zero()), 'bounded CRT prefix offset')
+        result, value = value, None
+        return result
+    finally:
+        if value is not None:
+            value.close()
diff --git a/research/crt-address-streams/verify.py b/research/crt-address-streams/verify.py
new file mode 100644
index 0000000000..e69ebb71d4
--- /dev/null
+++ b/research/crt-address-streams/verify.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""Cold, source-authenticated finite CRT replay. No Git or working-tree writes."""
+import argparse
+import ast
+from hashlib import sha256
+import json
+from pathlib import Path
+import crt_sources
+
+HERE=Path(__file__).resolve().parent
+
+
+def need(test,message):
+    if not test:
+        raise ValueError(message)
+
+
+def static_contract():
+    files=sorted(HERE.glob('crt_*.py'))+[HERE/'encoded_crt.py']
+    runtime=[p for p in files if p.name!='crt_sources.py']
+    for p in runtime:
+        tree=ast.parse(p.read_text())
+        for node in ast.walk(tree):
+            if isinstance(node,ast.Attribute):
+                need(node.attr not in ('cells','head','inspect','__dict__'), 'no runtime host state decoding')
+            if isinstance(node,ast.Call) and isinstance(node.func,ast.Name) and node.func.id=='range':
+                need(len(node.args)==1 and isinstance(node.args[0],ast.Constant) and node.args[0].value==6,
+                     'only fixed six-field runtime loop')
+    return len(runtime)
+
+
+def source_controls():
+    import copy
+    import sys
+    import tempfile
+    manifest=crt_sources.source_manifest()
+    row=next(r for r in manifest['files'] if r['path'].endswith('/tensor_sources.py'))
+    with tempfile.TemporaryDirectory(prefix='crt-source-controls-') as folder:
+        target=Path(folder)/row['path']
+        target.parent.mkdir(parents=True)
+        raw=Path(sys.modules['tensor_sources'].__file__).read_bytes()
+        target.write_bytes(raw)
+        single={'files':[row]}
+        crt_sources.check_tree(folder,single)
+        def rejects(m):
+            try:crt_sources.check_tree(folder,m)
+            except ValueError:return
+            raise ValueError('source-integrity negative control accepted')
+        target.write_bytes(raw[:-1]);rejects(single)
+        target.write_bytes(raw[:-1]+bytes([raw[-1]^1]));rejects(single)
+        target.write_bytes(raw)
+        wrong=copy.deepcopy(single);wrong['files'][0]['git_blob']='0'*40;rejects(wrong)
+        target.unlink();rejects(single)
+    return 4
+
+
+def main():
+    parser=argparse.ArgumentParser(description=__doc__)
+    source=parser.add_mutually_exclusive_group(required=True)
+    source.add_argument('--source-root',type=Path)
+    source.add_argument('--fetch',action='store_true')
+    parser.add_argument('--write-receipt',type=Path)
+    args=parser.parse_args()
+    from check_crt_cost import check
+    result={'schema':1,'base':'20ecf2891d80b5acf18d980b2164fb44ea7faa90',
+            'source_head':'240597ed313fc2854c0462b23c89dc3bae72aaf5',
+            'runtime_files':static_contract(),'cost':check()}
+    with crt_sources.opened(args.source_root,fetch=args.fetch):
+        import check_crt_runtime as checks
+        result['source_controls']=source_controls()
+        for name in ('complete_columns','descriptor_and_prefix','shear_geometry',
+                     'inverse_units','typed_plan','rejection_controls'):
+            result[name]=getattr(checks,name)()
+        # Check the exact offline dependency bytes again after execution.
+        if args.source_root is not None:
+            crt_sources.check_tree(args.source_root,crt_sources.source_manifest())
+    normalized=json.loads(json.dumps(result))
+    if args.write_receipt is not None:
+        args.write_receipt.write_text(json.dumps(normalized,indent=2,sort_keys=True)+'\n')
+    else:
+        need(normalized==json.loads((HERE/'EXPECTED.json').read_text()),'complete deterministic CRT receipt')
+    print('PASS_CRT_ADDRESS_STREAMS '+json.dumps({'columns':138,'inverse_cases':2176,
+          'controls':normalized['rejection_controls']['controls']+normalized['source_controls'],'wrapper_peak':39},sort_keys=True))
+
+
+if __name__=='__main__':
+    main()