diff --git a/research/centre-fanout-two-panel-seed962302/CLAIM.md b/research/centre-fanout-two-panel-seed962302/CLAIM.md
new file mode 100644
index 0000000000..1c271fb87d
--- /dev/null
+++ b/research/centre-fanout-two-panel-seed962302/CLAIM.md
@@ -0,0 +1,32 @@
+Correction to the first posted draft: I initially referenced the 492-helper ancestor under `gauge44-slots-t16/evidence/local/`; that is not the selected program, and it is excluded from this experiment. The selected 480-helper replay is `research/community-frontier1094-audit/selected-replay.tar.gz`, SHA256 `f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6`. Its `candidate/strict/global/base/providers/gauge44/LOCAL-PROGRAMS.json.gz` has eight rank-8 centre events on roles `415..422`, sourced respectively from `L[92], L[57], L[81], L[224], L[11], L[240], L[9], L[256]`; each is followed by exactly 22 target updates. I corrected the task pins and scope before running any experiment.
+
+CLAIM — recursive interfaces; OS seed `96230294e168f4b58c665c3efdec8d3b`; task `centre-path-sharing`; priority revision 3; base `0b1cccf86e2f5132ed286a26ef0a681a495740ea`.
+
+**Question.** In the pinned selected #1094 forward local program, can the eight rank-8 centre trajectories be evaluated once for two invocations that share the same eight source-row values, then scattered into two disjoint target panels with arbitrary dirty target and private-centre state?
+
+**Refined boundary.** The two calls share the exact source rows and centre maps; their target panels and private helper state are disjoint. This changes the independent-input per-call premise and does not claim that arbitrary independent calls can share. The nearby #1516 discussion completed a single-call dirty-hosting and waiting-level obstruction and records that cross-call sharing was not attempted. PRs #1643, #1664 and #1684 concern tree geometry/cut-rank application, not a two-panel fanout construction. PR #1652 treats a single-column COPY floor.
+
+**Method and bounded domain.** Use only the eight selected centre events and their 22 target updates each. Compare two separate centre phases with a fused phase that copies/transports each common centre once and applies every target update in both panels. Reconstruct the selected event order and coefficient lists from the pinned replay, test all source/target/centre basis dirt with exact arithmetic, and include controls for a changed second source, a missing target update, and a non-restored centre. Price every copy, clear, rank-8 move, target update, workspace coordinate and source/interface assumption. Screen the resulting profile at `m=73`, 896 families, nine stages against the unchanged bit threshold `a=0.001733427039589844234749`.
+
+**Optimistic budget.** The ideal half-centre model changes the per-call profile from `{1:2412,2:418,3:432,4:142,5:82,8:8}` and centre charge 64 to `{1:2412,2:418,3:432,4:142,5:82,8:4}` and centre charge 32. Its complex cap is `a≈0.003213`; the bit side then limits whole-bound `κ` to `0.0017304274698236029`, at most 3.4536% above the selected record. Added operations and assembly access costs must be charged before crediting this improvement.
+
+**Live overlap checked 2026-10-14 07:13–07:15 UTC.** Discussion pagination completed for 337 records. The overlap helper could not refresh PRs because this host's `gh api` rejects its `--slurp` flag, so I separately enumerated all 385 open PRs and read the closest bodies/heads: #1684 (`1e1af1a8f97f6eee21946cd1ff832e3d61269d33`) applies a single-call cut-rank bound; #1643 (`362086ed05870c793b4698f8843fba6720fa30cb`) checks the selected single-call tree bound; #1652 (`9f9295b1eb82056f31f4f1ac2b30ede0d7f8ca07`) proves a one-column COPY floor and lists shared billing as outside scope. The #1516 thread itself says it made no cross-call sharing attempt. None studies a shared source signal fanning out to two disjoint target panels.
+
+**Expected evidence.** A source-pinned exact two-panel phase replay with positive and semantic negative controls, full phase invoice, and a clear statement that this is a local interface mechanism with no new `κ` unless it composes through the selected supplier. No word search, owner optimization or full cold replay is in this cycle.
+
+**Expiry:** 2026-10-14T09:12:00Z.
+
+## Finding and handoff
+
+**Completed bounded construction:** under the stated shared-source and disjoint-target contract, evaluate each of the eight selected rank-8 centre maps once and scatter its signal to both panels. The exact source event stream has all eight prescribed source rows and 22 target updates per centre. The exact rational verifier checks the equality against two separate invocations on every coordinate basis vector for the eight source rows, 352 target coordinates and 1,241 private-centre coordinates, plus a dense fixture; three negative controls reject a changed source, an omitted target update and a missing clear.
+
+The complete two-call centre-phase invoice falls from 416 to 384 scalar actions: rank-8 moves 16→8, profile entries for rank 8 per call 8→4, source copies 16→8, and centre clears 32→16; all 352 panel target updates remain. The 9-stage profile gives `a_cap≈0.003212972894`; with the bit side unchanged at `a=0.001733427039589844234749`, the whole-bound ceiling is `κ≤0.0017304274698236029`, at most 3.4536% over the selected κ. These are a local mechanism and favorable screening cap, not a new accepted κ.
+
+Replay on exact base `0b1cccf86e2f5132ed286a26ef0a681a495740ea`:
+
+```text
+PASS_CENTRE_TWO_PANEL_FANOUT R=480 centres=8 targets_per_centre=22 updates_per_panel=176 basis_cases=1601 controls=3 actions=416->384 rank8=16->8 profile8=8->4 a_cap=0.003212972894 bit_a=0.001733427040 whole_kappa_cap=0.001730427469824 max_gain_pct=3.4536
+PASS_REGISTERED_RESEARCH_PACKAGE research/centre-fanout-two-panel-seed962302 outcome=completed
+```
+
+Final overlap refresh: 351 discussion records paginated at 2026-10-14T07:28:35Z; open PR census returned 394 entries. PR #1704 is a separate bit-scatter pair-sum construction; PR #1703 is a one-touch rank-2 retiming obstruction on the same selected source archive. Neither considers this common-centre, disjoint-target fanout. The overlap helper's PR fetch remains unavailable because this installed `gh api` rejects `--slurp`; the full open-PR list was therefore independently enumerated and the closest PR heads and bodies inspected. The package is submitted as [PR #1708](https://github.com/CrocSwap/integer-mult-bounds/pull/1708) from branch `research/centre-fanout-two-panel-seed962302`; remaining assembly obligations are whether the selected supplier has eligible invocation pairs and how to charge any source preparation, owner, precision or hosting cost.
diff --git a/research/centre-fanout-two-panel-seed962302/README.md b/research/centre-fanout-two-panel-seed962302/README.md
new file mode 100644
index 0000000000..363154e49a
--- /dev/null
+++ b/research/centre-fanout-two-panel-seed962302/README.md
@@ -0,0 +1,78 @@
+# centre-fanout-two-panel-seed962302
+
+**Bounded recursive-interface construction attempt; no new κ claimed.**
+
+## Scope and evidence
+
+Original assignment: recursive-interfaces, OS seed `96230294e168f4b58c665c3efdec8d3b`,
+`centre-path-sharing`, priority revision 3, base `0b1cccf86e2f5132ed286a26ef0a681a495740ea`.
+The first selector draw returned the excluded `independent-verification` track and was discarded.
+The scope refines the card to two invocations that share the same eight source-row values
+and have disjoint target panels. It tests whether the selected centre trajectory can serve both
+panels once while each panel retains its full target updates and all private state is restored.
+The nearby #1516 work treats single-call dirty hosting; this package explores cross-call fanout
+under an explicit shared-source condition.
+
+The current selected record is `κ=836330098538459/500000000000000000` and has SHA256
+`10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. Its review is
+`docs/research/community-batch1099-review.md`; source manifest is
+`research/community-frontier1094-audit/SELECTED-SOURCE.json`; certificate is
+`research/community-frontier1094-audit/ASSEMBLY.json` with SHA256
+`1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045`; reproduction is
+`make frontier1094-verify`. The selected 480-helper emitted replay is pinned at
+`research/community-frontier1094-audit/selected-replay.tar.gz`, SHA256
+`f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6`.
+
+The exact 9-stage, 112-port planning profile changes from eight to four rank-8 children and
+from centre charge 64 to 32 per call when two calls share one trajectory. The repository's
+favorable relaxation gives `a_cap≈0.003213` and `κ_cap≈0.003203`; the unchanged bit side then
+binds at `a=0.001733427039589844234749`, limiting any whole-bound gain to 3.4536%. This is
+the binding cap for the whole supplier while the bit side stays fixed. The verifier charges
+every local centre copy, clear, rank-8 move and both panels' target updates; it confirms that
+the fused phase performs fewer setup/restoration operations and retains all target operations.
+The unchanged non-centre paid profile is left untouched in the moment screen.
+
+Exact source pins are in [SOURCES.json](SOURCES.json). The selected certificate, review and
+record are provenance; all files listed as verifier inputs are live pinned dependencies.
+
+## Reproduce
+
+From the repository root:
+
+```sh
+python3 -I -B research/centre-fanout-two-panel-seed962302/verify.py
+python3 scripts/research_package.py --package research/centre-fanout-two-panel-seed962302 --check-only
+python3.12 scripts/research_package.py --package research/centre-fanout-two-panel-seed962302
+```
+
+The first command checks the selected source events and exact target coefficients, then compares
+separate and fused schedules on all source, target-dirt and private-centre basis states over `Q`.
+The selected rank-8 centre child is treated as a common linear map; the test uses a nontrivial
+exact rational representative, and the algebraic identity holds for every common map, including
+the inherited selected child. It checks three semantic failures, the complete local phase invoice
+and the paid moment against the unchanged bit threshold. The registered command repeats the
+same bounded replay through the repository hook.
+
+## Scope and limits
+
+The interface requires both invocations to see identical values in the eight selected source
+rows while their target panels are disjoint. The finite construction establishes a local phase
+rewrite under that condition. It does not show that the global supplier call schedule contains
+such a pair, nor pay a new owner/precision/controller transformation needed to create one. The
+unchanged bit supplier becomes binding in the optimistic screen, so no new selected κ follows.
+
+## Open next questions
+
+Does the selected assembly contain invocation pairs that meet the shared-source boundary without
+extra owner, preparation, precision or hosting charges? The first step is to match the pinned
+owner/call schedule to the eight verified centre-source functionals; this package does not claim
+full supplier composition.
+
+## Credit
+
+Predecessor: Rohan Arun's selected PR #1094 and the retained gauge44-slots-t16 provider lineage.
+This package uses the selected 480-helper replay archive, not the 492-helper ancestor in stored
+evidence/local files. The local centre maps are inherited unchanged; the proposed contribution
+is only the two-panel shared-source interface. Prepared by Cinna Davis with substantial OpenAI
+Codex assistance in scope, cost calculation, verifier and exposition. No human or Lean
+verification is claimed. New material is Apache-2.0.
diff --git a/research/centre-fanout-two-panel-seed962302/SOURCES.json b/research/centre-fanout-two-panel-seed962302/SOURCES.json
new file mode 100644
index 0000000000..a6af974fb2
--- /dev/null
+++ b/research/centre-fanout-two-panel-seed962302/SOURCES.json
@@ -0,0 +1,54 @@
+{
+  "schema_version": 1,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "input",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1",
+      "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075"
+    },
+    {
+      "path": "docs/research/community-batch1099-review.md",
+      "usage": "input",
+      "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099",
+      "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb"
+    },
+    {
+      "path": "research/community-frontier1094-audit/ASSEMBLY.json",
+      "usage": "input",
+      "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0",
+      "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045"
+    },
+    {
+      "path": "research/community-frontier1094-audit/REPLAY.json",
+      "usage": "input",
+      "git_blob": "2cfb7fffa7cd78f418be16c13224c3206b6d0183",
+      "sha256": "ce0678fa7abaab221de74baeace0c6696d5ea23a36719a58cff230215a06aae7"
+    },
+    {
+      "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json",
+      "usage": "input",
+      "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8",
+      "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b"
+    },
+    {
+      "path": "research/community-frontier1094-audit/selected-replay.tar.gz",
+      "usage": "input",
+      "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f",
+      "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6"
+    },
+    {
+      "path": "research/complex-local-word-ceiling/ceiling.py",
+      "usage": "input",
+      "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c",
+      "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc"
+    }
+  ]
+}
diff --git a/research/centre-fanout-two-panel-seed962302/TASK.json b/research/centre-fanout-two-panel-seed962302/TASK.json
new file mode 100644
index 0000000000..e40d172806
--- /dev/null
+++ b/research/centre-fanout-two-panel-seed962302/TASK.json
@@ -0,0 +1,73 @@
+{
+  "schema_version": 1,
+  "task_id": "centre-path-sharing",
+  "seed": "96230294e168f4b58c665c3efdec8d3b",
+  "track": "recursive-interfaces",
+  "catalog_assessed_on": "2026-10-13",
+  "catalog_sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075",
+  "discarded_excluded_draws": [
+    {"seed": "adc78c377e5a4c69c722bf00d8fe756a", "track": "independent-verification"}
+  ],
+  "priority_revision": 3,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32",
+  "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": [
+      "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=...).",
+    "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."
+    ],
+    "overlap_terms": [
+      "centre path",
+      "copied totals",
+      "private temporary",
+      "shared centre",
+      "batching"
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "For two copies of the selected #1094 480-helper centre phase with the same eight source-row values and disjoint arbitrary dirty target panels, execute each rank-8 centre trajectory once and scatter its signal to both panels. Verify the exact source/target contract, full operation and workspace invoice, and the changed complex moment profile.",
+  "scope_change_reason": "The nearby #1516 discussion priced single-call dirty hosting and its reply records no cross-call sharing attempt. This scope reuses a common source-side centre signal across two target panels; it keeps the selected source/centre maps fixed, requires exact common source values, and charges both panels' scalar updates. It does not claim independent-input calls can share. The local draft briefly cited a 492-helper ancestor; the final pins and experiment use only the selected 480-helper replay archive.",
+  "bottleneck_link": "The selected complex supplier pays eight rank-8 centre children and a 64-per-call centre charge. The ideal two-call fanout halves both terms. At that ideal, the existing bit supplier becomes binding, so any useful gain must keep the fully charged complex saving above a=0.001733427039589844234749.",
+  "budget_minutes": 60,
+  "stop_rule": "First verify the exact selected centre source rows, eight rank-8 events and 22 target updates per event from selected-replay.tar.gz. Test one two-panel centre phase with arbitrary source, target and private-centre dirt, then account for every source read, scalar update, frame move, copy, clear, workspace coordinate and restoration. Stop if the exact source values cannot be shared without an unpriced preparation/interface step, if the fused map differs from two separate calls, or if its exact 9-stage 112-port moment does not exceed the binding bit threshold. Do not widen the source family or search unrelated frame schedules in this cycle.",
+  "outcome": "completed",
+  "evidence": "PASS_CENTRE_TWO_PANEL_FANOUT R=480 centres=8 targets_per_centre=22 updates_per_panel=176 basis_cases=1601 controls=3 actions=416->384 rank8=16->8 profile8=8->4 a_cap=0.003212972894 bit_a=0.001733427040 whole_kappa_cap=0.001730427469824 max_gain_pct=3.4536. The selected source row values must be identical across the two calls; the target panels are separate and all 352 target updates remain charged. The verifier uses an exact rational representative for each common rank-8 centre map; the fanout identity is proved algebraically for every identical map. This is a local phase construction, not a global call-schedule match or a new selected kappa.",
+  "author": "Cinna Davis with substantial OpenAI Codex assistance",
+  "ai_assistance": "OpenAI Codex substantially assisted scope selection, exact cost-model calculations, verifier implementation and exposition. No independent human review or formal proof-assistant verification is claimed.",
+  "open_questions": [
+    {
+      "question": "Does the complete selected supplier call schedule contain eligible pairs with the same eight source-carrier values and disjoint target panels?",
+      "why_it_matters": "The local fanout only changes the exponent if the shared-source boundary occurs in the retained assembly without extra preparation, routing or lifetime costs that erase the gain.",
+      "first_step": "Inspect the pinned owner/call schedule and match its eight centre-source functionals against the verified two-panel interface.",
+      "blocked_by": "The current package tests one exact centre-phase boundary and does not yet compose its source-sharing condition with the global controller, precision or outer moment certificate."
+    }
+  ]
+}
diff --git a/research/centre-fanout-two-panel-seed962302/VERIFY.json b/research/centre-fanout-two-panel-seed962302/VERIFY.json
new file mode 100644
index 0000000000..b3a76371c9
--- /dev/null
+++ b/research/centre-fanout-two-panel-seed962302/VERIFY.json
@@ -0,0 +1,26 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "certificates/selected-result.json",
+    "docs/research/community-batch1099-review.md",
+    "research/community-frontier1094-audit/ASSEMBLY.json",
+    "research/community-frontier1094-audit/REPLAY.json",
+    "research/community-frontier1094-audit/SELECTED-SOURCE.json",
+    "research/community-frontier1094-audit/selected-replay.tar.gz",
+    "research/complex-local-word-ceiling/ceiling.py"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Pins the selected record/certificate/archive; extracts the actual 480-helper eight-centre event blocks and all 22 exact target coefficients per centre; compares two separate calls with one fused call over every source, target-dirt and private-centre basis coordinate plus a dense rational fixture; the centre map is an exact rational representative and the proof identity holds for every common map; rejects changed-source, missing-target and missing-clear controls; recounts all phase operations and checks the 9-stage moment against the selected bit threshold."
+    }
+  ]
+}
diff --git a/research/centre-fanout-two-panel-seed962302/verify.py b/research/centre-fanout-two-panel-seed962302/verify.py
new file mode 100644
index 0000000000..160e525dbc
--- /dev/null
+++ b/research/centre-fanout-two-panel-seed962302/verify.py
@@ -0,0 +1,371 @@
+#!/usr/bin/env python3
+"""Exact two-panel fanout for the selected 480-helper centre phase.
+
+This replays the pinned event contract and tests its linear identity over Q.
+The centre child itself is represented by an arbitrary exact rank-8 linear map;
+the equality proof depends only on invoking the same map once on the same source.
+"""
+from __future__ import annotations
+
+import gzip
+import hashlib
+import importlib.util
+import io
+import json
+import tarfile
+from collections import Counter
+from fractions import Fraction as Q
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+PKG = Path(__file__).resolve().parent
+ARCHIVE = ROOT / "research/community-frontier1094-audit/selected-replay.tar.gz"
+ARCHIVE_SHA256 = "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6"
+RECORD_SHA256 = "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+ASSEMBLY_SHA256 = "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045"
+PROVIDER = "candidate/strict/global/base/providers/gauge44/"
+DIM = 8
+EXPECTED_SOURCES = [92, 57, 81, 224, 11, 240, 9, 256]
+EXPECTED_PROFILE = {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8}
+
+
+def need(condition: bool, message: str) -> None:
+    if not condition:
+        raise AssertionError(message)
+
+
+def sha256(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def load_json_tar(tar: tarfile.TarFile, path: str):
+    member = tar.extractfile(path)
+    need(member is not None, f"missing archive member {path}")
+    raw = member.read()
+    if path.endswith(".gz"):
+        raw = gzip.decompress(raw)
+    return json.loads(raw)
+
+
+def scalar_clear(op, register: list) -> bool:
+    return bool(
+        op
+        and op[0] == "scalar"
+        and len(op) >= 2
+        and op[1][0] == "clear"
+        and op[1][1] == register
+    )
+
+
+def read_centres(program, word, local_checks):
+    ops = program["forward"]
+    centres = []
+    for index, event in enumerate(ops):
+        if not event or event[0] != "center":
+            continue
+        k, role, destination, rank = event[1:]
+        need(k == len(centres), "centre events are not in canonical order")
+        need(index >= 2, "centre event lacks its clear/copy prefix")
+        before_clear, before_copy = ops[index - 2 : index]
+        need(scalar_clear(before_clear, ["C", k]), f"centre {k}: missing dirty clear")
+        need(before_clear[2] == role, f"centre {k}: clear role differs")
+        need(
+            before_copy[0] == "scalar"
+            and before_copy[1][0] == "copy"
+            and before_copy[1][1] == ["C", k]
+            and before_copy[1][2][0] == "L",
+            f"centre {k}: missing carrier copy",
+        )
+        source = before_copy[1][2][1]
+        need(source == EXPECTED_SOURCES[k], f"centre {k}: source carrier changed")
+        need((role, destination, rank) == (415 + k, 0, 8), f"centre {k}: event changed")
+        need(word["center_frames"][k] == role, f"centre {k}: frame role changed")
+
+        updates = []
+        j = index + 1
+        while j < len(ops) and not scalar_clear(ops[j], ["C", k]):
+            current = ops[j]
+            need(
+                current[0] == "scalar"
+                and current[1][0] == "add"
+                and current[1][1][0] == "L"
+                and current[1][2] == ["C", k],
+                f"centre {k}: unexpected instruction in scatter block at {j}",
+            )
+            target = current[1][1][1]
+            coefficient = Q(current[1][3], current[1][4])
+            updates.append((target, coefficient))
+            j += 1
+        need(j < len(ops), f"centre {k}: missing final clear")
+        need(ops[j][2] == 0, f"centre {k}: final clear has a nonzero frame")
+        need(len(updates) == 22, f"centre {k}: expected 22 target updates")
+        need(len({target for target, _ in updates}) == 22, f"centre {k}: repeated target")
+        need(all(coefficient != 0 for _, coefficient in updates), f"centre {k}: zero scatter")
+        centres.append(
+            {"k": k, "role": role, "source": source, "updates": updates, "start": index - 2, "end": j}
+        )
+
+    need(len(centres) == 8, "selected word must have eight centre events")
+    need(word["R"] == 480, "archive is not the selected 480-helper word")
+    profile = {int(r): n for r, n in local_checks["forward"]["paid_profile"].items()}
+    need(profile == EXPECTED_PROFILE, "selected per-call paid profile changed")
+    need(sum(len(c["updates"]) for c in centres) == 176, "selected scatter edge count changed")
+    return centres, profile
+
+
+def matvec(matrix, vector):
+    return [sum((a * b for a, b in zip(row, vector)), Q(0)) for row in matrix]
+
+
+def transforms():
+    """Nontrivial exact invertible maps; the fanout identity is valid for every map."""
+    out = []
+    for k in range(8):
+        matrix = []
+        for i in range(DIM):
+            row = []
+            for j in range(DIM):
+                if i == j:
+                    row.append(Q(1))
+                elif i < j:
+                    row.append(Q(((k + 3 * i + 5 * j) % 7) - 3, 28))
+                else:
+                    row.append(Q(0))
+            matrix.append(row)
+        out.append(matrix)
+    return out
+
+
+def zero_vector():
+    return [Q(0) for _ in range(DIM)]
+
+
+def empty_targets(ids):
+    return {target: zero_vector() for target in ids}
+
+
+def add_scaled(target, source, coefficient):
+    return [x + coefficient * y for x, y in zip(target, source)]
+
+
+def run_separate(centres, matrices, source_a, source_b, targets_a, targets_b, dirt_a, dirt_b):
+    final_a, final_b = {}, {}
+    for panel, sources, targets, dirt, final in (
+        (0, source_a, targets_a, dirt_a, final_a),
+        (1, source_b, targets_b, dirt_b, final_b),
+    ):
+        for centre in centres:
+            k = centre["k"]
+            private = list(dirt[k])
+            private = zero_vector()  # selected pre-clear removes arbitrary dirty state
+            private = [x + y for x, y in zip(private, sources[centre["source"]])]
+            private = matvec(matrices[k], private)
+            for target, coefficient in centre["updates"]:
+                targets[target] = add_scaled(targets[target], private, coefficient)
+            private = zero_vector()  # selected post-clear restores private state
+            final[k] = private
+    return targets_a, targets_b, final_a, final_b
+
+
+def run_fused(
+    centres,
+    matrices,
+    source_a,
+    source_b,
+    targets_a,
+    targets_b,
+    dirt,
+    *,
+    skip_update=None,
+    restore=True,
+):
+    final = {}
+    for centre in centres:
+        k = centre["k"]
+        private = list(dirt[k])
+        private = zero_vector()  # one pre-clear for the shared private centre
+        private = [x + y for x, y in zip(private, source_a[centre["source"]])]
+        private = matvec(matrices[k], private)
+        for panel, targets in ((0, targets_a), (1, targets_b)):
+            for index, (target, coefficient) in enumerate(centre["updates"]):
+                if skip_update == (panel, k, index):
+                    continue
+                targets[target] = add_scaled(targets[target], private, coefficient)
+        final[k] = zero_vector() if restore else private
+    return targets_a, targets_b, final
+
+
+def test_basis(centres, matrices):
+    target_ids = sorted({target for c in centres for target, _ in c["updates"]})
+    source_ids = [c["source"] for c in centres]
+    need(not (set(target_ids) & set(source_ids)), "source and target roles overlap")
+    cases = 0
+    zero_sources = {source: zero_vector() for source in source_ids}
+    zero_dirt = {k: zero_vector() for k in range(8)}
+
+    def compare(sa, sb, ta, tb, da, db, ds):
+        nonlocal cases
+        original_a = {r: list(v) for r, v in sa.items()}
+        original_b = {r: list(v) for r, v in sb.items()}
+        sep = run_separate(
+            centres, matrices, sa, sb, {k: list(v) for k, v in ta.items()},
+            {k: list(v) for k, v in tb.items()}, da, db
+        )
+        fused = run_fused(
+            centres, matrices, sa, sb, {k: list(v) for k, v in ta.items()},
+            {k: list(v) for k, v in tb.items()}, ds
+        )
+        need(sep[0] == fused[0] and sep[1] == fused[1], "fused panel map differs from separate calls")
+        need(all(v == zero_vector() for v in sep[2].values()), "separate private centre not restored")
+        need(all(v == zero_vector() for v in sep[3].values()), "second private centre not restored")
+        need(all(v == zero_vector() for v in fused[2].values()), "shared private centre not restored")
+        need(sa == original_a and sb == original_b, "shared source row was modified")
+        cases += 1
+
+    # Basis for every source coordinate.
+    for source in source_ids:
+        for coordinate in range(DIM):
+            sa = {r: list(v) for r, v in zero_sources.items()}
+            sa[source][coordinate] = Q(1)
+            sb = {r: list(v) for r, v in sa.items()}
+            compare(sa, sb, empty_targets(target_ids), empty_targets(target_ids), zero_dirt, zero_dirt, zero_dirt)
+
+    # Basis for every arbitrary dirty coordinate in both target panels.
+    for panel in (0, 1):
+        for target in target_ids:
+            for coordinate in range(DIM):
+                ta, tb = empty_targets(target_ids), empty_targets(target_ids)
+                (ta if panel == 0 else tb)[target][coordinate] = Q(1)
+                compare(zero_sources, zero_sources, ta, tb, zero_dirt, zero_dirt, zero_dirt)
+
+    # Independent dirty values in each private centre of each separate call.
+    for k in range(8):
+        for coordinate in range(DIM):
+            da, db, ds = ({r: list(v) for r, v in zero_dirt.items()} for _ in range(3))
+            da[k][coordinate] = Q(1)
+            compare(zero_sources, zero_sources, empty_targets(target_ids), empty_targets(target_ids), da, zero_dirt, ds)
+            da, db, ds = ({r: list(v) for r, v in zero_dirt.items()} for _ in range(3))
+            db[k][coordinate] = Q(1)
+            ds[k][coordinate] = Q(3, 7)
+            compare(zero_sources, zero_sources, empty_targets(target_ids), empty_targets(target_ids), zero_dirt, db, ds)
+
+    # A dense rational fixture checks simultaneous arbitrary dirt and all panels.
+    sa = {r: [Q((r + 2 * i) % 9 - 4, 7) for i in range(DIM)] for r in source_ids}
+    sb = {r: list(v) for r, v in sa.items()}
+    ta = {r: [Q((r + i) % 11 - 5, 13) for i in range(DIM)] for r in target_ids}
+    tb = {r: [Q((2 * r + i) % 13 - 6, 17) for i in range(DIM)] for r in target_ids}
+    da = {k: [Q(k - i, 5) for i in range(DIM)] for k in range(8)}
+    db = {k: [Q(i - k, 9) for i in range(DIM)] for k in range(8)}
+    ds = {k: [Q(2 * i + k, 11) for i in range(DIM)] for k in range(8)}
+    compare(sa, sb, ta, tb, da, db, ds)
+    return cases, target_ids
+
+
+def controls(centres, matrices, target_ids):
+    source_ids = [c["source"] for c in centres]
+    zero_sources = {source: zero_vector() for source in source_ids}
+    targets_a, targets_b = empty_targets(target_ids), empty_targets(target_ids)
+    dirt = {k: zero_vector() for k in range(8)}
+
+    # A changed second source cannot be replaced by the shared source value.
+    source_b = {r: list(v) for r, v in zero_sources.items()}
+    source_b[source_ids[0]][0] = Q(1)
+    separate = run_separate(
+        centres, matrices, zero_sources, source_b, empty_targets(target_ids), empty_targets(target_ids), dirt, dirt
+    )
+    fused = run_fused(
+        centres, matrices, zero_sources, source_b, empty_targets(target_ids), empty_targets(target_ids), dirt
+    )
+    need(separate[1] != fused[1], "changed-source negative control was not detected")
+
+    # Omitting one of the two target-panel updates corrupts that output.
+    nonzero = {r: zero_vector() for r in source_ids}
+    nonzero[source_ids[0]][0] = Q(1)
+    separate = run_separate(
+        centres, matrices, nonzero, nonzero, empty_targets(target_ids), empty_targets(target_ids), dirt, dirt
+    )
+    fused = run_fused(
+        centres, matrices, nonzero, nonzero, empty_targets(target_ids), empty_targets(target_ids), dirt,
+        skip_update=(1, 0, 0),
+    )
+    need(separate[1] != fused[1], "missing-target negative control was not detected")
+
+    # A missing final clear leaves private data after a nonzero source.
+    _, _, final = run_fused(
+        centres, matrices, nonzero, nonzero, empty_targets(target_ids), empty_targets(target_ids), dirt, restore=False
+    )
+    need(any(v != zero_vector() for v in final.values()), "missing-clear negative control was not detected")
+    return 3
+
+
+def main():
+    task = json.loads((PKG / "TASK.json").read_text())
+    selected_path = ROOT / "certificates/selected-result.json"
+    selected_bytes = selected_path.read_bytes()
+    selected = json.loads(selected_bytes)
+    need(sha256(selected_bytes) == RECORD_SHA256 == task["selected_record_sha256"], "selected record pin changed")
+    need(selected["kappa"] == "836330098538459/500000000000000000", "selected kappa changed")
+    need(selected["source_manifest"] == "research/community-frontier1094-audit/SELECTED-SOURCE.json", "manifest link changed")
+    need(selected["certificate"] == "research/community-frontier1094-audit/ASSEMBLY.json", "certificate link changed")
+    need(selected["certificate_sha256"] == ASSEMBLY_SHA256, "selected certificate digest link changed")
+    need(selected["reproduce"] == "make frontier1094-verify", "selected reproduction instruction changed")
+    need(sha256((ROOT / selected["certificate"]).read_bytes()) == ASSEMBLY_SHA256, "selected certificate bytes changed")
+
+    archive_bytes = ARCHIVE.read_bytes()
+    need(sha256(archive_bytes) == ARCHIVE_SHA256, "selected replay archive pin changed")
+    with tarfile.open(fileobj=io.BytesIO(archive_bytes), mode="r:gz") as archive:
+        word = load_json_tar(archive, PROVIDER + "CANONICAL-WORD.json.gz")
+        programs = load_json_tar(archive, PROVIDER + "LOCAL-PROGRAMS.json.gz")
+        local_checks = load_json_tar(archive, PROVIDER + "LOCAL-CHECKS.json")
+    centres, profile = read_centres(programs, word, local_checks)
+    matrices = transforms()
+    basis_cases, target_ids = test_basis(centres, matrices)
+    control_count = controls(centres, matrices, target_ids)
+
+    # Exact full local phase invoice for the two-call boundary.
+    target_updates_per_panel = sum(len(c["updates"]) for c in centres)
+    separate = {
+        "clear": 4 * len(centres),
+        "source_copy": 2 * len(centres),
+        "rank8_center": 2 * len(centres),
+        "target_update": 2 * target_updates_per_panel,
+    }
+    fused = {
+        "clear": 2 * len(centres),
+        "source_copy": len(centres),
+        "rank8_center": len(centres),
+        "target_update": 2 * target_updates_per_panel,
+    }
+    need(sum(separate.values()) == 416 and sum(fused.values()) == 384, "phase invoice changed")
+    need(separate["target_update"] == fused["target_update"] == 352, "target updates were undercharged")
+    need(separate["rank8_center"] - fused["rank8_center"] == 8, "rank-8 saving changed")
+
+    # Recompute the favorable envelope, then compare it to the unchanged bit side.
+    ceiling_path = ROOT / "research/complex-local-word-ceiling/ceiling.py"
+    spec = importlib.util.spec_from_file_location("selected_ceiling", ceiling_path)
+    ceiling = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(ceiling)
+    shared_profile = dict(profile)
+    shared_profile[8] //= 2
+    bit_a = Q(json.loads((ROOT / selected["certificate"]).read_text())["bit_lower"])
+    lo, hi = ceiling.ceiling(shared_profile, 73, 896, 9, 32, grid=Q(1, 10**12))
+    bit_moment = ceiling.relax(shared_profile, 73, 896, 9, 32, bit_a)
+    need(lo < hi and bit_moment[1] < 1, "half-centre screen does not beat the current bit threshold")
+    whole_kappa_cap = bit_a / (1 + bit_a)
+    current_kappa = Q(selected["kappa"])
+    gain_percent = (whole_kappa_cap / current_kappa - 1) * 100
+
+    print(
+        "PASS_CENTRE_TWO_PANEL_FANOUT "
+        f"R={word['R']} centres={len(centres)} targets_per_centre=22 "
+        f"updates_per_panel={target_updates_per_panel} basis_cases={basis_cases} controls={control_count} "
+        f"actions={sum(separate.values())}->{sum(fused.values())} "
+        f"rank8={separate['rank8_center']}->{fused['rank8_center']} "
+        f"profile8={profile[8]}->{shared_profile[8]} "
+        f"a_cap={float(hi):.12f} bit_a={float(bit_a):.12f} "
+        f"whole_kappa_cap={float(whole_kappa_cap):.15f} max_gain_pct={float(gain_percent):.4f}"
+    )
+
+
+if __name__ == "__main__":
+    main()