diff --git a/research/gaussian-cache-reuse/PLAN.json b/research/gaussian-cache-reuse/PLAN.json
new file mode 100644
index 0000000000..42ce094942
--- /dev/null
+++ b/research/gaussian-cache-reuse/PLAN.json
@@ -0,0 +1,13 @@
+{
+  "at_UTC": "2026-10-23T13:12:01.622494+00:00",
+  "base_commit": "8544ddf488e4ecd2f8c85f79a5b2277d1380aee0",
+  "canonical_main": "ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c",
+  "scope": "Exact cache primitive and source-bound generalized center floor, not a complete supplier search or new kappa.",
+  "candidate": "One stable arbitrary source at zero frame; two arbitrary targets in planes <1,2> and <1,4>. Retain a line-<1> owned cache and reuse a second owned field for both output updates.",
+  "predicted_recursive_change": "2 H2 -> 3 H1, with zero new productive credit and two owned cache fields.",
+  "predicted_gain_at_selected_exponent": "0.991635124775620904301391563105821801159734270612346654",
+  "center_question": "Does the owned-center intersection floor extend to non-nested or arbitrary Clifford transport paths and typed-copy branching trees while persistent common-chart contact caps remain fixed?",
+  "claimed_new_application": "Constructive exponent-aware cache sharing plus its source-bound applicability limit. Metric, memoization and subadditivity are classical, not inventions claimed here.",
+  "stop": "Verify literal arbitrary-input fanout and raw dual, phases, invalidation controls and complete module tariff. Reconstruct all16 center blocks before asserting an 8-rank bound. Do not substitute the toy saving into the selected supplier without an actual changed caller.",
+  "geometry_sha256": "20c217d44893d2cc3b517af826936fc8a4c58f498f5bf76b833e5599a25d9084"
+}
diff --git a/research/gaussian-cache-reuse/PROOF.md b/research/gaussian-cache-reuse/PROOF.md
new file mode 100644
index 0000000000..f6eb9fbc48
--- /dev/null
+++ b/research/gaussian-cache-reuse/PROOF.md
@@ -0,0 +1,206 @@
+# Cache tree identities and the selected center intersection bound
+
+## Frames and actual paid ranks
+
+Let a field have \(2^n\) binary-address positions. A Clifford frame F has
+exact unitary operator \(G_F\). Set
+\(L_0=\{(0,z):z\in\mathbb F_2^n\}\) and
+\(\Lambda_F=F^{-1}L_0\), using the induced binary symplectic action.
+For the actual transport \(G_B G_A^{-1}\), its Fourier rank is
+
+\[
+r(A,B)=n-\dim(\Lambda_A\cap\Lambda_B).
+\tag{1}
+\]
+
+Indeed its B block measures the dimension outside \(L_0\) of
+\(BA^{-1}L_0\). Its kernel is the intersection of \(L_0\) with that
+image. Pulling the intersection back through B gives (1).
+Phases and monomial factors do not change this rank, but must still be
+implemented. This rank is an integer metric on Lagrangian charts; different
+Cliffords with the same chart can have distance zero and nontrivial paid
+ordinary monomial work.
+
+For the repository's canonical subspace frame \(C_U\), direct substitution
+gives
+
+\[
+\Lambda(U)=\{(x,x+z):x\in U,\ z\in U^\perp\}.
+\]
+
+Consequently
+\(r(U,V)=\dim U+\dim V-2\dim(U\cap V)\), including non-nested pairs.
+`primitive.py` independently checks this against exact lowered Clifford
+operators for every pair of the 16 subspaces of \(\mathbb F_2^3\), including
+all input columns and absolute phase. The binary chart formula is the
+algebraic statement; these finite tests check its convention in the retained
+implementation.
+
+## A cache is a snapshot with a representation
+
+Fix a logical column x. At each cache node v maintain physical value
+\(z_v=G_vx\). An owned child w is created by copying \(z_v\), then applying
+the fully paid transport \(G_wG_v^{-1}\). Thus
+
+\[
+G_wG_v^{-1}z_v=G_wx.
+\tag{2}
+\]
+
+Induction proves the invariant on any typed-copy tree. At a terminal,
+\(y_i\leftarrow y_i+\alpha_i z_i\) supplies precisely the requested
+contribution. Internal caches carry no productive-owner credit. Leaves can
+be processed in their original order using a reusable owned field if the
+retained parent cache remains unchanged.
+
+The logical snapshot is an operator row on the independent caller inputs.
+For a cached row R, a later required row S may use the cache when
+\(S=qR\) for an explicitly known scalar q, by changing the ADD coefficient.
+Writes to the original owner are harmless only when this row relation still
+holds. The invariant concerns expressions, not register identifiers. In a
+longer caller the row algebra must include all address operators, coefficients
+and phases; the small scalar-row control here is not such a caller analysis.
+
+Let the desired main endpoint be
+\((x,y_1,y_2)\mapsto(x,y_1+A_1x,y_2+A_2x)\).
+Its raw inverse transpose is
+
+\[
+(x,y_1,y_2)\mapsto
+(x-A_1^Ty_1-A_2^Ty_2,y_1,y_2).
+\tag{3}
+\]
+
+Since G is unitary, \(G^T=\overline G^{-1}\). Reversing the fanout into a
+gather therefore uses conjugate transports in the reversed directions.
+`dual_program` implements (3), not a forward move with a reversed name.
+The inverse transpose is of the main endpoint; owned CLEARs make the full
+scratch-inclusive map noninvertible. Arbitrary owned entries are erased under
+the retained owned-erasure contract and both owned fields leave zero.
+
+Equations (2) and (3) hold for arbitrary field columns. Lifting each block by
+\(I_b\otimes G\) proves the same identities with b idle positions, and block
+composition proves arbitrary repetitions. Tensoring address operators does
+not merge owner roles or turn their sum into independent output credit.
+This is an all-width algebraic identity under the retained Gaussian and
+owned-erasure primitives. A bit-cost implementation still needs those
+primitives' precision, storage, normalizer and tape contracts.
+
+## A sharp three terminal example
+
+Take \(U=0\), \(V_1=\langle1,2\rangle\),
+\(V_2=\langle1,4\rangle\). The three terminals have pairwise distance 2.
+Their shared line \(M=\langle1\rangle\) has distance 1 to each.
+Copy x to owned Z and move U to M; copy Z to owned W, move M to V1,
+ADD to Y1 and clear W; repeat for V2; clear Z. The program has three
+rank-1 moves and the ordinary passes recorded in RESULT.json.
+
+For \(0<s\leq1\), the minimum recursive moment over typed-copy cache trees
+connecting these terminals is exactly
+
+\[
+\min\{2\,2^s,3\}.
+\tag{4}
+\]
+
+To prove the lower bound, remove nonterminal leaves and suppress degree-two
+vertices. Suppression does not increase moment: the metric triangle
+inequality and \((a+b)^s\leq a^s+b^s\) allow replacement of a path by
+one direct edge. Contract zero-rank edges for this rank-only argument.
+A reduced tree connecting three terminals is either a path through one
+terminal or a three-edge tree with one nonterminal junction. The former
+costs \(2\,2^s\). In the latter all three positive integer edge ranks are
+at least 1, hence the cost is at least 3. These bounds apply to arbitrary
+Clifford intermediate charts. The separate transfers and the shared line
+attain them. Ordinary monomial costs are outside this rank-only optimum.
+
+At \(s=1-0.00302015\), the frozen gain is
+\(2\,2^s-3=0.9916351247756209043\ldots\).
+The exact rational interval engine certifies its positive sign and the
+negative sign after charging one more H1. In fact the repaired saving is
+\(4(2^{-\kappa}-1)<0\) for every \(\kappa>0\).
+At \(s=1/2\) the separate
+transfers win. This sign reversal is a useful control on treating rank mass
+as a sufficient cost statistic.
+
+If Z is already a caller-supplied observation \(C_Mx\), omit its creation
+and final erasure. One owned W then suffices for two marginal H1 moves.
+Z is returned unchanged. Its relation to x and all costs outside the module
+are preconditions; the module does not manufacture that observation.
+
+## Intersection loss bounds any typed tree
+
+For a rooted tree of n-dimensional charts, in parent-before-child order let
+\(I_k=\bigcap_{v\leq k}\Lambda_v\). When child w of p is added,
+\(I_{k-1}\subseteq\Lambda_p\), so the quotient map injects
+
+\[
+I_{k-1}/(I_{k-1}\cap\Lambda_w)
+\hookrightarrow
+\Lambda_p/(\Lambda_p\cap\Lambda_w).
+\]
+
+The lost dimension is at most \(r(p,w)\). Summing proves
+
+\[
+\sum_e r_e\geq n-\dim\!\bigcap_v\Lambda_v.
+\tag{5}
+\]
+
+Matarener's nested path argument is the predecessor of this proof. The
+extension uses the actual inverse-image Clifford chart and permits branching
+and arbitrary intermediate Lagrangians. For \(0<s\leq1\), subadditivity gives
+\(\sum_e r_e^s\geq(\sum_e r_e)^s\).
+
+For canonical terminal frames \(U_i\), set \(I=\bigcap_iU_i\) and
+\(J=\sum_iU_i\). The explicit chart formula gives
+
+\[
+\dim\bigcap_i\Lambda(U_i)=\dim I+n-\dim J.
+\tag{6}
+\]
+
+Adding arbitrary intermediate vertices can only shrink that intersection.
+
+## Application to all selected center blocks
+
+Keep #4470's chronological scalar demand, coefficients, fixed warps and helper
+boundaries. Persistent L roles retain the original monotone subspace-frame
+rules. Every source/target scalar contact is in a common canonical frame.
+The predecessor's interval propagation forces a source frame R to contain
+\(A=\operatorname{Low}(\mathrm{source})\), and every target frame Fi to
+lie in \(B_i=\operatorname{Up}(\mathrm{target}_i)\).
+
+Allow the owned payload to travel along arbitrary Clifford intermediates and
+to branch by typed copies. It carries the same specified snapshot; combining
+independent payloads is outside this contract. From (5) and (6), its rank mass
+is at least
+
+\[
+\begin{aligned}
+\dim(R+\sum_iF_i)-\dim(R\cap\bigcap_iF_i)
+&\geq\dim R-\dim(R\cap\bigcap_iB_i)\\
+&\geq\dim A-\dim(A\cap\bigcap_iB_i).
+\end{aligned}
+\tag{7}
+\]
+
+The last inequality is the injection
+\(A/(A\cap X)\hookrightarrow R/(R\cap X)\).
+For a dual gather, apply the same argument to the transposed typed-copy tree
+with conjugate charts; intersection dimensions and edge ranks are preserved.
+
+`center.py` rebuilds the selected local word, recovers paid profile
+`{1:2237,2:388,3:494,4:147,5:36,8:8}` in both orientations, and propagates
+all original contact intervals. For all eight blocks in each orientation,
+it finds \(\dim A=8\) and \(A\cap\bigcap_{i=1}^{22}B_i=0\).
+Thus every such tree pays rank mass at least 8 and moment at least \(8^s\).
+The existing single H8 attains the bound. The actual terminal-chart
+intersection independently gives the same loss eight.
+
+This closes the predecessor's stated non-nested-C question under unchanged
+persistent/contact constraints. It does not cover changed cross-frame contact
+interfaces, changed scalar graphs or helper boundaries, new observations, or
+general circuits mixing independent payloads. Such changes alter the premises
+of (7). In particular the bound must not be transferred unchanged to the
+split-contact or paid-history continuations.
diff --git a/research/gaussian-cache-reuse/README.md b/research/gaussian-cache-reuse/README.md
new file mode 100644
index 0000000000..2c5449434b
--- /dev/null
+++ b/research/gaussian-cache-reuse/README.md
@@ -0,0 +1,237 @@
+# Gaussian Cache Reuse for Cross Frame ADDs and Paid History
+
+Several required reads of the same logical snapshot can share a transformed
+owned copy. A small exact example replaces **two rank-2 Gaussian jobs by three
+rank-1 jobs**, with no new productive-output credit. The tree, word skeleton
+and moment prediction were frozen before exact Clifford realization and
+all-column verification. The same geometry extends
+Matarener's selected-center lower bound to non-nested Clifford transports and
+typed-copy trees: **each of the 16 block-orientations still costs at least one
+rank-8 job** under the original common-contact constraints.
+
+These are a reusable construction and a scoped lower-bound proof, with exact
+finite checks. They do not install a changed selected caller or establish a new
+κ. Canonical source baseline: `ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c`,
+selected conditional κ `0.00302015` from #4470.
+
+## The small geometric law
+
+A frame describes how a field is represented. Changing frames mixes some
+number of independent binary directions; call that number the edge's rank.
+A cache tree pays for each shared prefix once. The useful equations are
+
+\[
+\text{cache price at exponent }s=\sum_{e}r_e^s,\qquad s=1-\kappa,
+\]
+
+\[
+\sum_e r_e\;\geq\;n-\dim\!\left(\bigcap_v\Lambda_v\right).
+\]
+
+Here each \(\Lambda_v\) is an n-dimensional Clifford chart. The second equation
+says that the directions lost from the joint intersection must be paid for
+somewhere in the tree. [PROOF.md](PROOF.md) gives the argument and the exact
+chart convention. This is classical intersection geometry applied to the
+repository's owned-copy and Gaussian-job contracts.
+
+The simplest useful example has source frame 0 and two target planes
+\(\langle1,2\rangle,\langle1,4\rangle\). Going separately costs \(2\,2^s\).
+Sharing their line \(\langle1\rangle\) costs three rank-1 edges, hence 3.
+The shared paid-transfer graph is:
+
+```mermaid
+flowchart LR
+  S["Source frame 0"] -->|"rank 1"| M["Retained line cache"]
+  M -->|"rank 1"| A["First target plane"]
+  M -->|"rank 1"| B["Second target plane"]
+```
+
+The exact optimum over typed cache trees, even with arbitrary intermediate
+Clifford charts, is
+
+\[
+\boxed{\min\{2\,2^s,3\}}.
+\]
+
+The preferred network changes at \(s=\log_2(3/2)\). Thus the geometry alone
+does not predict the winner: the recursive exponent chooses the network.
+At the selected exponent the shared tree saves
+`0.9916351247756209043` moment units. **One additional rank-1 repair job
+exhausts that saving.** [PLAN.json](PLAN.json) fixes the prediction and geometry
+hash; [RESULT.json](RESULT.json) contains outward rational sign certificates.
+This tests a predeclared module-cost prediction. The word skeleton was already
+specified at the freeze; it is not a blind structural discovery or a held-out
+κ improvement.
+
+## Exact ownership and lifetime contract
+
+Every cache in frame F contains \(C_F x\) for one specified logical snapshot x.
+A COPY followed by the fully paid transport \(C_G C_F^{-1}\) creates a child
+cache in G. Scalar ADDs consume it while leaving that cache unchanged. Its
+productive-owner credit is zero.
+
+| Module | Paid jobs | Ordinary whole-field passes | Extra fields |
+| --- | --- | --- | --- |
+| Two separate forward transfers | 2 H2 | 2 COPY, 2 ADD, 3 CLEAR | 1 owned |
+| Shared forward fanout | 3 H1 | 3 COPY, 2 ADD, 5 CLEAR | 2 owned |
+| Raw inverse-transpose gather | 3 H1 | 2 COPY, 3 ADD, 5 CLEAR | 2 owned |
+| Caller supplies the line observation | 2 H1 marginal | 2 COPY, 2 ADD, 3 CLEAR | 1 owned, 1 borrowed observation |
+
+Every paid move also retains its exact left and right monomial normalizers,
+including phases; at most six such maps occur in each three-move module.
+The table counts the explicit ordinary passes, not a complete bit, tape or
+precision tariff. Those maps and passes remain implementation costs. Owned
+fields may enter arbitrarily and are explicitly cleared; they leave zero.
+Dirty borrowed workspace must be returned and cannot use this erasure rule.
+Relative to separate transfers, sharing uses one more owned field, three more
+explicit passes and one more pair of normalizers. A caller must price that
+tradeoff before interpreting the recursive-moment gain as an algorithmic gain.
+
+Reuse is valid when the required logical operator row equals the saved row,
+or is a proved scalar multiple absorbed into the ADD coefficient. Matching
+owner names or frame tags is insufficient. Intervening writes can invalidate
+the snapshot; a later exact restoration can make it usable again. The checker
+rejects a stale read and accepts restored and specified proportional rows.
+
+The already-paid observation variant requires the caller to supply
+\(Z=C_{\langle1\rangle}x\) for that exact snapshot. Z is returned unchanged.
+Its creation, lifetime, hosting and eventual cleanup remain caller obligations.
+This variant is derived after the frozen main prediction. It does not give an
+independent observation for free.
+
+## Where this changes the next research experiment
+
+These are source-specific handoffs, not a new task allocation or priority revision.
+
+1. **Batch cross-frame ADDs by exact snapshot.**
+   [Discussion #5125](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125)
+   already implements a separate owned COPY, paid transport, ADD and CLEAR per
+   split contact. That primitive is predecessor work. The changed experiment
+   is to find several required reads of the *same operator row*, share their
+   transformed prefix, and compare the complete changed invoice. Freeze the
+   candidate tree, cache lifetime, normalizers and repair allowance before
+   native lowering. Another frame seed does not test this premise.
+2. **Use an actual paid-history observation as the root.**
+   The paid-history continuation in
+   [Discussion #4930](https://github.com/CrocSwap/integer-mult-bounds/discussions/4930)
+   is already claimed. Supply this primitive to that question: first identify
+   the exact saved helper/center expression and its later demand. Prove the
+   row relation and return contract before claiming the marginal two-H1 bill.
+   Retaining an observation can change the root geometry; a count of saved
+   coordinates alone does not prove an independent Gaussian output block.
+3. **Require a changed contact or payload before another center-only scan.**
+   The new bound closes the non-nested-transport question explicitly left in
+   [owned-centre-wire-floor](../owned-centre-wire-floor/README.md), and also
+   covers typed-copy branching under those fixed caps. Arbitrary exact
+   Clifford intermediate charts do not lower its eight-rank charge. Changed
+   cross-frame contacts, helper boundaries, scalar graphs, or combinations of
+   independent payloads require a new bound and remain outside this result.
+
+The physical binding is the bottleneck: a candidate must supply the required
+rows with a winning complete bill. The existing
+[coded compiler reserve](../coded-compiler-closure/README.md) already supplies
+conditional arithmetic for its declared model. More compiler digits do not
+prove the missing physical caller. Likewise, the
+[active-query bound](../coded-active-query-bound/README.md) and
+[two-stage terminal result](../two-stage-coded-terminal/README.md) explain why
+static mode counts and a free endpoint decoder are insufficient; neither is a
+universal exclusion of paid-history or changed-contact constructions.
+
+The submission refresh adds a concrete warning from
+[active query feedback](../coded-active-feedback/README.md): its recovered
+missing coefficient is accompanied by a nonzero second-input coefficient
+whose rank fraction tends to 3/4. That scoped result does not reject other
+feedback grammars, but makes the full row relation the first test for a
+paid-history cache root. Recovering one desired coefficient is insufficient.
+
+## Verification
+
+From the repository root, with Python 3.12 and the standard library:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/gaussian-cache-reuse --check-only
+python3.12 -B scripts/research_package.py --package research/gaussian-cache-reuse
+```
+
+Both registered commands are read-only and compare every saved mathematical
+field. They run normally and with `-O`; explicit failure checks remain active
+with assertions disabled. The launcher supplies a fresh bytecode-cache namespace.
+
+The exact dyadic-complex checker tests all 40 independent input columns in
+each orientation, including arbitrary owned entry values; all 256 canonical
+three-axis frame pairs, 140 non-nested; and wrong-phase, wrong-dual and stale
+snapshot controls. It tests 6,750 two-qubit Lagrangian paths/trees and rebuilds
+the original selected word's complete local paid profile and all 16 center
+contact blocks. The general proofs are written, not proof-kernel checked.
+The unchanged selected supplier's native, compiler and multiplication-theorem
+obligations are not re-established by this module replay.
+
+## Open next questions
+
+- Which *actual* split-contact word contains a profitable repeated-snapshot
+  cache tree? Start with one source row and its first two required cross-frame
+  reads, including all intervening writes. The blockers are the exact row
+  match, legal lifetime and complete bill; [TASK.json](TASK.json) records a
+  bounded test.
+- Can the claimed paid-history caller provide a retained observation with the
+  required row relation and unchanged return? Start at its already claimed
+  source helper prefix. The blocker is caller binding, rather than the local
+  transport identity.
+- Does changing a helper boundary or splitting a contact reduce the new joint
+  intersection loss? Derive fresh Low/Up or replacement constraints for one
+  changed block before extending a construction. The original caps cannot be
+  reused after changing the graph.
+
+## Provenance and credit
+
+Prepared by zxv with substantial OpenAI Codex assistance. The predecessor
+contributions used here are:
+
+- **zxv:** the native and uniform supplier in
+  [PR #4359](https://github.com/CrocSwap/integer-mult-bounds/pull/4359),
+  logarithmic compiler in
+  [PR #4411](https://github.com/CrocSwap/integer-mult-bounds/pull/4411), and
+  higher-moment strictification and rational interval engine in
+  [PR #4433](https://github.com/CrocSwap/integer-mult-bounds/pull/4433).
+- **Matarener:** the owned-center intersection argument and fixed-word
+  interval engine in
+  [PR #5060](https://github.com/CrocSwap/integer-mult-bounds/pull/5060).
+- **Dugongue:** the owned-C retiming contract in
+  [PR #4534](https://github.com/CrocSwap/integer-mult-bounds/pull/4534).
+- **Cinna Davis:** the selected word in
+  [PR #4470](https://github.com/CrocSwap/integer-mult-bounds/pull/4470), building
+  on [PR #4440](https://github.com/CrocSwap/integer-mult-bounds/pull/4440),
+  [PR #4441](https://github.com/CrocSwap/integer-mult-bounds/pull/4441) and
+  [PR #4447](https://github.com/CrocSwap/integer-mult-bounds/pull/4447).
+  [PR #5220](https://github.com/CrocSwap/integer-mult-bounds/pull/5220)
+  supplies the active-feedback application context and coupling warning.
+- **Jacob Alan Sussman:** the mixed-target recursion in
+  [PR #4268](https://github.com/CrocSwap/integer-mult-bounds/pull/4268).
+- **icekylinx:** copied-center reuse in
+  [PR #36](https://github.com/CrocSwap/integer-mult-bounds/pull/36) and the
+  exact Clifford compiler lineage retained from
+  [PR #531](https://github.com/CrocSwap/integer-mult-bounds/pull/531).
+  See also the retained [copied-reversed attribution](../copied-reversed/README.md).
+- **Tekalign:** the source-pinned T74 package in
+  [PR #2768](https://github.com/CrocSwap/integer-mult-bounds/pull/2768), from
+  which the unchanged exact Clifford kernel is loaded. Its retained notices
+  preserve the complete native, phase and compiler contributor chain.
+
+The live split-contact and paid-history discussions supply application context,
+not mathematical inputs to the verifier. Metric geometry, memoization, Steiner
+trees and subadditivity are classical; this package claims their explicit
+costed application and scoped extension here. All retained source notices
+and predecessor attribution remain in force.
+
+Overlap checks on 2026-10-23 covered 347 PR records, 4,456 Discussion records
+and 6,999 local package notes in the second bounded search. They do not cover
+every diff, every comment or unpublished work. Live claims are provisional.
+This contribution publishes author-checked evidence with its remaining
+obligations explicit. Exact canonical source pins are in
+[SOURCES.json](SOURCES.json). Apache-2.0.
+
+The final upstream checkpoint is `ff3cc58e370d0f678e529246f8c73e8094e18fcf`.
+Selection, catalogue, family guidance and every existing declared source pin
+are unchanged. Newly archived two-axis and owned-kernel results concern
+different contact alphabets; their source-only intake is not scientific
+acceptance. The new active-feedback context above is pinned separately.
diff --git a/research/gaussian-cache-reuse/RESULT.json b/research/gaussian-cache-reuse/RESULT.json
new file mode 100644
index 0000000000..82ffee525c
--- /dev/null
+++ b/research/gaussian-cache-reuse/RESULT.json
@@ -0,0 +1,1003 @@
+{
+  "status": "PASS_GAUSSIAN_CACHE_REUSE_AND_SHARP_CENTER_BOUND_NO_NEW_KAPPA",
+  "plan_sha256": "9d914483465b5da9952a8c2ad3c1017ad231ffa6b1c2681eb846d4b98b6fd649",
+  "primitive": {
+    "exact_frame_pairs": 256,
+    "non_nested_pairs": 140,
+    "address_dimension": 3,
+    "addresses_per_field": 8,
+    "independent_original_fields": 3,
+    "arbitrary_owned_entry_fields_cleared": 2,
+    "all_input_columns_per_orientation": 40,
+    "forward": {
+      "paid": {
+        "1": 3
+      },
+      "ordinary_field_passes": {
+        "ADD": 2,
+        "CLEAR": 5,
+        "COPY": 3
+      },
+      "owned_fields": 2,
+      "new_productive_owners": 0
+    },
+    "raw_inverse_transpose": {
+      "paid": {
+        "1": 3
+      },
+      "ordinary_field_passes": {
+        "ADD": 3,
+        "CLEAR": 5,
+        "COPY": 2
+      },
+      "owned_fields": 2,
+      "new_productive_owners": 0
+    },
+    "existing_paid_observation_variant": {
+      "tariff": {
+        "paid": {
+          "1": 2
+        },
+        "ordinary_field_passes": {
+          "ADD": 2,
+          "CLEAR": 3,
+          "COPY": 2
+        },
+        "owned_fields": 1,
+        "new_productive_owners": 0,
+        "borrowed_observation_fields": 1
+      },
+      "all_input_columns": 40,
+      "precondition": "Z=C_line X for the exact required logical snapshot; caller supplies and already pays that observation. Z is returned unchanged. Its creation, retention and eventual cleanup remain caller costs."
+    },
+    "negative_controls": [
+      "wrong forward phase",
+      "wrong dual orientation",
+      "stale snapshot"
+    ],
+    "lifetime_controls": [
+      "restored source",
+      "specified proportional source"
+    ],
+    "primitive_scope": "Exact finite module plus written block/tensor lift; no installed selected-caller improvement."
+  },
+  "geometry": {
+    "all_two_qubit_lagrangians": 15,
+    "arbitrary_chart_path_and_tree_checks": 6750,
+    "canonical_three_axis_meetings": [
+      {
+        "meeting_basis": [],
+        "edge_grades": [
+          0,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          1
+        ],
+        "edge_grades": [
+          1,
+          1,
+          1
+        ]
+      },
+      {
+        "meeting_basis": [
+          2
+        ],
+        "edge_grades": [
+          1,
+          1,
+          3
+        ]
+      },
+      {
+        "meeting_basis": [
+          3
+        ],
+        "edge_grades": [
+          1,
+          1,
+          3
+        ]
+      },
+      {
+        "meeting_basis": [
+          4
+        ],
+        "edge_grades": [
+          1,
+          1,
+          3
+        ]
+      },
+      {
+        "meeting_basis": [
+          5
+        ],
+        "edge_grades": [
+          1,
+          1,
+          3
+        ]
+      },
+      {
+        "meeting_basis": [
+          6
+        ],
+        "edge_grades": [
+          1,
+          3,
+          3
+        ]
+      },
+      {
+        "meeting_basis": [
+          7
+        ],
+        "edge_grades": [
+          1,
+          3,
+          3
+        ]
+      },
+      {
+        "meeting_basis": [
+          1,
+          2
+        ],
+        "edge_grades": [
+          0,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          1,
+          4
+        ],
+        "edge_grades": [
+          0,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          1,
+          6
+        ],
+        "edge_grades": [
+          2,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          2,
+          4
+        ],
+        "edge_grades": [
+          2,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          2,
+          5
+        ],
+        "edge_grades": [
+          2,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          3,
+          4
+        ],
+        "edge_grades": [
+          2,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          3,
+          5
+        ],
+        "edge_grades": [
+          2,
+          2,
+          2
+        ]
+      },
+      {
+        "meeting_basis": [
+          1,
+          2,
+          4
+        ],
+        "edge_grades": [
+          1,
+          1,
+          3
+        ]
+      }
+    ],
+    "cache_tree_mass": {
+      "edge_rank_mass": 3,
+      "intersection_floor": 3,
+      "steps": [
+        {
+          "node": 1,
+          "parent": 0,
+          "grade": 1,
+          "intersection_loss": 1
+        },
+        {
+          "node": 2,
+          "parent": 1,
+          "grade": 1,
+          "intersection_loss": 1
+        },
+        {
+          "node": 3,
+          "parent": 1,
+          "grade": 1,
+          "intersection_loss": 1
+        }
+      ]
+    },
+    "transition_s": "0.584962500721156181453738943947816508759814407692481060455752",
+    "scope": "General proof is written; these finite checks corroborate its ranks and transcription."
+  },
+  "price": {
+    "baseline_paid": {
+      "2": 2
+    },
+    "cache_paid": {
+      "1": 3
+    },
+    "productive_owner_delta": 0,
+    "outward_moment_gains": {
+      ".00302015": {
+        "saving": [
+          "778074320324929711448396173466075825095034793744123736337/784637716923335095479473677900958302012794430558004314112",
+          "3112297281299718845793584693864303300380139174976494945539/3138550867693340381917894711603833208051177722232017256448"
+        ],
+        "after_one_extra_H1": [
+          "-6563396598405384031077504434882476917759636813880577775/784637716923335095479473677900958302012794430558004314112",
+          "-26253586393621536124310017739529907671038547255522310909/3138550867693340381917894711603833208051177722232017256448"
+        ]
+      },
+      ".004": {
+        "saving": [
+          "193986964612987004559506547625256900050002729830442564423/196159429230833773869868419475239575503198607639501078528",
+          "1551895716903896036476052381002055200400021838643540515479/1569275433846670190958947355801916604025588861116008628224"
+        ],
+        "after_one_extra_H1": [
+          "-2172464617846769310361871849982675453195877809058514105/196159429230833773869868419475239575503198607639501078528",
+          "-17379716942774154482894974799861403625567022472468112745/1569275433846670190958947355801916604025588861116008628224"
+        ]
+      },
+      ".005": {
+        "saving": [
+          "3095116623278995131471986088129486700423211664193186845345/3138550867693340381917894711603833208051177722232017256448",
+          "3095116623278995131471986088129486700423211664193186845541/3138550867693340381917894711603833208051177722232017256448"
+        ],
+        "after_one_extra_H1": [
+          "-43434244414345250445908623474346507627966058038830411103/3138550867693340381917894711603833208051177722232017256448",
+          "-43434244414345250445908623474346507627966058038830410907/3138550867693340381917894711603833208051177722232017256448"
+        ]
+      },
+      ".01": {
+        "saving": [
+          "3051832649934593665179488419917092609221248706206130443413/3138550867693340381917894711603833208051177722232017256448",
+          "3051832649934593665179488419917092609221248706206130443609/3138550867693340381917894711603833208051177722232017256448"
+        ],
+        "after_one_extra_H1": [
+          "-86718217758746716738406291686740598829929016025886813035/3138550867693340381917894711603833208051177722232017256448",
+          "-86718217758746716738406291686740598829929016025886812839/3138550867693340381917894711603833208051177722232017256448"
+        ]
+      }
+    },
+    "repair_budget": "Strictly less than one extra H1 per module at every tested positive saving.",
+    "selected_installation": false,
+    "new_kappa": null
+  },
+  "selected_centers": {
+    "blocks": {
+      "backward": [
+        {
+          "source_event": 11333,
+          "targets": [
+            11310,
+            11311,
+            11312,
+            11313,
+            11314,
+            11315,
+            11316,
+            11317,
+            11318,
+            11319,
+            11320,
+            11321,
+            11322,
+            11323,
+            11324,
+            11325,
+            11326,
+            11327,
+            11328,
+            11329,
+            11330,
+            11331
+          ],
+          "source_lower_basis": [
+            1,
+            4,
+            10,
+            16,
+            34,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11359,
+          "targets": [
+            11336,
+            11337,
+            11338,
+            11339,
+            11340,
+            11341,
+            11342,
+            11343,
+            11344,
+            11345,
+            11346,
+            11347,
+            11348,
+            11349,
+            11350,
+            11351,
+            11352,
+            11353,
+            11354,
+            11355,
+            11356,
+            11357
+          ],
+          "source_lower_basis": [
+            3,
+            5,
+            8,
+            16,
+            32,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11385,
+          "targets": [
+            11362,
+            11363,
+            11364,
+            11365,
+            11366,
+            11367,
+            11368,
+            11369,
+            11370,
+            11371,
+            11372,
+            11373,
+            11374,
+            11375,
+            11376,
+            11377,
+            11378,
+            11379,
+            11380,
+            11381,
+            11382,
+            11383
+          ],
+          "source_lower_basis": [
+            2,
+            4,
+            9,
+            17,
+            32,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11411,
+          "targets": [
+            11388,
+            11389,
+            11390,
+            11391,
+            11392,
+            11393,
+            11394,
+            11395,
+            11396,
+            11397,
+            11398,
+            11399,
+            11400,
+            11401,
+            11402,
+            11403,
+            11404,
+            11405,
+            11406,
+            11407,
+            11408,
+            11409
+          ],
+          "source_lower_basis": [
+            1,
+            2,
+            8,
+            20,
+            36,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11437,
+          "targets": [
+            11414,
+            11415,
+            11416,
+            11417,
+            11418,
+            11419,
+            11420,
+            11421,
+            11422,
+            11423,
+            11424,
+            11425,
+            11426,
+            11427,
+            11428,
+            11429,
+            11430,
+            11431,
+            11432,
+            11433,
+            11434,
+            11435
+          ],
+          "source_lower_basis": [
+            1,
+            4,
+            8,
+            18,
+            32,
+            66,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11463,
+          "targets": [
+            11440,
+            11441,
+            11442,
+            11443,
+            11444,
+            11445,
+            11446,
+            11447,
+            11448,
+            11449,
+            11450,
+            11451,
+            11452,
+            11453,
+            11454,
+            11455,
+            11456,
+            11457,
+            11458,
+            11459,
+            11460,
+            11461
+          ],
+          "source_lower_basis": [
+            3,
+            5,
+            9,
+            17,
+            33,
+            65,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11489,
+          "targets": [
+            11466,
+            11467,
+            11468,
+            11469,
+            11470,
+            11471,
+            11472,
+            11473,
+            11474,
+            11475,
+            11476,
+            11477,
+            11478,
+            11479,
+            11480,
+            11481,
+            11482,
+            11483,
+            11484,
+            11485,
+            11486,
+            11487
+          ],
+          "source_lower_basis": [
+            2,
+            4,
+            8,
+            16,
+            33,
+            65,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11515,
+          "targets": [
+            11492,
+            11493,
+            11494,
+            11495,
+            11496,
+            11497,
+            11498,
+            11499,
+            11500,
+            11501,
+            11502,
+            11503,
+            11504,
+            11505,
+            11506,
+            11507,
+            11508,
+            11509,
+            11510,
+            11511,
+            11512,
+            11513
+          ],
+          "source_lower_basis": [
+            1,
+            2,
+            12,
+            16,
+            32,
+            68,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        }
+      ],
+      "forward": [
+        {
+          "source_event": 11310,
+          "targets": [
+            11312,
+            11313,
+            11314,
+            11315,
+            11316,
+            11317,
+            11318,
+            11319,
+            11320,
+            11321,
+            11322,
+            11323,
+            11324,
+            11325,
+            11326,
+            11327,
+            11328,
+            11329,
+            11330,
+            11331,
+            11332,
+            11333
+          ],
+          "source_lower_basis": [
+            1,
+            4,
+            10,
+            16,
+            34,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11336,
+          "targets": [
+            11338,
+            11339,
+            11340,
+            11341,
+            11342,
+            11343,
+            11344,
+            11345,
+            11346,
+            11347,
+            11348,
+            11349,
+            11350,
+            11351,
+            11352,
+            11353,
+            11354,
+            11355,
+            11356,
+            11357,
+            11358,
+            11359
+          ],
+          "source_lower_basis": [
+            3,
+            5,
+            8,
+            16,
+            32,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11362,
+          "targets": [
+            11364,
+            11365,
+            11366,
+            11367,
+            11368,
+            11369,
+            11370,
+            11371,
+            11372,
+            11373,
+            11374,
+            11375,
+            11376,
+            11377,
+            11378,
+            11379,
+            11380,
+            11381,
+            11382,
+            11383,
+            11384,
+            11385
+          ],
+          "source_lower_basis": [
+            2,
+            4,
+            9,
+            17,
+            32,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11388,
+          "targets": [
+            11390,
+            11391,
+            11392,
+            11393,
+            11394,
+            11395,
+            11396,
+            11397,
+            11398,
+            11399,
+            11400,
+            11401,
+            11402,
+            11403,
+            11404,
+            11405,
+            11406,
+            11407,
+            11408,
+            11409,
+            11410,
+            11411
+          ],
+          "source_lower_basis": [
+            1,
+            2,
+            8,
+            20,
+            36,
+            64,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11414,
+          "targets": [
+            11416,
+            11417,
+            11418,
+            11419,
+            11420,
+            11421,
+            11422,
+            11423,
+            11424,
+            11425,
+            11426,
+            11427,
+            11428,
+            11429,
+            11430,
+            11431,
+            11432,
+            11433,
+            11434,
+            11435,
+            11436,
+            11437
+          ],
+          "source_lower_basis": [
+            1,
+            4,
+            8,
+            18,
+            32,
+            66,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11440,
+          "targets": [
+            11442,
+            11443,
+            11444,
+            11445,
+            11446,
+            11447,
+            11448,
+            11449,
+            11450,
+            11451,
+            11452,
+            11453,
+            11454,
+            11455,
+            11456,
+            11457,
+            11458,
+            11459,
+            11460,
+            11461,
+            11462,
+            11463
+          ],
+          "source_lower_basis": [
+            3,
+            5,
+            9,
+            17,
+            33,
+            65,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11466,
+          "targets": [
+            11468,
+            11469,
+            11470,
+            11471,
+            11472,
+            11473,
+            11474,
+            11475,
+            11476,
+            11477,
+            11478,
+            11479,
+            11480,
+            11481,
+            11482,
+            11483,
+            11484,
+            11485,
+            11486,
+            11487,
+            11488,
+            11489
+          ],
+          "source_lower_basis": [
+            2,
+            4,
+            8,
+            16,
+            33,
+            65,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        },
+        {
+          "source_event": 11492,
+          "targets": [
+            11494,
+            11495,
+            11496,
+            11497,
+            11498,
+            11499,
+            11500,
+            11501,
+            11502,
+            11503,
+            11504,
+            11505,
+            11506,
+            11507,
+            11508,
+            11509,
+            11510,
+            11511,
+            11512,
+            11513,
+            11514,
+            11515
+          ],
+          "source_lower_basis": [
+            1,
+            2,
+            12,
+            16,
+            32,
+            68,
+            128,
+            256
+          ],
+          "source_lower_dimension": 8,
+          "source_and_target_caps_intersection_dimension": 0,
+          "rank_mass_lower_bound": 8,
+          "moment_lower_bound": "8^s",
+          "baseline_paid_job": 8
+        }
+      ]
+    },
+    "orientations": 2,
+    "total_blocks": 16,
+    "new_scope": "Arbitrary exact Clifford transports between canonical common-chart contacts, and typed-copy branching trees or their dual gathers. Persistent contact intervals and the scalar demand stay fixed.",
+    "excluded": "Changed cross-frame contact ABI, changed L paths/warps/coefficients, new observations or combinations of independent payloads outside the typed tree, other source words.",
+    "claim_type": "Written general lower-bound proof plus exact source-incidence checks, not an exhaustive circuit or proof-kernel verification."
+  },
+  "claims": "Constructive all-width block identity under retained Gaussian/owned-erasure contracts; written sharp bound for typed-copy trees with fixed canonical contact caps. Finite exact corroboration, no formal kernel or full supplier admission."
+}
diff --git a/research/gaussian-cache-reuse/SOURCES.json b/research/gaussian-cache-reuse/SOURCES.json
new file mode 100644
index 0000000000..3fb706bd41
--- /dev/null
+++ b/research/gaussian-cache-reuse/SOURCES.json
@@ -0,0 +1,134 @@
+{
+  "schema_version": 1,
+  "base_commit": "ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c",
+  "files": [
+    {
+      "path": "research/fresh-helper-boundary/CHANGES.json",
+      "usage": "input",
+      "sha256": "cde73b8ff5b3c0d06e69e2293b991b24fd14a16dd4ccab7ff6b3439074a94624",
+      "git_blob": "45744fedd0e28967aa72586048b8bc0c72f419a9"
+    },
+    {
+      "path": "research/fresh-helper-boundary/native.py",
+      "usage": "input",
+      "sha256": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29",
+      "git_blob": "1b36f6cb5f205c33bf48811e0b1b3621c55e8154"
+    },
+    {
+      "path": "research/higher-moment-strictification/verify.py",
+      "usage": "input",
+      "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326",
+      "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699"
+    },
+    {
+      "path": "research/joint-helper-lattice/PATCH.json",
+      "usage": "input",
+      "sha256": "296d0e8c58cc70febe042c681ef30d6bb469818c0835fbcaac8aa8d330f5b727",
+      "git_blob": "51304a6601061ed4e698f910b09135ef109555e3"
+    },
+    {
+      "path": "research/joint-helper-lattice/RESULT.json",
+      "usage": "input",
+      "sha256": "c7b2388f6511c19976b337d8c8ac374610af616866a249d75dace704eb5d9e21",
+      "git_blob": "edf41a49a0350862c23378f837c7397fc5dc7596"
+    },
+    {
+      "path": "research/joint-helper-lattice/native_joint.py",
+      "usage": "input",
+      "sha256": "50869b1bcad7493e6b4cb2a4cd5d2fd9a193a5921100483fa2c3f2c999ddfd46",
+      "git_blob": "0315f80e2fdef5e0eef13e3e9b8f72066238164d"
+    },
+    {
+      "path": "research/kappa-rebuild/architecture/mixed_target_probe.py",
+      "usage": "input",
+      "sha256": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a",
+      "git_blob": "4fc05ab08138218ba9f09e5c89b649afae7c914e"
+    },
+    {
+      "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz",
+      "usage": "input",
+      "sha256": "6418ec3da24d548a57f5c3fe5b9062c26c9478e638504a61c387f5cfb5f4ed61",
+      "git_blob": "4a8c4ed26e53a72362d571c972e65aff546be784"
+    },
+    {
+      "path": "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz",
+      "usage": "input",
+      "sha256": "c54b0a3e129d28e6dbf74fa731fc3bb70fe3c6705f07256750fbecddcc842d39",
+      "git_blob": "b46d44c6ee624968dd57be928b0c15d9d45f3b2c"
+    },
+    {
+      "path": "research/missing-join-frame/PATCH.json",
+      "usage": "input",
+      "sha256": "9ab5328245ff02c9d0be21d39bcc375f50bc5d7909e9f7b9a3a9a6f812f5bd6e",
+      "git_blob": "f96d295d40014d4dd503f58eb3cdabcbb4b8e101"
+    },
+    {
+      "path": "research/owned-centre-wire-floor/verify.py",
+      "usage": "input",
+      "sha256": "46e4e242cc336adea56138117404c9b9e499747f7e8181d93e59608a4308026d",
+      "git_blob": "49053e0d6785c26e22c2e02db9d6699aa323a487"
+    },
+    {
+      "path": "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py",
+      "usage": "input",
+      "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962",
+      "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72",
+      "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375",
+      "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395"
+    },
+    {
+      "path": "research/owned-centre-wire-floor/PROOF.md",
+      "usage": "provenance",
+      "sha256": "4fddcb9d3595870dd6ba9a0819e19ba50d9748b3cd643b978f43aef8750dcaf5",
+      "git_blob": "e6033ac5ddedc4152c2553499021b262f81f75bd"
+    },
+    {
+      "path": "research/owned-centre-wire-floor/README.md",
+      "usage": "provenance",
+      "sha256": "f2fdd6c91d98b692dac91e7a6cd6c8f09094cd2259ed3737ec429b147499c0a3",
+      "git_blob": "ffd10d3c4314d3bdc80aad56d606b73e1bb4d820"
+    },
+    {
+      "path": "research/coded-active-query-bound/README.md",
+      "usage": "provenance",
+      "sha256": "95269b047c19069caeb11edd36a485a0a86275b329aa44da90c8c08403e09178",
+      "git_blob": "f8858cea6b9ff5018ac3eee71bebcde9696e595d"
+    },
+    {
+      "path": "research/two-stage-coded-terminal/README.md",
+      "usage": "provenance",
+      "sha256": "1547a1b5fbb4b919fa90c6b2c3e476e51e52ca8f99c39a5f6a268757eced1365",
+      "git_blob": "86e7af1c02878abd03e2287fa6c87f94d3371ef1"
+    },
+    {
+      "path": "research/coded-compiler-closure/README.md",
+      "usage": "provenance",
+      "sha256": "3ee6da00bdee9f1607e9725f0b9853355c7f3c60b701bae479e86fccc602a7a1",
+      "git_blob": "8f14ae9c3a4d01097375be28ae3c7886f3eb44d5"
+    },
+    {
+      "path": "research/copied-reversed/README.md",
+      "usage": "provenance",
+      "sha256": "d23336ad86ffeb10755088ff9aaf8dada3791a6399c2891a07cb34436870f5f5",
+      "git_blob": "aaf71dc7fe72a936f64c6dfc75e8bee99c1ec472"
+    },
+    {
+      "path": "research/coded-active-feedback/README.md",
+      "usage": "provenance",
+      "pin": "head:ff3cc58e370d0f678e529246f8c73e8094e18fcf:research/coded-active-feedback/README.md",
+      "sha256": "a5db3dc44c87f5469d2eee6251010862dca49e92bf418297b8e3d92e813daa7b",
+      "git_blob": "bdd22ccce3d96bb1fa7c3e6f40862df54609dec1"
+    }
+  ],
+  "source_credit": "zxv, Matarener, Dugongue, Cinna Davis, Jacob Alan Sussman, icekylinx, Tekalign and the full retained native/Clifford/compiler lineage; contribution-specific PR links are in README.md#provenance-and-credit. New work by zxv with substantial OpenAI Codex assistance."
+}
diff --git a/research/gaussian-cache-reuse/TASK.json b/research/gaussian-cache-reuse/TASK.json
new file mode 100644
index 0000000000..df3bb06fa4
--- /dev/null
+++ b/research/gaussian-cache-reuse/TASK.json
@@ -0,0 +1,113 @@
+{
+  "schema_version": 1,
+  "task_id": "centre-path-sharing",
+  "priority_revision": 7,
+  "base_commit": "ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c",
+  "original_card": {
+    "id": "centre-path-sharing",
+    "question": "Can the 64-per-call centre path (eight rank-8 COPY/ERASE totals through the private temporary) be shared across calls or shrunk?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "research/complex-local-word-ceiling/README.md",
+      "research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt",
+      "certificates/selected-result.json"
+    ],
+    "methods": [
+      "Derive a fully charged favorable relaxation for sharing one centre path across k calls, including restoration, hosting and precision.",
+      "Prove a lower bound on copied information per call for the selected decoder contract."
+    ],
+    "acceptance_gate": "Show the changed centre charge and copy profile per call with every added restoration or hosting cost charged, and its ceiling via ceiling.ceiling(centre=...). 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": "Write the per-call centre charge and copy children for sharing across k = 2 calls, charge the sharing overhead, and screen it; stop this route if even the ideal sharing gains under 10%. Ideal budgets: free 2.80x, shared by two 1.90x (levers.py).",
+    "bottleneck_link": "The centre path consumes 64 of about 99.6 unpaid coordinates per call, i.e. about 64% of the raw deficit.",
+    "allowed_variations": [
+      "One sharing pattern across a fixed number of calls.",
+      "One reduced copied-total contract for the existing decoder.",
+      "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": [
+      "Removing copies without a replacement contract for the decoder's copied totals.",
+      "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": [
+      "centre path",
+      "copied totals",
+      "private temporary",
+      "shared centre",
+      "batching"
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Explicit user assignment: turn geometric laws into useful research findings. Supply an exact exponent-aware owned-cache sharing primitive, and extend the selected fixed-common-contact center bound to arbitrary Clifford paths and typed-copy trees.",
+  "scope_change_reason": "The historical card requests cross-call center savings and its historical packing screen. This package installs no supplier and uses the refreshed selected source. It supplies a local reusable contract and closes the predecessor non-nested-center gap instead; no old packing ceiling or complete card acceptance is asserted.",
+  "bottleneck_link": "Physical row/caller binding and complete repair costs distinguish usable sharing from geometric rank savings. The sharp selected-center bound prevents another transport-only scan under unchanged caps; changed split contacts or paid-history roots need separate contracts.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop at exact primitive and dual checks, complete module ownership/pass counts, outward moment signs and all16 source-bound center blocks. No duplicate active native synthesis campaign or new supplier-admission claim.",
+  "outcome": "partial",
+  "evidence": "PROOF.md, frozen PLAN.json and geometry.py hash, RESULT.json reproduced by normal and optimized registered verify.py commands. README links the three bounded next questions.",
+  "author": "zxv, with substantial OpenAI Codex research assistance",
+  "ai_assistance": "Substantial OpenAI Codex assistance in analysis, code and writing; exact finite checks and written proofs; no independent human or proof-kernel review.",
+  "open_questions": [
+    {
+      "question": "Can a required split-contact word share one transformed snapshot across two or more cross-frame ADDs with a winning complete bill?",
+      "why_it_matters": "The exact primitive removes duplicated rank work only when the same operator row is required; this changes the per-ADD ownership premise already explored in Discussion 5125.",
+      "first_step": "In the current claimed split-contact source, symbolically track one source row through its first two cross-frame reads. Freeze their frames, candidate cache tree, write interval and all incremental costs, then compare and lower exactly. Coordinate with the existing claim before expanding the campaign.",
+      "blocked_by": "An actual repeated-row witness and source-bound native/precision/tape invoice; one extra H1 already loses the toy gain."
+    },
+    {
+      "question": "Can the existing paid-history continuation supply an observation with the required exact row relation and unchanged return?",
+      "why_it_matters": "An already-paid observation changes the cache root and can reduce marginal work without pretending a new independent Gaussian output was supplied.",
+      "first_step": "Use the source helper prefix already claimed in Discussion 4930; identify the saved expression, later required expression and lifetime. Prove proportionality as operator rows before applying the two-H1 observation variant.",
+      "blocked_by": "Caller-bound expression equality, return/cleanup and complete storage/precision costs. The local variant cannot establish these."
+    },
+    {
+      "question": "Can a changed helper boundary or independent source/destination contact reduce the selected block joint-intersection floor?",
+      "why_it_matters": "Arbitrary owned transport and typed-copy branching alone cannot improve the fixed-cap center charge; a changed cap or payload is needed to escape this scoped bound.",
+      "first_step": "For one changed block, derive new interval or replacement constraints and exact terminal charts. Compute its new joint intersection loss, then price a completed candidate under that new contract.",
+      "blocked_by": "Valid replacement constraints after graph/contact changes; the old Low/Up propagation is not automatically applicable."
+    }
+  ],
+  "entry_checkpoint": {
+    "canonical_main": "ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c",
+    "selected_conditional_kappa": "0.00302015",
+    "selected_binding_command": [
+      "python3",
+      "-B",
+      "scripts/research_selected_baseline.py"
+    ],
+    "task_assignment": "Explicit user geometric/predictive research assignment; no task-picker reroll.",
+    "live_overlap_date": "2026-10-23",
+    "second_overlap_coverage": {
+      "pr_records": 347,
+      "discussion_records": 4456,
+      "local_notes": 6999
+    },
+    "overlap_limits": "Bounded cached text search plus selected live discussion and open-PR reads, not exhaustive diffs/comments/unpublished work. Existing claims advisory. The initial investigation was local; zxv subsequently authorized submitting this focused package as a PR.",
+    "relevant_active_context": [
+      "https://github.com/CrocSwap/integer-mult-bounds/discussions/5125",
+      "https://github.com/CrocSwap/integer-mult-bounds/discussions/4930",
+      "https://github.com/CrocSwap/integer-mult-bounds/pull/5200"
+    ],
+    "scope_separation": "Single per-ADD cross-frame lowering is prior work. Paid-history native closure is already claimed. This package supplies a shared-cache module and fixed-cap theorem, not a duplicate construction campaign."
+  },
+  "final_upstream_checkpoint": {
+    "canonical_main": "ff3cc58e370d0f678e529246f8c73e8094e18fcf",
+    "guidance_catalog_and_selection_changed": false,
+    "existing_declared_source_pins_changed": false,
+    "new_context_read": [
+      "research/coded-active-feedback/README.md",
+      "research/two-axis-owned-contacts/README.md",
+      "research/owned-kernel-weak-duality/README.md"
+    ],
+    "replay_runner_change": "New POSIX Git-blob descendant cleanup; no mathematical semantics change. Recheck package with the refreshed runner after integrating upstream."
+  }
+}
diff --git a/research/gaussian-cache-reuse/VALIDATION.md b/research/gaussian-cache-reuse/VALIDATION.md
new file mode 100644
index 0000000000..fb8f851847
--- /dev/null
+++ b/research/gaussian-cache-reuse/VALIDATION.md
@@ -0,0 +1,118 @@
+# Local validation
+
+Checked on 2026-10-23 on Darwin arm64 with CPython 3.12.14, standard library
+only. The bundled interpreter was
+`/Users/temp/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/bin/python3`.
+No new dependency installation was required.
+
+## Commands and outcomes
+
+```sh
+python3.12 -B scripts/research_package.py --package research/gaussian-cache-reuse --check-only
+python3.12 -B scripts/research_package.py --package research/gaussian-cache-reuse
+python3 -B scripts/research_selected_baseline.py
+```
+
+The metadata/source-pin check passed. The registered replay passed both
+`-I -W error -B verify.py` and `-I -O -W error -B verify.py`, each in its
+launcher-supplied private bytecode-cache namespace. They reproduced all saved
+mathematical fields read-only and ended with
+`PASS_REGISTERED_RESEARCH_PACKAGE research/gaussian-cache-reuse outcome=partial`.
+Explicit guards and all-column comparisons remain active under optimization.
+Result comparison uses the JSON representation, including string rank keys.
+
+Coverage: 256 exact canonical frame pairs including 140 non-nested pairs;
+40 independent input columns in each main orientation and in the supplied
+observation module; eight correlated observation fixtures; wrong phase,
+wrong raw-dual orientation and stale-snapshot controls; restored/proportional
+row controls; all 15 two-qubit Lagrangians and 6,750 paths/trees; all 16
+selected center block-orientations with 22 targets each; complete local paid
+profile reconstruction; outward rational moment signs at four exponents
+and a losing half-exponent control.
+
+The selected-baseline command passed source/metadata orientation only. It is
+not the full selected replay. No new selected supplier was installed, so
+native, Lean, Docker, full compiler/precision/tape and multiplication-theorem
+replays were not run. The all-width identities and lower bound are written
+proofs, not kernel-checked theorems or an independently reviewed admission.
+
+## Frozen evidence
+
+The plan was frozen at `2026-10-23T13:12:01.622494+00:00` before exact Clifford
+realization and the all-column checker. The frozen geometry file already
+contains the word skeleton. Its prediction is a module moment saving, not
+a blind design forecast or a new kappa. The observation variant and final
+proof are subsequent derivations.
+
+| File | SHA256 |
+| --- | --- |
+| `PLAN.json` | `9d914483465b5da9952a8c2ad3c1017ad231ffa6b1c2681eb846d4b98b6fd649` |
+| `geometry.py` | `20c217d44893d2cc3b517af826936fc8a4c58f498f5bf76b833e5599a25d9084` |
+| `RESULT.json` | `127aaacd8c24043129f224f56f14f436826c218091c82bde647ef9f46fe9c3c5` |
+
+## Upstream checkpoint and scope
+
+The investigation started at canonical main
+`ec2780e8aeb1c88acaf5e9e470ef8c68e7fbbb6c` and refreshed to
+`ff3cc58e370d0f678e529246f8c73e8094e18fcf`. Selection, catalogue,
+family guidance and every pre-existing declared source pin were unchanged.
+Upstream was merged without modifying frozen evidence, and the package was
+replayed with its updated Git-reader cleanup. The newly archived
+active-feedback README is a separately pinned provenance source.
+
+The overlap search and relevant live claims are recorded in TASK.json.
+At the initial validation checkpoint no external post or PR had been made.
+zxv subsequently authorized this focused contribution PR. No selected-frontier
+update or maintainer queue action is included.
+
+## Committed bytes and Git free replay
+
+The byte preflight passed for all 24 package/input files at
+`40eeaa2a363ec8f9bc420b3bb6e337234949b308`:
+
+```sh
+python3 -B scripts/check_research_commit.py --package research/gaussian-cache-reuse
+python3 -B scripts/export_research_package.py export --package research/gaussian-cache-reuse --ref 40eeaa2a363ec8f9bc420b3bb6e337234949b308 --output /tmp/gaussian-cache-reuse-40eeaa2a36.tar
+python3 -B scripts/export_research_package.py check /tmp/gaussian-cache-reuse-40eeaa2a36.tar
+```
+
+The 580 KiB export passed its exact inventory/hash check. It was extracted
+into a fresh temporary directory with no Git checkout and replayed normally
+and with `-O`, using the same Python 3.12 interpreter, `PATH=/nonexistent`,
+`-I -W error -B` and fresh `-X pycache_prefix` directories. Both mathematical
+replays passed and the temporary extracted files were removed. Subsequent
+documentation refinements leave the verifier, plan and result bytes unchanged.
+This is evidence for the declared mathematical replay inputs, not hosted CI.
+
+The additional `--check-source-history` preflight did not pass: this checkout
+is shallow and the tool requires full Git history. It reported
+`source-history check requires full Git history`. No full-history download
+or weaker replacement check was used. The successful byte/export checks do
+not substitute for that separate optional publication-history preflight.
+
+## Focused publication replay
+
+The publication branch starts at canonical main
+`ff3cc58e370d0f678e529246f8c73e8094e18fcf` and contains only this package.
+Earlier exploratory packages stay on the development branch. Frozen PLAN,
+geometry and RESULT bytes are unchanged. PLAN's `base_commit` records that
+local development checkpoint; it is not a replay dependency. The consumed
+source pins are the canonical commits declared in SOURCES.json.
+
+The registered normal and optimized commands above passed again from the
+focused branch. A fresh committed export at its reachable commit
+`5a40115affefff6a6811996e7c175a4e4ab10a40` passed inventory/hash checks and
+both Git-free mathematical replays, using the same isolated Python flags,
+fresh bytecode directories and `PATH=/nonexistent` described above.
+
+For publication, this reachable snapshot replaces the development-only
+`40eeaa2a36` reference in the historical export example:
+
+```sh
+python3 -B scripts/export_research_package.py export --package research/gaussian-cache-reuse --ref 5a40115affefff6a6811996e7c175a4e4ab10a40 --output /tmp/gaussian-cache-reuse-publication-5a40115aff.tar
+python3 -B scripts/export_research_package.py check /tmp/gaussian-cache-reuse-publication-5a40115aff.tar
+```
+
+Publication status and credit refinements after that snapshot change no
+scientific input, verifier, frozen plan or result. Metadata and committed-byte
+checks cover the final publication commit separately.
diff --git a/research/gaussian-cache-reuse/VERIFY.json b/research/gaussian-cache-reuse/VERIFY.json
new file mode 100644
index 0000000000..d457be3f60
--- /dev/null
+++ b/research/gaussian-cache-reuse/VERIFY.json
@@ -0,0 +1,47 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/fresh-helper-boundary/CHANGES.json",
+    "research/fresh-helper-boundary/native.py",
+    "research/higher-moment-strictification/verify.py",
+    "research/joint-helper-lattice/PATCH.json",
+    "research/joint-helper-lattice/RESULT.json",
+    "research/joint-helper-lattice/native_joint.py",
+    "research/kappa-rebuild/architecture/mixed_target_probe.py",
+    "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-CANONICAL.json.gz",
+    "research/kappa-rebuild/complex/full-identity-certificates/THREE-base-FULL-IDENTITY-NATIVE.json.gz",
+    "research/missing-join-frame/PATCH.json",
+    "research/owned-centre-wire-floor/verify.py",
+    "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-W",
+        "error",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Authenticate live sources and frozen geometry; exact all-column primitive/dual/observation, 256 frame pairs with absolute phases, stale and incorrect orientation controls, 6750 Lagrangian tree/path checks, all16 reconstructed selected center blocks and outward rational price signs; reproduce RESULT.json read-only."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-W",
+        "error",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Repeat all explicit identity, source, geometry and price checks with assertions disabled; reproduce every mathematical field read-only. Retained Clifford internal assertions are supplemented by explicit all-column comparisons."
+    }
+  ]
+}
diff --git a/research/gaussian-cache-reuse/center.py b/research/gaussian-cache-reuse/center.py
new file mode 100644
index 0000000000..08883af45d
--- /dev/null
+++ b/research/gaussian-cache-reuse/center.py
@@ -0,0 +1,58 @@
+"""Source-bound extension of Matarener's owned-center intersection bound.
+
+Only the original geometry helpers are loaded; its root computation is not
+executed. New conclusion allows arbitrary Clifford path intermediates and
+typed-copy trees under the unchanged canonical contact caps.
+Apache-2.0; substantial OpenAI Codex assistance.
+"""
+from collections import Counter
+from pathlib import Path
+from hashlib import sha256
+import ast
+import importlib.util
+import sys
+from geometry import need,span,dim,canonical_chart
+
+
+def run(root):
+    path=root/'research/owned-centre-wire-floor/verify.py'
+    names={'points','dim','join','c_contact','l_roles','blocks','paid_profile','propagate'}
+    parsed=ast.parse(path.read_text());functions=[x for x in parsed.body if isinstance(x,ast.FunctionDef) and x.name in names]
+    need({x.name for x in functions}==names,'Exact predecessor helper inventory')
+    ctx={'Counter':Counter,'need':need,'ALL':frozenset(range(512))}
+    exec(compile(ast.Module(body=functions,type_ignores=[]),str(path),'exec'),ctx)
+    sys.path.insert(0,str(root/'research/joint-helper-lattice'))
+    import native_joint as J
+    c,programs,_,_,_=J.construct();spaces=[span(b) for b in c['frames']]
+    records={};expected=Counter({1:2237,2:388,3:494,4:147,5:36,8:8})
+    for direction,program in programs.items():
+        need(ctx['paid_profile'](c,program,spaces)==expected,'Reconstructed complete selected local bill')
+        low,up=ctx['propagate'](c,program,spaces)
+        need(all(low[i]<=up[i] for i in low),'Every fixed-word scalar contact interval')
+        rows=[]
+        for block in ctx['blocks'](program):
+            need(block['src'] is not None and len(block['t'])==22,'One source and 22 target contacts')
+            a=low[block['src']];common=a
+            for t in block['t']:common &= up[t]
+            need(dim(a)==8 and dim(common)==0,'Source-bound eight-rank intersection loss')
+            # At the actual current contact charts, Lagrangian intersection
+            # gives the same sharp floor, with arbitrary intermediate charts.
+            actual=canonical_chart(spaces[program[block['src']][2]],9)
+            for t in block['t']:actual &= canonical_chart(spaces[program[t][2]],9)
+            need(9-dim(actual)==8,'Actual Clifford-chart intersection attains rank-eight lower bound')
+            rows.append({'source_event':block['src'],'targets':block['t'],
+                         'source_lower_basis':list_basis(a),
+                         'source_lower_dimension':8,'source_and_target_caps_intersection_dimension':0,
+                         'rank_mass_lower_bound':8,'moment_lower_bound':'8^s',
+                         'baseline_paid_job':8})
+        need(len(rows)==8,'All eight blocks per orientation')
+        records[direction]=rows
+    return {'blocks':records,'orientations':2,'total_blocks':16,
+            'new_scope':'Arbitrary exact Clifford transports between canonical common-chart contacts, and typed-copy branching trees or their dual gathers. Persistent contact intervals and the scalar demand stay fixed.',
+            'excluded':'Changed cross-frame contact ABI, changed L paths/warps/coefficients, new observations or combinations of independent payloads outside the typed tree, other source words.',
+            'claim_type':'Written general lower-bound proof plus exact source-incidence checks, not an exhaustive circuit or proof-kernel verification.'}
+
+
+def list_basis(s):
+    from geometry import basis
+    return basis(s)
diff --git a/research/gaussian-cache-reuse/geometry.py b/research/gaussian-cache-reuse/geometry.py
new file mode 100644
index 0000000000..600e4350c2
--- /dev/null
+++ b/research/gaussian-cache-reuse/geometry.py
@@ -0,0 +1,128 @@
+"""Finite binary frame geometry and rooted cache-tree certificates.
+
+Metric/Clifford principles are classical. Retain Dugongue's chart grammar,
+Matarener's owned-center intersection proof, and the local geometry lineage.
+Apache-2.0; substantial OpenAI Codex assistance.
+"""
+from collections import Counter
+
+
+def need(ok, why):
+    if not ok:
+        raise ValueError(why)
+
+
+def span(basis):
+    s={0}
+    for x in basis:
+        s |= {v^x for v in tuple(s)}
+    return frozenset(s)
+
+
+def dim(s):
+    need(len(s)>0 and len(s)&(len(s)-1)==0,'binary subspace cardinality')
+    return len(s).bit_length()-1
+
+
+def distance(a,b):
+    return dim(a)+dim(b)-2*dim(a&b)
+
+
+def basis(s):
+    rows={}
+    for v in sorted(s):
+        for p in sorted(rows,reverse=True):
+            if v>>p&1:
+                v^=rows[p]
+        if v:
+            rows[v.bit_length()-1]=v
+    return list(rows.values())
+
+
+def subspaces(n):
+    seen={frozenset({0})}; todo=list(seen)
+    while todo:
+        s=todo.pop()
+        for v in set(range(1<<n))-s:
+            t=frozenset(s|{x^v for x in s})
+            if t not in seen:
+                seen.add(t);todo.append(t)
+    return sorted(seen,key=lambda s:(len(s),sorted(s)))
+
+
+def gf2_rank(rows):
+    basis_={}
+    for x in rows:
+        while x:
+            p=x.bit_length()-1
+            if p not in basis_:
+                basis_[p]=x;break
+            x^=basis_[p]
+    return len(basis_)
+
+
+def canonical_chart(u,n):
+    """Inverse-image Lagrangian L_U={(x,x+z):x in U,z in U-perp}."""
+    perp=[z for z in range(1<<n) if all((x&z).bit_count()%2==0 for x in u)]
+    return span([x|((x^z)<<n) for x in u for z in perp])
+
+
+def lagrangians(n):
+    """All isotropic n-spaces, used only in the bounded n<=2 control."""
+    out=[]
+    for s in subspaces(2*n):
+        if dim(s)!=n:
+            continue
+        b=basis(s); mask=(1<<n)-1
+        if all((((a&mask)&(v>>n)).bit_count()+((v&mask)&(a>>n)).bit_count())%2==0
+               for a in b for v in b):
+            out.append(s)
+    return out
+
+
+def tree_bound(charts,parents):
+    """Exact intersection-loss certificate for any equal-dimensional charts."""
+    need(len(charts)==len(parents)>0 and parents[0] is None,'rooted tree')
+    n=dim(charts[0]); common=charts[0]; mass=0; steps=[]
+    for i in range(1,len(charts)):
+        p=parents[i]
+        need(type(p) is int and 0<=p<i,'parent precedes child')
+        need(dim(charts[i])==n,'equal-dimensional Lagrangian charts')
+        edge=n-dim(charts[p]&charts[i]);drop=dim(common)-dim(common&charts[i])
+        need(drop<=edge,'intersection loss fits actual edge grade')
+        common &= charts[i]; mass+=edge
+        steps.append({'node':i,'parent':p,'grade':edge,'intersection_loss':drop})
+    need(mass>=n-dim(common),'tree rank-mass floor')
+    return {'edge_rank_mass':mass,'intersection_floor':n-dim(common),'steps':steps}
+
+
+def fanout_program(n=3):
+    """Two owned fields; original target updates remain in their given order."""
+    z=[];line=[1];ab=[1,2];ac=[1,4]
+    return [
+        ['CLEAR','Z'],['CLEAR','W'],
+        ['COPY','Z','X'],['MOVE','Z',z,line],
+        ['COPY','W','Z'],['MOVE','W',line,ab],['ADD','Y1','W',1],['CLEAR','W'],
+        ['COPY','W','Z'],['MOVE','W',line,ac],['ADD','Y2','W',1],['CLEAR','W'],
+        ['CLEAR','Z']]
+
+
+def dual_program():
+    """Inverse-transpose main endpoint; reversed gather, same three grades."""
+    z=[];line=[1];ab=[1,2];ac=[1,4]
+    return [
+        ['CLEAR','Z'],['CLEAR','W'],
+        ['COPY','W','Y1'],['DUAL_MOVE','W',ab,line],['ADD','Z','W',1],['CLEAR','W'],
+        ['COPY','W','Y2'],['DUAL_MOVE','W',ac,line],['ADD','Z','W',1],['CLEAR','W'],
+        ['DUAL_MOVE','Z',line,z],['ADD','X','Z',-1],['CLEAR','Z']]
+
+
+def tariffs(program):
+    paid=Counter();ordinary=Counter()
+    for e in program:
+        if e[0] in ('MOVE','DUAL_MOVE'):
+            r=distance(span(e[2]),span(e[3]))
+            if r:paid[r]+=1
+        else:ordinary[e[0]]+=1
+    return {'paid':dict(sorted(paid.items())),'ordinary_field_passes':dict(sorted(ordinary.items())),
+            'owned_fields':2,'new_productive_owners':0}
diff --git a/research/gaussian-cache-reuse/primitive.py b/research/gaussian-cache-reuse/primitive.py
new file mode 100644
index 0000000000..38e95b750b
--- /dev/null
+++ b/research/gaussian-cache-reuse/primitive.py
@@ -0,0 +1,155 @@
+"""Literal owned-cache primitives with exact dyadic-complex column checks.
+
+Classical copy/transport sharing; repository Clifford implementation retained
+unchanged and authenticated by the caller. Apache-2.0; Codex assistance.
+"""
+from collections import Counter
+from fractions import Fraction as Q
+from functools import lru_cache
+from geometry import need, distance, span, fanout_program, dual_program, tariffs
+
+ZERO=(Q(0),Q(0));ONE=(Q(1),Q(0))
+
+
+def add(a,b):
+    return a[0]+b[0],a[1]+b[1]
+
+
+def mul(a,b):
+    return a[0]*b[0]-a[1]*b[1],a[0]*b[1]+a[1]*b[0]
+
+
+def conjugate(ce,op):
+    out=ce.ident(op.n)
+    for e in op.circuit:
+        if e[0]=='P':part=ce.perm(op.n,e[1])
+        elif e[0]=='D':part=ce.diag(op.n,e[1],tuple(-a%4 for a in e[2]))
+        elif e[0]=='C':part=ce.cgate(op.n,e[1],-e[2])
+        elif e[0]=='X':part=ce.xgate(op.n,e[1])
+        elif e[0]=='phase':part=ce.Op(op.n,ce.identity(op.n),[('phase',-e[1]%4)])
+        else:raise ValueError('Unrecognized exact circuit primitive')
+        out=out.then(part)
+    return out
+
+
+def matrix(op):
+    cols=[]
+    for j in range(1<<op.n):
+        vec,den=op.zero_state(j)
+        cols.append([(Q(a,1<<den),Q(b,1<<den)) for a,b in vec])
+    return [list(row) for row in zip(*cols)]
+
+
+def mv(a,x):
+    return [sum_pairs(mul(v,w) for v,w in zip(row,x)) for row in a]
+
+
+def sum_pairs(values):
+    z=ZERO
+    for v in values:z=add(z,v)
+    return z
+
+
+def proportion(snapshot,current):
+    """Exact logical operator rows, not owner names or frame labels."""
+    if not snapshot:return Q(0) if not current else None
+    k=next(iter(snapshot));q=current.get(k,Q(0))/snapshot[k]
+    return q if {k:v*q for k,v in snapshot.items() if v*q}==current else None
+
+
+def run(ce,spaces):
+    n=3;frames=[ce.canonical_frame(n,list_basis(s)) for s in spaces]
+    edge_checks=0;non_nested=0
+    for i,a in enumerate(spaces):
+      for j,b in enumerate(spaces):
+        op=frames[i].adjoint().then(frames[j]);recipe,compiled=ce.lower_child(op)
+        need(recipe['rank']==distance(a,b),'Actual Clifford edge grade, including nonnested frames')
+        need(compiled.tab==op.tab and matrix(compiled)==matrix(op),'All-column normal form and absolute phase')
+        edge_checks+=1;non_nested+=int(not(a<=b or b<=a))
+    roles=['X','Y1','Y2','Z','W'];size=1<<n
+    forward=fanout_program();backward=dual_program()
+
+    @lru_cache(None)
+    def transition(kind,a,b):
+        op=ce.canonical_frame(n,list(a)).adjoint().then(ce.canonical_frame(n,list(b)))
+        return matrix(conjugate(ce,op) if kind=='DUAL_MOVE' else op)
+
+    def execute(program,column,wrong_phase=False,changed_source=False,supplied=None):
+        state={r:[ZERO]*size for r in roles} if supplied is None else {r:v[:] for r,v in supplied.items()}
+        if supplied is None:state[roles[column//size]][column%size]=ONE
+        mutated=False
+        for e in program:
+            kind,r=e[:2]
+            if kind=='CLEAR':state[r]=[ZERO]*size
+            elif kind=='COPY':state[r]=state[e[2]][:]
+            elif kind=='ADD':
+                state[r]=[add(x,(e[3]*y[0],e[3]*y[1])) for x,y in zip(state[r],state[e[2]])]
+                if changed_source and r=='Y1':
+                    state['X']=[(2*x,2*y) for x,y in state['X']]
+            else:
+                a,b=tuple(e[2]),tuple(e[3])
+                if wrong_phase and not mutated:
+                    kind='DUAL_MOVE' if kind=='MOVE' else 'MOVE';mutated=True
+                state[r]=mv(transition(kind,a,b),state[r])
+        return state
+
+    a1=matrix(ce.canonical_frame(n,[1,2]));a2=matrix(ce.canonical_frame(n,[1,4]))
+    transpose=lambda a:[list(row) for row in zip(*a)]
+    def expected(column,back=False,source_changed=False):
+        initial={r:[ZERO]*size for r in roles};initial[roles[column//size]][column%size]=ONE
+        out={r:initial[r][:] for r in roles}
+        out['Z']=out['W']=[ZERO]*size
+        if back:
+            delta1=mv(transpose(a1),initial['Y1']);delta2=mv(transpose(a2),initial['Y2'])
+            out['X']=[(x[0]-y[0]-z[0],x[1]-y[1]-z[1]) for x,y,z in zip(initial['X'],delta1,delta2)]
+        else:
+            out['Y1']=[add(x,y) for x,y in zip(initial['Y1'],mv(a1,initial['X']))]
+            source=[(2*x,2*y) for x,y in initial['X']] if source_changed else initial['X']
+            if source_changed:out['X']=source
+            out['Y2']=[add(x,y) for x,y in zip(initial['Y2'],mv(a2,source))]
+        return out
+    for column in range(len(roles)*size):
+        need(execute(forward,column)==expected(column),'Forward: all arbitrary persistent and owned entry columns')
+        need(execute(backward,column)==expected(column,True),'Raw inverse transpose: all arbitrary columns')
+    need(any(execute(forward,j,True)!=expected(j) for j in range(size)),'Wrong forward phase rejected')
+    need(any(execute(backward,j,True)!=expected(j,True) for j in range(size,3*size)),'Wrong raw-dual orientation rejected')
+    need(any(execute(forward,j,changed_source=True)!=expected(j,source_changed=True) for j in range(size)),
+         'Reusing a stale snapshot after a source change is rejected')
+    row={('X',()):Q(1)};changed={('X',()):Q(1),('Y',()):Q(1)}
+    need(proportion(row,changed) is None,'Changed source expression invalidates cache')
+    restored=dict(changed);restored.pop(('Y',()))
+    need(proportion(row,restored)==1,'A restored source is safe despite intervening writes')
+    need(proportion(row,{('X',()):Q(3,2)})==Q(3,2),'Specified scalar change can be absorbed in the ADD coefficient')
+    # Derived variant for an actual already-paid observation. Its correlation
+    # with X is an explicit caller precondition, never independent input credit.
+    existing=[['CLEAR','W']]+forward[4:-1]
+    for column in range(len(roles)*size):
+        initial={r:[ZERO]*size for r in roles};initial[roles[column//size]][column%size]=ONE
+        wanted={r:v[:] for r,v in initial.items()};wanted['W']=[ZERO]*size
+        for r,frame in [('Y1',(1,2)),('Y2',(1,4))]:
+            delta=mv(transition('MOVE',(1,),frame),initial['Z'])
+            wanted[r]=[add(x,y) for x,y in zip(initial[r],delta)]
+        need(execute(existing,column)==wanted,'Existing observation: every independent column; cache returned unchanged')
+    line=matrix(ce.canonical_frame(n,[1]))
+    for j in range(size):
+        supplied={r:[ZERO]*size for r in roles};supplied['X'][j]=ONE
+        supplied['Z']=mv(line,supplied['X'])
+        actual=execute(existing,0,supplied=supplied);wanted=expected(j)
+        need(all(actual[r]==wanted[r] for r in ('X','Y1','Y2','W')) and actual['Z']==supplied['Z'],
+             'Caller-proved observation Z=C_line X gives the intended target updates')
+    existing_tariff=tariffs(existing);existing_tariff['owned_fields']=1
+    existing_tariff['borrowed_observation_fields']=1
+    return {'exact_frame_pairs':edge_checks,'non_nested_pairs':non_nested,
+            'address_dimension':3,'addresses_per_field':size,'independent_original_fields':3,
+            'arbitrary_owned_entry_fields_cleared':2,'all_input_columns_per_orientation':len(roles)*size,
+            'forward':tariffs(forward),'raw_inverse_transpose':tariffs(backward),
+            'existing_paid_observation_variant':{'tariff':existing_tariff,'all_input_columns':len(roles)*size,
+                'precondition':'Z=C_line X for the exact required logical snapshot; caller supplies and already pays that observation. Z is returned unchanged. Its creation, retention and eventual cleanup remain caller costs.'},
+            'negative_controls':['wrong forward phase','wrong dual orientation','stale snapshot'],
+            'lifetime_controls':['restored source','specified proportional source'],
+            'primitive_scope':'Exact finite module plus written block/tensor lift; no installed selected-caller improvement.'}
+
+
+def list_basis(s):
+    from geometry import basis
+    return basis(s)
diff --git a/research/gaussian-cache-reuse/verify.py b/research/gaussian-cache-reuse/verify.py
new file mode 100644
index 0000000000..e1c2b0019b
--- /dev/null
+++ b/research/gaussian-cache-reuse/verify.py
@@ -0,0 +1,110 @@
+"""Exact cache construction, geometric bound and source application.
+
+Standard library only. Apache-2.0; substantial OpenAI Codex assistance.
+"""
+from decimal import Decimal as D,localcontext
+from fractions import Fraction as Q
+from hashlib import sha256
+from itertools import product
+from pathlib import Path
+import argparse
+import importlib.util
+import json
+import sys
+
+sys.dont_write_bytecode=True
+HERE=Path(__file__).resolve().parent;ROOT=HERE.parents[1]
+sys.path.insert(0,str(HERE))
+import geometry as G
+import primitive as P
+import center
+
+
+def authenticate():
+    manifest=json.loads((HERE/'SOURCES.json').read_text())
+    for row in manifest['files']:
+        if row.get('usage')!='input':
+            continue
+        G.need(sha256((ROOT/row['path']).read_bytes()).hexdigest()==row['sha256'],'Changed source '+row['path'])
+    plan=json.loads((HERE/'PLAN.json').read_text())
+    G.need(sha256((HERE/'geometry.py').read_bytes()).hexdigest()==plan['geometry_sha256'],'Unchanged prospective geometry')
+    return plan
+
+
+def load(path,name):
+    spec=importlib.util.spec_from_file_location(name,path)
+    module=importlib.util.module_from_spec(spec);sys.modules[name]=module;spec.loader.exec_module(module)
+    return module
+
+
+def geometry_checks():
+    ls=G.lagrangians(2);G.need(len(ls)==15,'All two-qubit Lagrangians including noncanonical phase charts')
+    checks=0
+    for a,b,c in product(ls,repeat=3):
+        for parents in ([None,0,0],[None,0,1]):
+            G.tree_bound([a,b,c],parents);checks+=1
+    spaces=G.subspaces(3)
+    G.need(len(spaces)==16,'All canonical three-axis frames')
+    terminals=[G.span([]),G.span([1,2]),G.span([1,4])]
+    choices=[]
+    for f in spaces:
+        ranks=sorted(G.distance(t,f) for t in terminals)
+        choices.append({'meeting_basis':G.basis(f),'edge_grades':ranks})
+    with localcontext() as ctx:
+        ctx.prec=60
+        for s in [D(1)-D('.00302015'),D('.5')]:
+            power=lambda r:D(0) if not r else (D(r).ln()*s).exp()
+            scores=[sum(power(r) for r in x['edge_grades']) for x in choices]
+            G.need(abs(min(scores)-min(D(3),2*power(2)))<D('1e-55'),'Exact-profile three-terminal minimum')
+        transition=(D(3)/2).ln()/D(2).ln()
+    tree=[G.canonical_chart(G.span(b),3) for b in [[],[1],[1,2],[1,4]]]
+    sharp=G.tree_bound(tree,[None,0,1,1])
+    G.need(sharp['edge_rank_mass']==sharp['intersection_floor']==3,'Branching example attains intersection bound')
+    return {'all_two_qubit_lagrangians':len(ls),'arbitrary_chart_path_and_tree_checks':checks,
+            'canonical_three_axis_meetings':choices,'cache_tree_mass':sharp,
+            'transition_s':str(transition),'scope':'General proof is written; these finite checks corroborate its ranks and transcription.'}
+
+
+def price_checks(plan):
+    m=load(ROOT/'research/higher-moment-strictification/verify.py','cache_exact_moments')
+    def margin(targets,paid,c):
+        a=m.moment(targets,1-c);b=m.moment(paid,1-c)
+        return a[0]-b[1],a[1]-b[0]
+    gains={}
+    for c in ['.00302015','.004','.005','.01']:
+        gain=margin({2:2},{1:3},Q(c));debt=margin({2:2},{1:4},Q(c))
+        G.need(gain[0]>0 and debt[1]<0,'Positive reuse gain; one extra H1 destroys it')
+        gains[c]={'saving':[str(v) for v in gain],'after_one_extra_H1':[str(v) for v in debt]}
+    G.need(margin({2:2},{1:3},Q('.5'))[1]<0,'At exponent one-half separate copies beat the three-H1 tree')
+    with localcontext() as ctx:
+        ctx.prec=55
+        predicted=D(plan['predicted_gain_at_selected_exponent'])
+        lo,hi=margin({2:2},{1:3},Q('.00302015'))
+        to_dec=lambda q:D(q.numerator)/q.denominator
+        G.need(to_dec(lo)-D('1e-52')<predicted<to_dec(hi)+D('1e-52'),'Frozen preconstruction gain agrees with exact bounds')
+    return {'baseline_paid':{'2':2},'cache_paid':{'1':3},'productive_owner_delta':0,
+            'outward_moment_gains':gains,'repair_budget':'Strictly less than one extra H1 per module at every tested positive saving.',
+            'selected_installation':False,'new_kappa':None}
+
+
+def run():
+    plan=authenticate()
+    ce=load(ROOT/'research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py','cache_pinned_clifford')
+    primitive=P.run(ce,G.subspaces(3));print('PASS_EXACT_CACHE_PRIMITIVE',flush=True)
+    geo=geometry_checks();print('PASS_GENERAL_CHART_TREE_CONTROLS',flush=True)
+    source=center.run(ROOT);print('PASS_ALL_16_SELECTED_CENTER_BLOCKS',flush=True)
+    return {'status':'PASS_GAUSSIAN_CACHE_REUSE_AND_SHARP_CENTER_BOUND_NO_NEW_KAPPA',
+            'plan_sha256':sha256((HERE/'PLAN.json').read_bytes()).hexdigest(),
+            'primitive':primitive,'geometry':geo,'price':price_checks(plan),'selected_centers':source,
+            'claims':'Constructive all-width block identity under retained Gaussian/owned-erasure contracts; written sharp bound for typed-copy trees with fixed canonical contact caps. Finite exact corroboration, no formal kernel or full supplier admission.'}
+
+
+if __name__=='__main__':
+    ap=argparse.ArgumentParser();ap.add_argument('--write',action='store_true');args=ap.parse_args()
+    # JSON object keys are strings. Compare the serialized schema so an exact
+    # integer rank key from the frozen geometry helper is not a false mismatch.
+    result=json.loads(json.dumps(run()))
+    if args.write:
+        (HERE/'RESULT.json').write_text(json.dumps(result,indent=2)+'\n')
+    else:G.need(result==json.loads((HERE/'RESULT.json').read_text()),'Every saved mathematical field reproduced')
+    print(json.dumps({'status':result['status'],'new_kappa':None,'module_gain':json.loads((HERE/'PLAN.json').read_text())['predicted_gain_at_selected_exponent']},sort_keys=True))