diff --git a/research/centre-block-repair-information/INDEPENDENT.md b/research/centre-block-repair-information/INDEPENDENT.md
new file mode 100644
index 0000000000..648a5e0ad3
--- /dev/null
+++ b/research/centre-block-repair-information/INDEPENDENT.md
@@ -0,0 +1,166 @@
+# Independent bounded-block information argument
+
+For the declared selected calls 0/4 source model, arbitrary linear repair
+observations may mix the sources within each block of a disjoint partition of
+physical owners. A global, possibly nonlinear decoder receives every old
+transcript and every block repair. If a block has b<=6 owners, its exact minimum
+repair dimension remains **104b complex scalars**. This is total information per
+block; mixed observations need not be allocated to individual owners.
+
+No paid implementation, recursive rank mass, new kappa, or saving for a block
+of seven or more owners is established here.
+
+## Source model and finite premises
+
+Let G be the finite group acting on its regular cover. Every owner g has an
+independent source vector x(g) in C^112. Helper and target dirt are held equal in
+the executions being compared. Source differences are constant in payload and
+spectator factors. The observations are
+
+```
+z(g)=R x(g),
+y(d)=sum_p H[:,p] x_p(d rho_p),       H=R/4.
+```
+
+R has rank eight. Every one- or two-column subset is independent. The 112 route
+matrices are distinct involutions in O_73(F_2), and all 12,432 ordered products
+rho_p rho_q, p!=q, are different. These finite premises belong to this selected
+source pair; they are not general assertions about suppliers.
+
+A repair for block B is an arbitrary complex-linear map E_B of its 112|B|
+initial source coordinates to r_B complex scalars. The decoder receives all old
+transcripts and all repairs, with arbitrary computation and routing granted.
+Other source-dependent observations are excluded. Nonlinear decoding is allowed;
+nonlinear encoding by E_B is outside the contract.
+
+The native application inherits the predecessor's common-frame conjugation,
+complete first-call constant-source endpoint, and retained local-view/regular-
+cover premises. This check does not reprove those native identities. Its
+later-row reconstruction explicitly uses the first-call identification of D/T
+source differences.
+
+## General counting lemma
+
+Suppose every set of fewer than s columns of R is independent, H has the same
+columns up to one common nonzero scalar, routes are distinct, and at most M
+ordered pairs p!=q yield any given relative route rho_p^-1 rho_q. For a finite
+source set B let S_B be its old observation and T_B its contribution to the
+entire later field. A nonzero x_B in both kernels, supported on b active owners,
+necessarily satisfies
+
+```
+M(b-1) >= s(s-1).
+```
+
+Fix an active source owner g. Its nonzero port support P_g has size at least s
+because R x(g)=0. These ports go to distinct output owners d_p=g rho_p^-1.
+At each such output, the nonzero term H[:,p]x_p(g) must cancel with terms from
+at least s-1 other active owners: distinct contributing owners use distinct
+port labels, and fewer than s columns are independent.
+
+For a fixed other owner h, sharing an output through ports p,q implies
+
+```
+g^-1 h = rho_p^-1 rho_q.
+```
+
+Thus g and h share at most M output destinations. Counting the other-owner
+incidences needed at the destinations from P_g gives
+
+```
+(s-1)|P_g| <= M(b-1).
+```
+
+As |P_g|>=s, the lemma follows. This is an all-parameter written implication;
+it does not enumerate owners, blocks, group elements, or input coefficients.
+
+## Exact block repair dimension
+
+The checked premises allow s=3 and give M=1. A nonzero joint-kernel vector
+therefore requires at least seven active source owners. For every |B|<=6,
+
+```
+ker S_B intersect ker T_B = {0}.
+```
+
+Vary only the source coordinates in one block B. All other blocks' repairs and
+all other old transcripts are zero on this difference. Correctness of any
+nonlinear decoder forces
+
+```
+ker S_B intersect ker E_B subset ker T_B,
+```
+
+hence E_B must be injective on ker S_B. The old observation is a direct sum of
+rank-eight maps, so
+
+```
+r_B >= dim ker S_B = (112-8)|B| = 104|B|.
+```
+
+This argument is unaffected by decoding across partition blocks. Its crucial
+restriction is that repairs have disjoint source domains.
+
+For equality choose eight pivot columns J of R. At each owner retain the 104
+source coordinates outside J. Subtract their known contribution from z(g) and
+invert R[:,J] to recover every source vector, then reconstruct every later
+query using the route formula. These 104|B| coordinate reads are permitted by
+the block contract. This supplies an abstract information interface only.
+
+Seven owners are merely a necessary threshold for a possible joint-kernel
+vector. There is no claim that such a vector exists for seven owners, or that
+larger blocks admit a saving.
+
+## Independent finite verification
+
+Run from the repository root:
+
+```
+python3 -I -O -B research/centre-block-repair-information/independent.py
+```
+
+The checker imports neither the parent checker nor any predecessor checker.
+It authenticates these source bytes before decoding unique regular members:
+
+* Archive research/community-frontier1094-audit/selected-replay.tar.gz:
+  SHA-256 f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6.
+* Canonical word member
+  candidate/strict/global/base/providers/gauge44/CANONICAL-WORD.json.gz:
+  compressed SHA-256
+  16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219.
+* Route member
+  candidate/strict/global/base/work/complex-nine-native/DATA-PHASES.json:
+  SHA-256 c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa.
+
+It reconstructs old query covectors by reverse exact rational adjoints of the
+canonical additions and scalings. Later covectors use the canonical inverse-
+transpose generators and cut, then the explicit inherited D/T identification.
+The resulting R/H must equal the predecessor receipt exactly, with H=R/4.
+Exact rational elimination checks rank eight; one nonzero rational 2x2 minor
+is found for each of 6,216 column pairs. These equalities and nonzero rational
+minors remain valid over C.
+
+For each route, the independent implementation decomposes a local vector in
+the orthonormal chart (q,b_0,...,b_7), fixes its q coefficient, swaps each b_j
+coefficient with coordinate 9+j, and fixes coordinates 17 through 72. It checks
+all 73 columns for orthogonality and involution, then forms every ordered
+distinct-port product on all 73 columns. It does not use the predecessor's
+transvection formula. The product-multiplicity histogram must be {1:12432}.
+Output includes hashes of the complete pair-minor and route-product
+certificates. Negative controls reject a parallel-column alteration and
+malformed or collapsed route source/order data; these are premise checks,
+not native executions.
+
+Finite coverage is precisely 112 columns, 6,216 unordered column pairs, 112
+routes and 12,432 ordered distinct-port products. The written lemma covers
+all finite disjoint partitions of the retained regular cover whose blocks
+have one through six owners and every complex source difference in the
+stated slice. There is no formal-kernel proof, full native cold replay,
+nonconstant native-input rank calculation, larger-block classification,
+paid recursive bill, or kappa claim.
+
+The source matrix, scalar quarter identity, selected route recipes and native
+source interpretation are predecessor work credited in
+research/centre-owner-observation-floor/README.md. This independent check and
+bounded-block argument were prepared with OpenAI Codex assistance. The checker
+is licensed Apache-2.0.
diff --git a/research/centre-block-repair-information/README.md b/research/centre-block-repair-information/README.md
new file mode 100644
index 0000000000..cf564c02ae
--- /dev/null
+++ b/research/centre-block-repair-information/README.md
@@ -0,0 +1,208 @@
+# Small owner blocks do not compress selected-centre information repair
+
+**Scoped information theorem, exact finite premises; no new kappa or native
+supplier.** In the selected PR1094 calls-0/4 observation model, permitting each
+repair observation to mix source data from a block of **up to six physical cover
+owners** still requires exactly **104 additional scalar linear observations per
+owner**. Arbitrary global, even nonlinear, decoding of those observations is
+allowed. The earlier owner-local theorem covers blocks of one; this result
+tests a changed locality contract rather than repeating that theorem.
+
+The new finite premise is that all **12,432 ordered nonidentity products** of
+the actual 112 owner routes are distinct. Together with **6,216 nonparallel
+column-pair checks**, this implies that a nonzero vector invisible to both the
+old and later query fields must involve at least seven source owners. Seven is
+only a lower bound; no seven-owner construction is claimed.
+
+## Exact contract
+
+Use the same rational constant-payload source model as
+[`centre-owner-observation-floor`](../centre-owner-observation-floor/README.md).
+Let G be the finite regular orthogonal cover group. For each cover owner g,
+let x(g) in C^112 vary independently. Compared executions have equal arbitrary
+ordinary target/helper dirt. The old observations and desired later field are
+
+```text
+Sx(g) = R x(g),
+Tx(d) = sum_p H[:,p] x_p(d rho_p),       H = R/4.
+```
+
+Here R is the actual eight-by-112 centre matrix, and the 112 rho_p are the
+source-bound involutory owner routes, represented by 73-by-73 binary matrices.
+The native interpretation of these equations remains conditional on the
+predecessors' common-frame, constant-endpoint and source-adapter identities.
+This is not a native cold replay. In particular, a regular cover owner is an
+element of G, not an ordinary helper-family index.
+
+Partition G into disjoint nonempty blocks B. A repair at B retains scalar
+**linear** observations E_B of the initial x(g) for g in B; it may mix all ports
+and all owners within B. The rows may be complex and may differ by block.
+All old fields Sx and all repair observations are then available to an arbitrary
+global decoder. No additional source-dependent state is available. The decoder
+must recover **the entire Tx field**, not one output owner or just the eventual
+supplier endpoint. Constants independent of x can be subtracted and do not
+change the theorem.
+
+**Theorem.** If every block has size at most six, each block needs at least
+104|B| repair coordinates. This is attainable as an abstract linear-information
+interface, and hence the total additional-coordinate minimum is 104|G|.
+
+## Proof
+
+The exact checks establish three premises:
+
+1. R has rank eight, every column is nonzero, and every pair of distinct columns
+   is linearly independent over Q, hence also over C. H=R/4 has the same property.
+2. The 112 rho_p are distinct involutions in the group acting regularly on G.
+3. The map (p,q) -> rho_p rho_q is injective for p != q: all 112*111 products
+   are distinct, with every one of their 73 binary columns compared exactly.
+
+Suppose x is nonzero and Sx=Tx=0, supported on b distinct source owners.
+Choose an active source owner g. Since R x(g)=0, premise 1 implies that at least
+three port coordinates of x(g) are nonzero. They go to distinct output owners
+d=g rho_p because the routes are distinct.
+
+At each such output d, the contribution from g is nonzero. To cancel it in
+Tx(d), at least two other source owners must contribute: one other contribution
+would be a dependence between two distinct columns of H. There is at most one
+port from any particular source owner at d.
+
+A fixed pair of distinct source owners g,h can share at most one output owner.
+Indeed, an equality g rho_p=h rho_q implies
+
+```text
+h^(-1) g = rho_q rho_p.
+```
+
+The right side uniquely identifies the ordered pair (q,p) by premise 3; the
+case p=q would force g=h. Thus the at least three outputs reached from g need
+at least six **different** other source owners. Consequently b>=7.
+
+Now restrict input variations to a single block B, with |B|<=6. Write S_B for
+the old observations of that block, and T_B for its contribution to the entire
+later field. The argument proves
+
+```text
+ker S_B intersect ker T_B = {0}.
+```
+
+Since rank(S_B)=8|B|, its kernel has dimension 104|B|. All other blocks'
+source-dependent observations vanish on this restricted input. If E_B had
+fewer than 104|B| scalar rows, its restriction to ker S_B would have a nonzero
+kernel vector. That vector and zero would give identical old and repair
+observations but different Tx. Even a nonlinear decoder cannot distinguish
+them. Therefore at least 104|B| rows are necessary.
+
+For attainment, choose eight independent columns of R. Read the other 104
+source coordinates separately at each owner, subtract their contribution from
+R x(g), and invert the eight-by-eight pivot matrix. This reconstructs every
+x(g), so it reconstructs Tx with the granted arbitrary global processing.
+The receipt lists the exact pivot and complementary coordinates. This is an
+information-level upper bound, not a priced collection or restoration circuit.
+
+More generally, if source and destination column-dependence supports are at
+least s and t, and a source-owner pair can share at most M destinations, the
+same argument gives M(b-1)>=s(t-1). Only s=t=3 and M=1 are certified here.
+
+## Exact checks and controls
+
+`verify.py` explicitly reuses ywz65's pinned forward scalar interpreter and
+route construction. It replays both complete local scalar endpoints on all
+704 ordinary symbolic inputs, checks the selected chronological pair and
+intervening data separation, derives R and H, and compares their coefficients
+to the predecessor receipt. It then checks all column pairs and all ordered
+route products and certifies the 104-coordinate information repair.
+
+`independent.py` reconstructs the cut matrices with reverse adjoints of the
+literal canonical word, rather than importing that forward interpreter. It
+computes the route actions by orthonormal chart swaps and compares the finite
+premises. `INDEPENDENT.md` independently reviews the all-block argument.
+Both implementations have the same AI-assisted contribution owner; specialist
+separation is not independent human or formal-kernel review.
+
+The registered replay also runs three behavioral controls: changed executable
+source is rejected before execution, a receipt claiming seven-owner coverage
+is rejected, and an occupied output is preserved. The forward interpreter is
+compiled from its authenticated source bytes, so a preexisting bytecode cache
+cannot replace that source in a direct replay.
+
+Six primary mathematical controls include a rejected parallel column, a
+rejected duplicate route, a collapsed-route interface requiring no repair, a
+two-owner C2 counterexample when the nonparallel-column premise is removed,
+and loss of one dimension after omitting a complementary read. The sixth is
+especially relevant: the actual columns satisfy R_44+R_38-R_24=0. Placing these
+three values at the three owners d rho_44, d rho_38, d rho_24 cancels T at d,
+but does **not** preserve S at those owners. Thus a three-owner kernel of T
+alone cannot refute the theorem. These are mathematical controls, not a census
+of owner blocks.
+
+## Cost decision and limits
+
+The proposed change was block-local acquisition of a shared centre cache.
+Ideal two-call sharing would remove half of the incumbent 64 centre charge and
+half of its eight rank-eight children per call before added costs. That
+predecessor planning relaxation does not provide a repair implementation.
+The present result rejects **information compression** through blocks of size
+at most six: the required repair dimension stays exactly 104 per owner.
+
+No scalar-coordinate count here is equated with recursive rank, paid mass,
+arrays, bits or tape steps. Acquisition, routing, storage, dirty restoration,
+precision, hosting and recursive child costs of a repair remain unknown. An
+implementation might change those costs while preserving dimension. No complete
+cost rejection of every six-owner circuit, selected-frontier change, or exponent
+improvement follows. The family decision is to stop before unpriced synthesis.
+
+The general block statement is a written proof from finite source-bound premises;
+it is not a finite enumeration of all subsets of G or a theorem-kernel proof.
+Overlapping observation supports, changed query cuts, final-output-only readers,
+additional source-dependent state, nonregular actions, nonlinear observations
+and blocks of size seven or more are outside the theorem.
+
+## Reproduce
+
+Python 3.12 and the standard library, from the repository root:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/centre-block-repair-information
+python3 -I -O -B research/centre-block-repair-information/verify.py
+python3 -I -O -B research/centre-block-repair-information/independent.py
+```
+
+Local validation passed the complete registered replay on CPython 3.12.12 and
+the optimized primary replay on CPython 3.14.6, including the six primary
+mathematical controls, three independent premise controls and three behavioral
+integrity tests. These checks cover the stated finite premises and artifacts;
+they do not turn the written implication into a formal-kernel proof.
+
+Inputs, exact base and source hashes are in `SOURCES.json`. The frozen selected
+replay archive is read without extraction; no selected cold replay or hosted CI
+pass is implied. The source base is
+`d8e0f83f00191df62174b641e9fff055c357f641`, priority revision 6, selected-record
+SHA256 `bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129`.
+Current coordination and scope are in [Discussion3062](https://github.com/CrocSwap/integer-mult-bounds/discussions/3062).
+
+## Open next questions
+
+Can a named block of at least seven owners admit a nonzero vector in both
+kernels, and can that change be used by a legally priced repair? First specify
+one concrete owner block and solve the combined old/routed equations exactly;
+seven is not asserted sufficient. A dimension reduction alone still needs a
+source-access, restoration and complete recursive invoice before supplier work
+is justified. A changed chronological readout or final-output-only contract is
+another question and must specify its exact source-dependent observations.
+
+## Credit and license
+
+Aaron Wang/navinor's PR2391 supplies the native centre-reuse witness and the
+additional-observation question. ywz65's `centre-owner-observation-floor`
+supplies the sharp owner-local theorem, source matrices and route interface;
+its forward interpreter is reused with its notice intact. Credit Sagar Thakrar
+(PR2199 and Clifford conventions), Adam Gall (PR1918), commdata2338 (PR2048),
+DreamingOfClouds' common-frame lineage, and the selected construction/emitter
+lineage of Rohan Arun, Jeremy Kothe, Hao Yan and icekylinx, as recorded by those
+sources. The new contribution is the ordered-route-product certificate and
+the extension to every block of up to six owners.
+
+Ross Richardson, with substantial OpenAI Codex assistance (GPT-6.1 Sol), including
+a separate observation-kernels specialist derivation and implementation.
+Apache-2.0. No independent human or formal-kernel review is claimed.
diff --git a/research/centre-block-repair-information/RESULT.json b/research/centre-block-repair-information/RESULT.json
new file mode 100644
index 0000000000..1127acd01b
--- /dev/null
+++ b/research/centre-block-repair-information/RESULT.json
@@ -0,0 +1,163 @@
+{
+  "R_sha256": "3666960c2e8467e22b688b3c029f5f430984bf6e1cd9db09bf1df8b5b6e22346",
+  "T_kernel_without_old_kernel_control": {
+    "coefficients": [
+      "1",
+      "1",
+      "-1"
+    ],
+    "ports": [
+      44,
+      38,
+      24
+    ]
+  },
+  "all_blocks_proved": {
+    "extra_scalar_linear_observations_exact": "104*block_size",
+    "maximum_size": 6,
+    "minimum_size": 1
+  },
+  "column_pair_minor_sha256": "92ea5f6b7e8a96afb9913e1e62fe7c4a81072c20269a99a0d9ea9ff780ff17e9",
+  "controls": [
+    "parallel_column_rejected",
+    "duplicate_route_rejected",
+    "collapsed_routes_need_no_repair",
+    "parallel_column_C2_two_owner_counterexample",
+    "three_owner_T_kernel_fails_old_kernel",
+    "103_coordinate_repair_loses_dimension"
+  ],
+  "distinct_nonidentity_route_products": 12432,
+  "kernel_nonzero_owner_support_lower_bound": 7,
+  "model": "PR1094 calls0/4; independent scalar source values by regular cover owner; equal ordinary dirt",
+  "nonparallel_column_pairs": 6216,
+  "old_rank": 8,
+  "ordered_nonidentity_route_products": 12432,
+  "ordered_route_product_sha256": "f9c783abfcaae83a9b93b8cca86b2e34ae148c7ede827e4f0a33250349fb6f49",
+  "output_minimum_active_owners_lower_bound": 3,
+  "ports": 112,
+  "relative_route_multiplicity_histogram": {
+    "1": 12432
+  },
+  "repair_coordinate_reads": [
+    7,
+    8,
+    9,
+    10,
+    11,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    26,
+    27,
+    28,
+    29,
+    30,
+    31,
+    32,
+    33,
+    34,
+    35,
+    36,
+    37,
+    38,
+    39,
+    40,
+    41,
+    42,
+    43,
+    44,
+    45,
+    46,
+    47,
+    48,
+    49,
+    50,
+    51,
+    52,
+    53,
+    54,
+    55,
+    56,
+    57,
+    58,
+    59,
+    60,
+    61,
+    62,
+    63,
+    64,
+    65,
+    66,
+    67,
+    68,
+    69,
+    70,
+    71,
+    72,
+    73,
+    74,
+    75,
+    76,
+    77,
+    78,
+    79,
+    80,
+    81,
+    82,
+    83,
+    84,
+    85,
+    86,
+    87,
+    88,
+    89,
+    90,
+    91,
+    92,
+    93,
+    94,
+    95,
+    96,
+    97,
+    98,
+    99,
+    100,
+    101,
+    102,
+    103,
+    104,
+    105,
+    106,
+    107,
+    108,
+    109,
+    110,
+    111
+  ],
+  "repair_pivot_columns": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    12
+  ],
+  "route_count": 112,
+  "route_dimension": 73,
+  "scope": "finite exhaustive premises plus written all-block theorem; no kernel proof, native tariff, supplier admission or new kappa",
+  "source_base": "d8e0f83f00191df62174b641e9fff055c357f641",
+  "source_minimum_active_ports_lower_bound": 3,
+  "status": "PASS_CENTRE_BLOCK_REPAIR_INFORMATION"
+}
diff --git a/research/centre-block-repair-information/SOURCES.json b/research/centre-block-repair-information/SOURCES.json
new file mode 100644
index 0000000000..f608c397e1
--- /dev/null
+++ b/research/centre-block-repair-information/SOURCES.json
@@ -0,0 +1,46 @@
+{
+  "schema_version": 1,
+  "base_commit": "d8e0f83f00191df62174b641e9fff055c357f641",
+  "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129",
+  "selected_source_head": "0fc329d0bec93ca7cd288eaea1295172e8789810",
+  "files": [
+    {
+      "path": "research/community-frontier1094-audit/selected-replay.tar.gz",
+      "usage": "input",
+      "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f",
+      "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6"
+    },
+    {
+      "path": "research/centre-owner-observation-floor/verify.py",
+      "usage": "input",
+      "git_blob": "834acabd860473d45dd36c52336874f169503e33",
+      "sha256": "9e64f741e95df9aa73b6918b3a2dba45076fc31304418d4251fee99912e040ff"
+    },
+    {
+      "path": "research/centre-owner-observation-floor/RESULT.json",
+      "usage": "input",
+      "git_blob": "14532324c629e822f79c941053911f52fba546bb",
+      "sha256": "d238990b46dba2e4b92919602ef17de994f02a3d904adb399efc1dbcd032c86e"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "pin": "base_commit:docs/research/agent-task-catalog.json",
+      "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5",
+      "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "pin": "base_commit:certificates/selected-result.json",
+      "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81",
+      "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+    }
+  ],
+  "source_credit": [
+    "ywz65, centre-owner-observation-floor, exact source matrix/route interface and owner-local theorem",
+    "Aaron Wang/navinor, PR2391, native centre-reuse kernel and additional-observation question",
+    "Selected PR1094 and retained emitter/native lineage; see README"
+  ],
+  "license": "Apache-2.0; predecessor notices retained"
+}
diff --git a/research/centre-block-repair-information/TASK.json b/research/centre-block-repair-information/TASK.json
new file mode 100644
index 0000000000..fad51bf3de
--- /dev/null
+++ b/research/centre-block-repair-information/TASK.json
@@ -0,0 +1,67 @@
+{
+  "schema_version": 1,
+  "task_id": "centre-path-sharing",
+  "priority_revision": 6,
+  "base_commit": "d8e0f83f00191df62174b641e9fff055c357f641",
+  "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": "refined",
+  "actual_scope": "Exact additional-observation minimum for selected calls0/4 with disjoint blocks of up to6 physical cover owners; scalar linear observations, arbitrary global decoder, entire later query field.",
+  "scope_change_reason": "Change the owner-local repair restriction by allowing mixed-owner linear observations; certify finite route-product premises and prove that all blocks of size1..6 still need104 extra coordinates per owner.",
+  "bottleneck_link": "Tests an information prerequisite of centre-cache sharing before any unpriced acquisition/restoration circuit is synthesized; dimensions are not recursive mass.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop at a sharp small-block theorem and exact controls; no search for larger blocks, no seven-owner existence or native tariff claim.",
+  "outcome": "negative-result",
+  "evidence": "RESULT.json and independent.py:6216 nonparallel pairs;12432 unique ordered relative routes;104-coordinate attainment; written support lower bound7 and all-block proof.",
+  "author": "Ross Richardson",
+  "ai_assistance": "Substantial OpenAI Codex assistance using GPT-6.1 Sol, with a separate mathematical observation-kernels specialist implementation and proof check.",
+  "open_questions": [
+    {
+      "question": "Does one named block of at least7 cover owners admit a nonzero vector in both old and routed query kernels?",
+      "why_it_matters": "The certified information obstruction only covers blocks of up to6 owners;7 is necessary but is not asserted sufficient.",
+      "first_step": "Specify one actual owner block and solve its combined old and routed equations exactly, with a full source-access/restoration budget before synthesis.",
+      "blocked_by": "No concrete larger block, chronological observation collector, restoration circuit or recursive tariff is supplied."
+    }
+  ]
+}
diff --git a/research/centre-block-repair-information/VERIFY.json b/research/centre-block-repair-information/VERIFY.json
new file mode 100644
index 0000000000..b47c0bf70c
--- /dev/null
+++ b/research/centre-block-repair-information/VERIFY.json
@@ -0,0 +1,45 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/community-frontier1094-audit/selected-replay.tar.gz",
+    "research/centre-owner-observation-floor/verify.py",
+    "research/centre-owner-observation-floor/RESULT.json"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Exact selected endpoints and chronological source bindings,6216 column minors,12432 route products,104-coordinate attainment and6 mathematical controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/independent.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Separate reverse-adjoint R/H reconstruction and orthonormal-chart route actions; independent exact premises and three premise controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/test_verify.py"
+      ],
+      "timeout_seconds": 180,
+      "checks": "Changed executable source is rejected before execution; a seven-owner overclaim fails receipt comparison; occupied output evidence is preserved."
+    }
+  ]
+}
diff --git a/research/centre-block-repair-information/independent.py b/research/centre-block-repair-information/independent.py
new file mode 100644
index 0000000000..d2db50ec7a
--- /dev/null
+++ b/research/centre-block-repair-information/independent.py
@@ -0,0 +1,282 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Independent finite premises for the bounded block-repair theorem.
+
+OpenAI Codex assistance; source and mathematical scope are in INDEPENDENT.md.
+This checker imports no primary or predecessor verification code.  It pulls
+canonical query covectors backwards and constructs each route by swapping two
+orthonormal coordinate charts, rather than using the predecessor's transvection
+formula.  No native supplier, recursive cost or formal kernel is evaluated.
+"""
+
+from collections import Counter
+from fractions import Fraction as Q
+from itertools import combinations
+from pathlib import Path
+import gzip
+import hashlib
+import json
+import tarfile
+
+
+ROOT = Path(__file__).resolve().parents[2]
+ARCHIVE = ROOT / "research/community-frontier1094-audit/selected-replay.tar.gz"
+ARCHIVE_SHA256 = "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6"
+WORD = "candidate/strict/global/base/providers/gauge44/CANONICAL-WORD.json.gz"
+PHASES = "candidate/strict/global/base/work/complex-nine-native/DATA-PHASES.json"
+MEMBER_SHA256 = {
+    WORD: "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219",
+    PHASES: "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa",
+}
+
+
+def require(condition, reason):
+    if not condition:
+        raise ValueError(reason)
+
+
+def canonical(value):
+    return json.dumps(value, sort_keys=True, separators=(",", ":")).encode()
+
+
+def digest(value):
+    return hashlib.sha256(canonical(value)).hexdigest()
+
+
+def sources():
+    require(hashlib.sha256(ARCHIVE.read_bytes()).hexdigest() == ARCHIVE_SHA256,
+            "archive SHA-256")
+    decoded = {}
+    with tarfile.open(ARCHIVE) as archive:
+        for name, expected in MEMBER_SHA256.items():
+            members = [m for m in archive.getmembers() if m.name == name]
+            require(len(members) == 1 and members[0].isfile(),
+                    "one regular archive member: " + name)
+            raw = archive.extractfile(members[0]).read()
+            require(hashlib.sha256(raw).hexdigest() == expected,
+                    "member SHA-256: " + name)
+            decoded[name] = json.loads(gzip.decompress(raw)
+                                       if name.endswith(".gz") else raw)
+    return decoded[WORD], decoded[PHASES]
+
+
+def pull_covector(covector, events, backward):
+    """Compute f M from elementary row operations by reverse adjoints.
+
+    The canonical backward prefix replaces each generator by its inverse
+    transpose, without reversing the chronological generator list.
+    """
+    result = list(covector)
+    for event in reversed(events):
+        kind = event[0]
+        if kind == "scale":
+            target, coefficient = event[1], Q(event[2], event[3])
+            require(coefficient != 0, "invertible canonical scale")
+            result[target] *= 1 / coefficient if backward else coefficient
+        else:
+            require(kind == "add", "supported canonical operation")
+            target, source = event[1:3]
+            coefficient = Q(event[3], event[4])
+            require(target != source, "elementary off-diagonal addition")
+            if backward:
+                target, source, coefficient = source, target, -coefficient
+            result[source] += coefficient * result[target]
+    return result
+
+
+def query_rows(word):
+    prefix = word["precondition"] + word["compensation"] + word["A"]
+    dimension = 1 + max(max(e[1:3]) if e[0] == "add" else e[1]
+                        for e in prefix + word["cut"])
+    # Only 667 of the 704 local registers are addressed by this prefix.  The
+    # remaining zero covector entries do not affect either source restriction.
+    require(224 <= dimension <= 704 and len(word["centers"]) == 8,
+            "canonical prefix register and query dimensions")
+    old, later = [], []
+    for centre in word["centers"]:
+        row = [Q(0)] * dimension
+        row[centre] = Q(1)
+        old.append(pull_covector(row, prefix, False)[:112])
+
+        row = [Q(0)] * dimension
+        for event in word["cut"]:
+            require(event[0] == "add", "canonical cut addition")
+            if event[2] == centre:
+                row[event[1]] += Q(event[3], event[4])
+        row = pull_covector(row, prefix, True)
+        # The inherited first-call constant-source endpoint identifies initial
+        # D_p and T_p differences.  This is an explicit source-model premise.
+        later.append([row[p] + row[112 + p] for p in range(112)])
+    return old, later
+
+
+def pivot_columns(rows):
+    work = [list(row) for row in rows]
+    pivots = []
+    for column in range(len(work[0])):
+        next_row = next((i for i in range(len(pivots), len(work))
+                         if work[i][column]), None)
+        if next_row is None:
+            continue
+        row = len(pivots)
+        work[row], work[next_row] = work[next_row], work[row]
+        scale = work[row][column]
+        work[row] = [v / scale for v in work[row]]
+        for i in range(row + 1, len(work)):
+            scale = work[i][column]
+            work[i] = [a - scale * b for a, b in zip(work[i], work[row])]
+        pivots.append(column)
+        if len(pivots) == len(work):
+            break
+    return pivots
+
+
+def pair_certificates(rows):
+    columns = list(zip(*rows))
+    require(all(any(column) for column in columns), "all columns nonzero")
+    certificates = []
+    for p, q in combinations(range(len(columns)), 2):
+        witness = next(((i, j, columns[p][i] * columns[q][j]
+                         - columns[q][i] * columns[p][j])
+                        for i, j in combinations(range(len(rows)), 2)
+                        if columns[p][i] * columns[q][j]
+                        != columns[q][i] * columns[p][j]), None)
+        require(witness is not None, "column pair is independent")
+        i, j, determinant = witness
+        certificates.append([p, q, i, j, str(determinant)])
+    return certificates
+
+
+def dot2(left, right):
+    return (left & right).bit_count() % 2
+
+
+def chart_action(record, vector):
+    """Swap b_j with e_(9+j), fixing q and all remaining coordinates."""
+    q = record["q"]
+    basis = record["idle_children"][0]["orthogonal_axes"][:8]
+    u, v = vector & 511, (vector >> 9) & 255
+    result = q if dot2(q, u) else 0
+    for j, axis in enumerate(basis):
+        if (v >> j) & 1:
+            result ^= axis
+        if dot2(axis, u):
+            result ^= 1 << (9 + j)
+    return result ^ (vector & ~((1 << 17) - 1))
+
+
+def route_certificates(word, phases):
+    records = phases["recipes"]
+    require(len(records) == 112 and phases["m"] == 73,
+            "selected port count and cover dimension")
+    require([r["q"] for r in records] == word["ports"],
+            "canonical route/column ordering")
+    routes = []
+    for record in records:
+        basis = record["idle_children"][0]["orthogonal_axes"][:8]
+        chart = [record["q"]] + basis
+        require(len(chart) == 9 and all(0 < x < 512 for x in chart),
+                "local nine-dimensional chart")
+        require(all(dot2(a, b) == int(i == j)
+                    for i, a in enumerate(chart) for j, b in enumerate(chart)),
+                "orthonormal chart")
+        columns = tuple(chart_action(record, 1 << k) for k in range(73))
+        require(all(chart_action(record, column) == 1 << k
+                    for k, column in enumerate(columns)), "involutory route")
+        require(all(dot2(a, b) == int(i == j)
+                    for i, a in enumerate(columns)
+                    for j, b in enumerate(columns)), "orthogonal route")
+        require(all(columns[k] == 1 << k for k in range(17, 73)),
+                "all spectator columns fixed")
+        routes.append(columns)
+    require(len(set(routes)) == 112, "all routes distinct")
+
+    products = Counter()
+    pair_witness = {}
+    for p, record in enumerate(records):
+        for q, columns in enumerate(routes):
+            if p == q:
+                continue
+            product = tuple(chart_action(record, column) for column in columns)
+            products[product] += 1
+            pair_witness.setdefault(product, []).append([p, q])
+    require(sum(products.values()) == 112 * 111, "all ordered pairs covered")
+    require(max(products.values()) == 1, "relative-route multiplicity M=1")
+    # The sorted representation binds every port pair and all 73 columns.
+    certificate = sorted((pairs[0], list(product))
+                         for product, pairs in pair_witness.items())
+    return routes, products, certificate
+
+
+def rejected(operation):
+    try:
+        operation()
+    except ValueError:
+        return True
+    return False
+
+
+def main():
+    word, phases = sources()
+    old, later = query_rows(word)
+    predecessor_path = ROOT / "research/centre-owner-observation-floor/RESULT.json"
+    predecessor = json.loads(predecessor_path.read_bytes())
+    require([[str(x) for x in row] for row in old] == predecessor["R"],
+            "reverse-adjoint old rows equal source receipt")
+    require([[str(x) for x in row] for row in later] == predecessor["H"],
+            "reverse-adjoint later rows equal source receipt")
+    require(all(4 * b == a for r, s in zip(old, later) for a, b in zip(r, s)),
+            "H=R/4 on the declared source slice")
+    pivots = pivot_columns(old)
+    require(len(pivots) == 8, "exact rational rank eight")
+    pairs = pair_certificates(old)
+    routes, products, product_certificate = route_certificates(word, phases)
+
+    parallel = [list(row) for row in old]
+    for row in parallel:
+        row[1] = row[0]
+    require(rejected(lambda: pair_certificates(parallel)),
+            "parallel-column negative control")
+    malformed = dict(phases["recipes"][0])
+    malformed["q"] ^= 1
+    malformed_phases = dict(phases)
+    malformed_phases["recipes"] = [malformed] + phases["recipes"][1:]
+    require(rejected(lambda: route_certificates(word, malformed_phases)),
+            "changed-route source/order negative control")
+    duplicate_phases = dict(phases)
+    duplicate_phases["recipes"] = [phases["recipes"][0]] * 112
+    require(rejected(lambda: route_certificates(word, duplicate_phases)),
+            "collapsed-route negative control")
+
+    receipt = {
+        "status": "PASS_INDEPENDENT_BOUNDED_BLOCK_REPAIR",
+        "proof_level": "finite exact premises plus written all-block implication",
+        "archive_sha256": ARCHIVE_SHA256,
+        "member_sha256": MEMBER_SHA256,
+        "predecessor_result_sha256": hashlib.sha256(predecessor_path.read_bytes()).hexdigest(),
+        "row_reconstruction": "canonical reverse adjoints; constant endpoint is inherited",
+        "old_rank": 8,
+        "source_dimension_per_owner": 112,
+        "later_scale": "1/4",
+        "pivot_columns": pivots,
+        "column_pair_minor_count": len(pairs),
+        "column_pair_minor_sha256": digest(pairs),
+        "relative_route_ordered_pair_count": sum(products.values()),
+        "relative_route_distinct_product_count": len(products),
+        "relative_route_multiplicity_histogram": dict(Counter(products.values())),
+        "relative_route_certificate_sha256": digest(product_certificate),
+        "route_matrix_sha256": digest([list(route) for route in routes]),
+        "maximum_relative_route_multiplicity": 1,
+        "nonzero_joint_kernel_owner_count_lower_bound": 7,
+        "every_block_size_covered": [1, 2, 3, 4, 5, 6],
+        "sharp_extra_linear_coordinates_for_covered_block": "104*block_size",
+        "controls_rejected": ["parallel_columns", "changed_route", "collapsed_routes"],
+        "no_existence_claim_at_seven": True,
+        "no_recursive_cost_or_kappa_claim": True,
+        "native_and_formal_kernel_replay": False,
+    }
+    print(json.dumps(receipt, sort_keys=True, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/centre-block-repair-information/test_verify.py b/research/centre-block-repair-information/test_verify.py
new file mode 100644
index 0000000000..cb5fb8fd33
--- /dev/null
+++ b/research/centre-block-repair-information/test_verify.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Behavioral integrity controls for the exact information certificate."""
+import json
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import types
+import unittest
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+primary = types.ModuleType('primary_under_test')
+primary.__file__ = str(HERE / 'verify.py')
+exec(compile((HERE / 'verify.py').read_bytes(), primary.__file__, 'exec'), primary.__dict__)
+
+
+class IntegrityControls(unittest.TestCase):
+    def run_cli(self, *args):
+        return subprocess.run([sys.executable, '-I', '-O', '-B', str(HERE / 'verify.py'), *args],
+                              text=True, capture_output=True, timeout=120, cwd=ROOT)
+
+    def test_changed_executable_input_is_rejected_before_execution(self):
+        manifest = json.loads((HERE / 'SOURCES.json').read_text())
+        with tempfile.TemporaryDirectory(prefix='centre-block-source-') as tmp:
+            root = Path(tmp)
+            for row in manifest['files']:
+                if row['usage'] == 'input':
+                    dst = root / row['path']
+                    dst.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copyfile(ROOT / row['path'], dst)
+            changed = root / primary.PREDECESSOR
+            changed.write_bytes(b"raise RuntimeError('changed bytes executed')\n" + changed.read_bytes())
+            with self.assertRaisesRegex(ValueError, '^source pin: ' + primary.PREDECESSOR + '$'):
+                primary.load(root)
+
+    def test_receipt_cannot_extend_coverage_to_seven(self):
+        with tempfile.TemporaryDirectory(prefix='centre-block-receipt-') as tmp:
+            path = Path(tmp) / 'overclaimed.json'
+            receipt = json.loads((HERE / 'RESULT.json').read_text())
+            receipt['all_blocks_proved']['maximum_size'] = 7
+            path.write_text(json.dumps(receipt))
+            completed = self.run_cli('--receipt', str(path))
+            self.assertNotEqual(completed.returncode, 0)
+            self.assertIn('receipt mismatch', completed.stderr)
+
+    def test_write_does_not_replace_occupied_output(self):
+        with tempfile.TemporaryDirectory(prefix='centre-block-output-') as tmp:
+            path = Path(tmp) / 'retained.json'
+            original = b'preserve earlier evidence\n'
+            path.write_bytes(original)
+            completed = self.run_cli('--write', str(path))
+            self.assertNotEqual(completed.returncode, 0)
+            self.assertIn('FileExistsError', completed.stderr)
+            self.assertEqual(path.read_bytes(), original)
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=1)
diff --git a/research/centre-block-repair-information/verify.py b/research/centre-block-repair-information/verify.py
new file mode 100644
index 0000000000..6b9131b7bf
--- /dev/null
+++ b/research/centre-block-repair-information/verify.py
@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Exact premises for small-block selected-centre information repair.
+
+Ross Richardson, with substantial OpenAI Codex assistance. The predecessor
+forward interpreter is explicitly reused; independent.py uses reverse adjoints.
+"""
+import argparse
+from collections import Counter, defaultdict
+from fractions import Fraction as Q
+import gzip
+import hashlib
+import io
+import json
+from pathlib import Path
+import tarfile
+import types
+
+HERE = Path(__file__).resolve().parent
+ARCHIVE = 'research/community-frontier1094-audit/selected-replay.tar.gz'
+PREDECESSOR = 'research/centre-owner-observation-floor/verify.py'
+
+
+def need(ok, why):
+    if not ok:
+        raise ValueError(why)
+
+
+def canonical(value):
+    return (json.dumps(value, sort_keys=True, indent=2) + '\n').encode()
+
+
+def digest(value):
+    return hashlib.sha256(canonical(value)).hexdigest()
+
+
+def load(root):
+    manifest = json.loads((HERE / 'SOURCES.json').read_text())
+    inputs = {}
+    for row in manifest['files']:
+        if row['usage'] == 'input':
+            raw = (root / row['path']).read_bytes()
+            actual = hashlib.sha256(raw).hexdigest()
+            need(actual == row['sha256'], 'source pin: ' + row['path'])
+            inputs[row['path']] = raw
+    # Execute the authenticated source bytes, never a timestamp-selected .pyc.
+    source = types.ModuleType('retained_owner_source')
+    source.__file__ = str(root / PREDECESSOR)
+    exec(compile(inputs[PREDECESSOR], source.__file__, 'exec'), source.__dict__)
+    data = {}
+    with tarfile.open(fileobj=io.BytesIO(inputs[ARCHIVE])) as archive:
+        for key, (name, expected) in source.MEMBERS.items():
+            members = [m for m in archive.getmembers() if m.name == name]
+            need(len(members) == 1 and members[0].isfile(), 'unique regular source member')
+            raw = archive.extractfile(members[0]).read()
+            need(hashlib.sha256(raw).hexdigest() == expected, 'archive member pin')
+            data[key] = json.loads(gzip.decompress(raw) if name.endswith('.gz') else raw)
+    data['prior_receipt'] = json.loads(inputs['research/centre-owner-observation-floor/RESULT.json'])
+    return source, data
+
+
+def column_pair_minors(columns):
+    """One nonzero 2x2 minor per unordered pair, over Q (therefore also C)."""
+    minors = []
+    for p, a in enumerate(columns):
+        need(any(a), 'zero column')
+        for q in range(p):
+            b = columns[q]
+            witness = next(((i, j, a[i]*b[j]-a[j]*b[i])
+                            for i in range(len(a)) for j in range(i)
+                            if a[i]*b[j] != a[j]*b[i]), None)
+            need(witness is not None, 'parallel columns')
+            i, j, det = witness
+            minors.append([q, p, i, j, str(det)])
+    return minors
+
+
+def route_products(source, routes):
+    n = len(routes[0])
+    identity = tuple(1 << k for k in range(n))
+    need(len(set(routes)) == len(routes), 'duplicate route')
+    table = defaultdict(list)
+    for p, left in enumerate(routes):
+        need(tuple(source.act(left, c) for c in left) == identity, 'route not involutory')
+        for q, right in enumerate(routes):
+            if p != q:
+                product = tuple(source.act(left, c) for c in right)
+                need(product != identity, 'nontrivial relative route is identity')
+                table[product].append([p, q])
+    return table
+
+
+def dependent_triple(columns):
+    """A T-kernel with three source owners need not be in the old kernel."""
+    for p, a in enumerate(columns):
+        for q in range(p):
+            b = columns[q]
+            i, j = next((i, j) for i in range(8) for j in range(i)
+                        if a[i]*b[j] != a[j]*b[i])
+            det = a[i]*b[j]-a[j]*b[i]
+            for r in range(q):
+                c = columns[r]
+                u = (c[i]*b[j]-c[j]*b[i])/det
+                v = (a[i]*c[j]-a[j]*c[i])/det
+                if u and v and all(u*x+v*y == z for x, y, z in zip(a, b, c)):
+                    return {'ports': [p, q, r], 'coefficients': [str(u), str(v), '-1']}
+    raise ValueError('expected dependent triple not found')
+
+
+def build(root):
+    source, data = load(root)
+    forward, end = source.replay(data['programs']['forward'])
+    backward, bend = source.replay(data['programs']['backward'])
+    # Bind to the complete formal scalar endpoint, including arbitrary ordinary dirt.
+    for i in range(704):
+        f = {i: Q(1)}
+        if 112 <= i < 224:
+            f[i-112] = Q(1)
+        b = {i: Q(1)}
+        if i < 112:
+            b[i+112] = Q(-1)
+        need(end['L', i] == f and bend['L', i] == b, 'complete scalar endpoint')
+    R = [{p: q for p, q in row.items() if p < 112} for row in forward]
+    H = []
+    for row in backward:
+        out = {}
+        for i, q in row.items():
+            source.add(out, {p: v for p, v in end['L', i].items() if p < 112}, q)
+        H.append(out)
+    need(H == [{p: q/4 for p, q in row.items()} for row in R], 'H=R/4')
+    need(len(source.echelon(R)) == 8, 'old rank is eight')
+    calls = sorted(data['template']['calls'], key=lambda c: c['time'])
+    need([(calls[t]['time'], calls[t]['stage'], calls[t]['replica'], calls[t]['orientation'])
+          for t in (0, 4)] == [(0, 0, 0, 'forward'), (4, 1, 0, 'backward')],
+         'selected chronological pair')
+    for c in calls[:5]:
+        raw = json.dumps(data['programs'][c['orientation']], sort_keys=True, separators=(',', ':')).encode()
+        need(c['local_program_sha256'] == hashlib.sha256(raw).hexdigest(), 'call program binding')
+        need(len(c['owners']) == len({o[0] for o in c['owners']}) == 704, 'injective ordinary owners')
+    for t, stage in ((0, 0), (4, 1)):
+        need(calls[t]['owners'][:224] == [[p, [1, stage, p % 112]] for p in range(224)],
+             'source owner boundary')
+    need(all(not set(range(224)) & {o[0] for o in c['owners']} for c in calls[1:4]),
+         'intervening source-data contact')
+    need([e['kind'] for e in data['template']['execution_schedule'][:5]] == ['local_cover_sweep']*5,
+         'intervening schedule event')
+    dense = [[str(row.get(p, 0)) for p in range(112)] for row in R]
+    prior = data['prior_receipt']
+    need(dense == prior['R'], 'retained R coefficient comparison')
+    need([[str(row.get(p, 0)) for p in range(112)] for row in H] == prior['H'], 'retained H coefficient comparison')
+    columns = [tuple(row.get(p, Q(0)) for row in R) for p in range(112)]
+    minors = column_pair_minors(columns)
+    routes = [source.route(record) for record in data['phases']['recipes']]
+    need(len(routes) == 112, 'route count')
+    need([r['q'] for r in data['phases']['recipes']] == data['word']['ports'], 'route port order')
+    table = route_products(source, routes)
+    histogram = Counter(map(len, table.values()))
+    need(histogram == {1: 12432}, 'ordered relative route multiplicities')
+    pivots = sorted(source.echelon(R))
+    complement = [p for p in range(112) if p not in pivots]
+    need(len(complement) == 104, 'sharp repair dimension')
+    need(len(source.echelon(R + [{p: Q(1)} for p in complement])) == 112, 'repair attainment')
+    need(len(source.echelon(R + [{p: Q(1)} for p in complement[:-1]])) == 111, '103-read defect control')
+
+    # Mathematical controls exercise load-bearing hypotheses.
+    mutant = list(columns)
+    mutant[1] = mutant[0]
+    try:
+        column_pair_minors(mutant)
+    except ValueError as e:
+        need(str(e) == 'parallel columns', 'wrong parallel-column rejection')
+    else:
+        raise ValueError('parallel columns accepted')
+    try:
+        route_products(source, [routes[0], routes[0]])
+    except ValueError as e:
+        need(str(e) == 'duplicate route', 'wrong duplicate-route rejection')
+    else:
+        raise ValueError('duplicate route accepted')
+    # If every route collapses to I, T is ownerwise R/4: no repair is needed.
+    need(len(source.echelon(R + H)) == 8, 'collapsed-route zero-repair control')
+    # On C2 with two parallel columns R=(1,1), x=(1,-1) at both owners
+    # lies in both S and T kernels for routes identity and swap.
+    xs = ((Q(1), Q(-1)), (Q(1), Q(-1)))
+    need(all(sum(x) == 0 for x in xs), 'parallel-column local-kernel control')
+    need(all(xs[g][0] + xs[1-g][1] == 0 for g in range(2)), 'parallel-column routed-kernel control')
+    triple = dependent_triple(columns)
+    ps, coeffs = triple['ports'], list(map(Q, triple['coefficients']))
+    need(all(sum(c*columns[p][i] for p, c in zip(ps, coeffs)) == 0 for i in range(8)), 'triple T-kernel')
+    need(all(c and any(columns[p]) for p, c in zip(ps, coeffs)), 'triple is not in S-kernel')
+    controls = ['parallel_column_rejected', 'duplicate_route_rejected',
+                'collapsed_routes_need_no_repair', 'parallel_column_C2_two_owner_counterexample',
+                'three_owner_T_kernel_fails_old_kernel', '103_coordinate_repair_loses_dimension']
+    return {
+        'status': 'PASS_CENTRE_BLOCK_REPAIR_INFORMATION',
+        'source_base': 'd8e0f83f00191df62174b641e9fff055c357f641',
+        'model': 'PR1094 calls0/4; independent scalar source values by regular cover owner; equal ordinary dirt',
+        'old_rank': 8, 'ports': 112, 'nonparallel_column_pairs': len(minors),
+        'column_pair_minor_sha256': digest(minors), 'R_sha256': digest(dense),
+        'route_count': 112, 'route_dimension': 73, 'ordered_nonidentity_route_products': 12432,
+        'distinct_nonidentity_route_products': len(table),
+        'relative_route_multiplicity_histogram': {str(k): v for k, v in sorted(histogram.items())},
+        'ordered_route_product_sha256': digest([[p, q, list(product)] for product, pairs in table.items() for p, q in pairs]),
+        'source_minimum_active_ports_lower_bound': 3, 'output_minimum_active_owners_lower_bound': 3,
+        'kernel_nonzero_owner_support_lower_bound': 7,
+        'all_blocks_proved': {'minimum_size': 1, 'maximum_size': 6,
+                              'extra_scalar_linear_observations_exact': '104*block_size'},
+        'repair_pivot_columns': pivots, 'repair_coordinate_reads': complement,
+        'T_kernel_without_old_kernel_control': triple, 'controls': controls,
+        'scope': 'finite exhaustive premises plus written all-block theorem; no kernel proof, native tariff, supplier admission or new kappa',
+    }
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--source-root', type=Path, default=HERE.parents[1])
+    p.add_argument('--write', type=Path)
+    p.add_argument('--receipt', type=Path, default=HERE / 'RESULT.json')
+    args = p.parse_args()
+    result = build(args.source_root.resolve())
+    if args.write:
+        with args.write.open('xb') as stream:
+            stream.write(canonical(result))
+    else:
+        need(canonical(result) == canonical(json.loads(args.receipt.read_text())), 'receipt mismatch')
+    print('PASS_CENTRE_BLOCK_REPAIR_INFORMATION blocks=1..6 repair=104*b products=12432 controls=6 no_new_kappa')
+
+
+if __name__ == '__main__':
+    main()