diff --git a/research/complex-routing-leaf-fusion/CAP-SOURCE.json b/research/complex-routing-leaf-fusion/CAP-SOURCE.json
new file mode 100644
index 0000000000..d56c816ec9
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/CAP-SOURCE.json
@@ -0,0 +1,9 @@
+{
+  "repository": "CrocSwap/integer-mult-bounds",
+  "head": "4cfbb0cc8314d7fb4e8e754545a49a42eb590a69",
+  "path": "research/t74-joint-twelve/vendor/ceiling.py",
+  "local_path": "vendor/ceiling.py",
+  "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc",
+  "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c",
+  "credit": "Douglas Colkitt, with Claude assistance; retained unchanged. Adapter derived from Tekalign PR2751 packing_cap.py, with Codex assistance."
+}
diff --git a/research/complex-routing-leaf-fusion/CLAIM.json b/research/complex-routing-leaf-fusion/CLAIM.json
new file mode 100644
index 0000000000..d352e67b80
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/CLAIM.json
@@ -0,0 +1,26 @@
+{
+  "status": "COMPLETE_FINITE_RELEASE_PASSED_CONDITIONAL_KAPPA",
+  "complex_lower": "0.001717256973467002308270",
+  "complex_upper": "0.001717256973467002308271",
+  "kappa": "17172569734670023082699999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000",
+  "kappa_decimal": "0.0017172569734670023082699999999999999999999998999999999999999999999999",
+  "profile": {
+    "1": 1591740,
+    "2": 430902,
+    "3": 204396,
+    "4": 79920,
+    "5": 22532,
+    "8": 5328,
+    "32": 1,
+    "48": 26558
+  },
+  "comparison_pr": 2751,
+  "comparison_head": "4cfbb0cc8314d7fb4e8e754545a49a42eb590a69",
+  "comparison_kappa": "17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000",
+  "absolute_gain": "115387118575970161/1000000000000000000000000",
+  "relative_gain": "1153871185759701610000000000000000000000000000000000000000000000/17171415863484263381089999999999999999999998999999999999999999999999",
+  "relative_gain_percent_decimal": "0.006719720697076920262999344663512072867487887126182086416724216655132904",
+  "credited_refit_pr": 2733,
+  "credited_refit_head": "a63c55ff56aaa8645d64d1162d1f017b59ded42a",
+  "scope": "New composition of the credited PR2733 frame refit with PR2751 joint twelve-source recovery. Complete finite native, supplier and modern outer release passed; inherited universal hypotheses and selected frontier unchanged."
+}
diff --git a/research/complex-routing-leaf-fusion/CREDIT-PINS.json b/research/complex-routing-leaf-fusion/CREDIT-PINS.json
new file mode 100644
index 0000000000..135d91f4f6
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/CREDIT-PINS.json
@@ -0,0 +1,20 @@
+{
+  "repository": "CrocSwap/integer-mult-bounds",
+  "pr": 2733,
+  "head": "a63c55ff56aaa8645d64d1162d1f017b59ded42a",
+  "root": "references/pr2733",
+  "files": {
+    "PROOF.md": {
+      "sha256": "7e029f68b0ff7beb0b1ba1f9013d525ec97060c0309026b3838d4d2680cc5dd0",
+      "git_blob": "452212aa89fa23a3c058b5485c9f97b8877f4cb6"
+    },
+    "CLAIM.json": {
+      "sha256": "7402be1dcf6225f36fe727f0d0d5ae801de3b5dfda5bf18f8c1290e71d6f25c1",
+      "git_blob": "4d848d5466e2b9b203891ac8a2ad75fd97124c9b"
+    },
+    "NOTICE": {
+      "sha256": "43b0546bcdf17863c8c2199b2da3f436b4fa92b634ae36a0e793ef10ce3f8b98",
+      "git_blob": "6dacc7b2ce7ad75c7574914c8b30fa64611be9b0"
+    }
+  }
+}
diff --git a/research/complex-routing-leaf-fusion/FULL-REPLAY-CHANGES.patch b/research/complex-routing-leaf-fusion/FULL-REPLAY-CHANGES.patch
new file mode 100644
index 0000000000..4f1f4c3220
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/FULL-REPLAY-CHANGES.patch
@@ -0,0 +1,118 @@
+--- pr2751/full_replay.py
++++ full_replay.py
+@@ -1,7 +1,8 @@
+ #!/usr/bin/env python3
+ # SPDX-License-Identifier: Apache-2.0
+-# Tekalign (@tekuuu), with substantial OpenAI Codex assistance.
+-"""Cold reproduction of the joint twelve-source/pre-life composition.
++# Derived from Tekalign / PR2751 full_replay.py, with substantial OpenAI Codex assistance.
++# This derivative composes Marius-Paul Dumitrean / PR2733's exact frame refit.
++"""Cold reproduction of the twelve-source / five-frame composition.
+ 
+ Default: authenticated source download, fresh native providers and retained
+ parent admission, then the complete original supplier/release verifier. An
+@@ -27,6 +28,8 @@
+ from urllib.parse import quote
+ from urllib.request import Request, urlopen
+ 
++from derive_runtime import derive_runtime
++
+ HERE = Path(__file__).resolve().parent
+ REPOSITORY = HERE.parents[1]
+ STEPS = ['native', 'ledgers', 'local-replay', 'wrappers', 'phases']
+@@ -116,6 +119,7 @@
+     ap = argparse.ArgumentParser(description=__doc__)
+     ap.add_argument('--source', type=Path, help='Exact original PR2679 package directory; otherwise download pinned files.')
+     ap.add_argument('--work', type=Path, required=True)
++    ap.add_argument('--composition-source', type=Path, help='Exact PR2751 package; otherwise fetch four pinned composition files.')
+     ap.add_argument('--prepared-native-cache', type=Path, help='Explicit reuse of the complete published pinned cache.')
+     ap.add_argument('--jobs', type=int, default=4)
+     a = ap.parse_args()
+@@ -129,10 +133,22 @@
+     need(versions['sympy'] == '1.14.0', 'pinned predecessor evidence requires sympy==1.14.0')
+     work = a.work.resolve()
+     need(not work.exists() and not work.is_relative_to(REPOSITORY), 'fresh external work required')
+-    for path in (a.source, a.prepared_native_cache):
++    for path in (a.source, a.composition_source, a.prepared_native_cache):
+         need(path is None or (path.is_dir() and not work.is_relative_to(path.resolve())), 'input/work separation')
+-    pins, reuse, claim = read(HERE / 'SOURCE-FILES.json'), read(HERE / 'REUSE-PINS.json'), read(HERE / 'CLAIM.json')
++    config, claim = read(HERE / 'FULL-REPLAY-PINS.json'), read(HERE / 'CLAIM.json')
++    reuse = read(HERE / 'evidence/NATIVE-RECEIPT.json') if a.prepared_native_cache else None
+     work.mkdir(parents=True)
++    composition = work / 'composition'
++    composition.mkdir()
++    for name, expected in config['files'].items():
++        safe(name)
++        body = ((a.composition_source / name).read_bytes() if a.composition_source
++                else download(config['base_url'] + quote(name, safe='/'), expected))
++        need(hashlib.sha256(body).hexdigest() == expected, 'composition source bytes: ' + name)
++        destination = composition / name
++        destination.parent.mkdir(parents=True, exist_ok=True)
++        destination.write_bytes(body)
++    pins = read(composition / 'SOURCE-FILES.json')
+     env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONUTF8='1', PYTHONINTMAXSTRDIGITS='0',
+                OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1')
+     for name in ('PYTHONOPTIMIZE', 'WITNESS_SPEC', 'WITNESS_DISCOVER', 'WITNESS_RECORD'):
+@@ -157,10 +173,10 @@
+     run('literal-review', HERE / 'verify.py')
+     source = work / 'source'
+     source_copy(a.source.resolve() if a.source else None, source, pins, a.jobs)
+-    overlay = read(HERE / 'OVERLAY-PINS.json')
++    overlay = read(composition / 'OVERLAY-PINS.json')
+     need(sha(source/'MANIFEST.json') == overlay['original_manifest_sha256'], 'overlay base manifest')
+-    need(sha(HERE/'DERIVATIVE-OVERLAY.tar.gz') == overlay['archive_sha256'], 'overlay archive')
+-    with tarfile.open(HERE/'DERIVATIVE-OVERLAY.tar.gz') as archive:
++    need(sha(composition/'DERIVATIVE-OVERLAY.tar.gz') == overlay['archive_sha256'], 'overlay archive')
++    with tarfile.open(composition/'DERIVATIVE-OVERLAY.tar.gz') as archive:
+         members=archive.getmembers()
+         need(set(m.name for m in members)==set(overlay['files']) and len(members)==len(overlay['files']), 'exact overlay paths')
+         for member in members:
+@@ -170,7 +186,25 @@
+             (source/member.name).write_bytes(body)
+     need(sha(source/'MANIFEST.json')==overlay['derived_manifest_sha256'] and
+          tree(source,('MANIFEST.json',))==read(source/'MANIFEST.json'), 'complete derived source tree')
+-    pins=dict(pins,commit='local-joint12-pr2733',manifest_sha256=overlay['derived_manifest_sha256'])
++    changes = derive_runtime(source, HERE)
++    need(sha(source/'MANIFEST.json') == config['derived_manifest_sha256']
++         and tree(source, ('MANIFEST.json',)) == read(source/'MANIFEST.json'), 'complete refit source tree')
++    write(work/'DERIVATION.json', changes)
++    pins=dict(pins,commit=config['source_commit'],manifest_sha256=config['derived_manifest_sha256'])
++    # Only source bindings and the strict predecessor comparison change in the
++    # authenticated admission driver. Its physical costs and controls remain.
++    admission = (composition/'workflow/admit.py').read_text()
++    edits = [("SOURCE_COMMIT = 'local-joint12-pr2733'", "SOURCE_COMMIT = " + repr(config['source_commit'])),
++             ("SOURCE_MANIFEST = '7980dbde79b63de4093cde89d1564a18c6bf16a2e35d810e38cf9797fe09e0cf'",
++              "SOURCE_MANIFEST = " + repr(config['derived_manifest_sha256'])),
++             ("previous = Q('0.0017161404259974415161889999999999999999999998999999999999999999999999')",
++              "previous = Q(" + repr(read(HERE/'vendor/pr2751/CLAIM.json')['kappa']) + ")")]
++    for before, after in edits:
++        need(admission.count(before) == 1, 'exact admission patch preimage')
++        admission = admission.replace(before, after)
++    (work/'admit.py').write_text(admission)
++    write(work/'ADMISSION-CHANGES.json', edits)
++
+     cache = work / 'native-cache'
+     if a.prepared_native_cache:
+         need(tree(a.prepared_native_cache.resolve()) == reuse['cache_files'], 'published complete cache pins')
+@@ -221,8 +255,8 @@
+                               source_commit=pins['commit'], manifest_sha256=pins['manifest_sha256'], providers=providers,
+                               retained_parent_receipt_sha256=sha(receipts / 'RECEIPT.json'), cache_files=tree(cache))
+     write(work / 'NATIVE-RECEIPT.json', native_receipt)
+-    run('complete-admission', HERE / 'workflow/admit.py', '--source', source,
+-        '--fill', HERE / 'inputs/FILL.json.gz', '--order', HERE / 'inputs/ORDER.json',
++    run('complete-admission', work / 'admit.py', '--source', source,
++        '--fill', HERE / 'vendor/pr2751/inputs/FILL.json.gz', '--order', HERE / 'vendor/pr2751/inputs/ORDER.json',
+         '--native-cache', cache, '--native-receipt', work / 'NATIVE-RECEIPT.json',
+         '--work', work / 'admission', '--jobs', a.jobs)
+     result = read(work / 'admission/RESULT.json')
+@@ -230,8 +264,8 @@
+          and Q(result['kappa']) == Q(claim['kappa']) and Q(result['complex_lower']) == Q(claim['complex_lower']),
+          'published complete claim binding')
+     need(result['profile'] == {str(k):v for k,v in read(HERE / 'CLAIM.json')['profile'].items()}, 'published complete profile binding')
+-    result.update(status='PASS_T74_JOINT_TWELVE_COLD_COMPLETE_RELEASE', explicit_native_cache_reuse=bool(a.prepared_native_cache),
+-                  source_files_sha256=sha(HERE / 'SOURCE-FILES.json'), native_receipt_sha256=sha(work / 'NATIVE-RECEIPT.json'),
++    result.update(status='PASS_T74_JOINT_TWELVE_REFIT_COLD_COMPLETE_RELEASE', explicit_native_cache_reuse=bool(a.prepared_native_cache),
++                  source_files_sha256=sha(composition / 'SOURCE-FILES.json'), native_receipt_sha256=sha(work / 'NATIVE-RECEIPT.json'),
+                   cold_stages=stages, cold_seconds=time.monotonic()-started,
+                   environment=dict(python=platform.python_version(), executable=sys.executable, versions=versions))
+     write(work / 'RESULT.json', result)
diff --git a/research/complex-routing-leaf-fusion/FULL-REPLAY-PINS.json b/research/complex-routing-leaf-fusion/FULL-REPLAY-PINS.json
new file mode 100644
index 0000000000..9b40d7aece
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/FULL-REPLAY-PINS.json
@@ -0,0 +1,12 @@
+{
+  "base_url": "https://raw.githubusercontent.com/CrocSwap/integer-mult-bounds/4cfbb0cc8314d7fb4e8e754545a49a42eb590a69/research/t74-joint-twelve/",
+  "derived_manifest_sha256": "1e75eabffe1ce311cc3bddc05e76118cbdedfc806200a906c57fbc5a5dd213eb",
+  "files": {
+    "DERIVATIVE-OVERLAY.tar.gz": "16468f7428c6e01522fcb15a8e3040d13de6cb8856428e32dcfbce8dbe46b8ec",
+    "OVERLAY-PINS.json": "c5aab657b189d1324b75c2a35dd21063877229ebfd58b4b64261fdf0e5861e75",
+    "SOURCE-FILES.json": "4191b13800d48048f8b3b736c888040445d02c31ee7756915c21e011da62f5a1",
+    "workflow/admit.py": "f0d510b46a5f05b033b13fecb706389ab374b783bd46ef30e7386195d9e56d3e"
+  },
+  "source_commit": "local-joint12-refit393",
+  "source_head": "4cfbb0cc8314d7fb4e8e754545a49a42eb590a69"
+}
diff --git a/research/complex-routing-leaf-fusion/OVERLAP.json b/research/complex-routing-leaf-fusion/OVERLAP.json
new file mode 100644
index 0000000000..d6ea92f4c7
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/OVERLAP.json
@@ -0,0 +1,55 @@
+{
+  "status": "POSSIBLE_OVERLAP_NOT_A_NOVELTY_CERTIFICATE",
+  "searched_at": "2026-10-15T20:50:51.799511+00:00",
+  "terms": [
+    "routing",
+    "leaf",
+    "H2",
+    "bootstrap",
+    "2751",
+    "2733",
+    "refit"
+  ],
+  "coverage": {
+    "open_prs": {
+      "fetched_at": "2026-10-15T20:48:19.409017+00:00",
+      "complete_pagination": true,
+      "records": 711
+    },
+    "discussions": {
+      "fetched_at": "2026-10-15T20:50:51.632152+00:00",
+      "complete_pagination": true,
+      "records": 1400
+    }
+  },
+  "local_records": 1961,
+  "warnings": [],
+  "limits": "Remote PR scope is open PRs including drafts. Closed work is searched through local READMEs, TASK metadata and ledger only. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission.",
+  "matches_total": 979,
+  "reviewed_distinctions": [
+    {
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2751",
+      "head": "4cfbb0cc8314d7fb4e8e754545a49a42eb590a69",
+      "finding": "Latest twelve-source words retain the old rank-six frame at B1151. This package composes the credited earlier refit and validates full native/outer admission."
+    },
+    {
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2733",
+      "head": "a63c55ff56aaa8645d64d1162d1f017b59ded42a",
+      "finding": "Credited rank-five refit on a different predecessor word at B1149; not new authorship of the refit."
+    },
+    {
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2755",
+      "finding": "Native replay acceleration, not a changed paid leaf profile."
+    },
+    {
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2319",
+      "finding": "BIT caller, control and numerical storage work; does not supply this changed binding complex paid moment."
+    },
+    {
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2399",
+      "finding": "Conditional fast-callee substitution already overlaps an initial BIT target; not replicated here."
+    }
+  ],
+  "source_heads_checked_at_utc": "2026-10-15T20:48:00Z",
+  "decision": "No duplicate composition found in the inspected metadata and relevant source words. Metadata is not a novelty certificate."
+}
diff --git a/research/complex-routing-leaf-fusion/PACKING-CAP.json b/research/complex-routing-leaf-fusion/PACKING-CAP.json
new file mode 100644
index 0000000000..c7bedd3bf6
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/PACKING-CAP.json
@@ -0,0 +1,25 @@
+{
+  "status": "PASS_FIXED_WORD_PACKING_CEILING",
+  "source_sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc",
+  "local_per_call": {
+    "1": "2364",
+    "2": "647",
+    "3": "297",
+    "4": "120",
+    "5": "26",
+    "8": "8"
+  },
+  "dimension": 73,
+  "families": 896,
+  "stages": 9,
+  "centre_rank_per_call": 64,
+  "max_idle_rank": 51,
+  "complex_cap_bracket": [
+    "875246617611/500000000000000",
+    "1750493235223/1000000000000000"
+  ],
+  "complex_cap_upper_decimal": "0.001750493235223",
+  "realized_fraction_lower": "171725697346700230827/175049323522300000000",
+  "realized_fraction_decimal": "0.98101320182950399363412598930700232291074148709344",
+  "scope": "Fixed joint-twelve local word and hosted nine-stage coverage law; all remaining mass is relaxed to fractional rank51 children. This generic coverage-law ceiling is weaker than a window-aware packing or lattice bound. It does not certify or import the predecessor advertised lattice ceiling. It bounds this complex model, not different words or coverage laws. Modern outer admission is separate; no historical a/(1+a) conversion is used."
+}
diff --git a/research/complex-routing-leaf-fusion/PATCH.json b/research/complex-routing-leaf-fusion/PATCH.json
new file mode 100644
index 0000000000..96a2f040c3
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/PATCH.json
@@ -0,0 +1,111 @@
+{
+  "status": "EXACT_CREDITED_FRAME_REFIT_COMPOSITION",
+  "source_head": "4cfbb0cc8314d7fb4e8e754545a49a42eb590a69",
+  "refit_head": "a63c55ff56aaa8645d64d1162d1f017b59ded42a",
+  "providers": {
+    "base": {
+      "source_sha256": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a",
+      "canonical_source_sha256": "f01476ff54463854b4bf0d76ab8880335d4352d2c9835a3f9e04f861833f3a0c",
+      "canonical_result_sha256": "af1a684d3ae4a6fb7f8709a3ff5a84e4449e10a97f5b415f5733016cab9997c4",
+      "section": "B",
+      "index": 1151,
+      "old": [
+        "add",
+        393,
+        515,
+        1,
+        1,
+        [
+          259,
+          132,
+          66,
+          36,
+          16,
+          9
+        ]
+      ],
+      "new": [
+        "add",
+        393,
+        515,
+        1,
+        1,
+        [
+          259,
+          148,
+          66,
+          36,
+          9
+        ]
+      ],
+      "local_profile": {
+        "1": 2364,
+        "2": 647,
+        "3": 297,
+        "4": 120,
+        "5": 26,
+        "8": 8
+      }
+    },
+    "extra": {
+      "source_sha256": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127",
+      "canonical_source_sha256": "4c29482885c1a189186c4641bfe34b8a95936f5536ac607ffbb1a9f17d94800e",
+      "canonical_result_sha256": "d2c596ce4aecf9af92f294bbc1d7e9450cf83b9d80dfe347faa6be849d7f6cbc",
+      "section": "B",
+      "index": 1151,
+      "old": [
+        "add",
+        393,
+        515,
+        1,
+        1,
+        [
+          259,
+          132,
+          66,
+          36,
+          16,
+          9
+        ]
+      ],
+      "new": [
+        "add",
+        393,
+        515,
+        1,
+        1,
+        [
+          259,
+          148,
+          66,
+          36,
+          9
+        ]
+      ],
+      "local_profile": {
+        "1": 2364,
+        "2": 647,
+        "3": 297,
+        "4": 120,
+        "5": 26,
+        "8": 8
+      }
+    }
+  },
+  "global_delta": {
+    "1": -1332,
+    "2": 666
+  },
+  "global_profile": {
+    "1": 1591740,
+    "2": 430902,
+    "3": 204396,
+    "4": 79920,
+    "5": 22532,
+    "8": 5328,
+    "32": 1,
+    "48": 26558
+  },
+  "source_refit_authorship": "Marius-Paul Dumitrean PR2733; joint twelve-source recovery Tekalign PR2751",
+  "scope": "Generator only; independent algebra/frame checks and native/global/outer replay remain separate."
+}
diff --git a/research/complex-routing-leaf-fusion/PREDECESSOR.json b/research/complex-routing-leaf-fusion/PREDECESSOR.json
new file mode 100644
index 0000000000..035f363968
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/PREDECESSOR.json
@@ -0,0 +1,92 @@
+{
+  "repository": "CrocSwap/integer-mult-bounds",
+  "pr": 2751,
+  "head": "4cfbb0cc8314d7fb4e8e754545a49a42eb590a69",
+  "root": "vendor/pr2751",
+  "files": {
+    "independent_local.py": {
+      "sha256": "ee1faab70095fa312fc61d375ddf015b76104cb1a542ae7876a149e7999faa20",
+      "git_blob": "e0b556adc3d05c8f97e94992e0f872916154202d"
+    },
+    "independent_owners.py": {
+      "sha256": "4e0785a659b4a6516581f15476c054de1581aa4b3763ce45b1fd20e45c2bb5af",
+      "git_blob": "93270b725a4efd56b283b02f9abf7a5d0e66c55f"
+    },
+    "composition.py": {
+      "sha256": "f202f8ce9730b778c9ee1213d63d444d117df5ff7d47933037a924723a37e3f4",
+      "git_blob": "bb455e907ddf8227cb5c8062825540eda219ba17"
+    },
+    "exact_moment.py": {
+      "sha256": "f170292f7983773d4f142afdac4677c1615fb7b781dbabf395200aea886dcade",
+      "git_blob": "30dc8aa22939ea377d893462a863bc7c37b4e210"
+    },
+    "PROFILE.json": {
+      "sha256": "36e76f32570bac074cf70a6076b7c54e6d5b0fc3b505f404bc58fd02abf7967d",
+      "git_blob": "080d9e165dbc951c9e8d3eb027bf2b187e932c5d"
+    },
+    "CLAIM.json": {
+      "sha256": "78e99222196fca8b74a895b9e2db40a0e4afd1d69cd4fb52f38bfb157bac2438",
+      "git_blob": "48ad23a430def28e485ee311ac92828ac9664a0c"
+    },
+    "README.md": {
+      "sha256": "d8501fbc11b3dc87fc618122c83f10a56cd4457c7abdab792e2f9506bab4666e",
+      "git_blob": "77ab0d3121069a8aa365bf0f6c35ee8e5ac15ac8"
+    },
+    "PROOF.md": {
+      "sha256": "6ecefda5d853e3ede1ee06aab08de24dfde960d98178a71844340ed86ae0d9b9",
+      "git_blob": "d2b1a96ba8ea6f20e87e12cf2817e0c3ce4c5f30"
+    },
+    "SOURCE-NOTICE": {
+      "sha256": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420",
+      "git_blob": "380e979f0e84e00a22bd890615d87cc4684ad740"
+    },
+    "LICENSE": {
+      "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+      "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64"
+    },
+    "inputs/WORD-base.json.gz": {
+      "sha256": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a",
+      "git_blob": "f1fc67a6eaf4bcc5dfa852b448aa2659070fa5f8"
+    },
+    "inputs/WORD-extra.json.gz": {
+      "sha256": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127",
+      "git_blob": "f06e80c4dddb9741d0051cb85a57d356e673f687"
+    },
+    "inputs/FILL.json.gz": {
+      "sha256": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1",
+      "git_blob": "17129e917b31b15625c53181d303b68e17ffed55"
+    },
+    "inputs/ORDER.json": {
+      "sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7",
+      "git_blob": "c202d6ec222a257a64b2017eb1bbb0f9d2682669"
+    },
+    "inputs/PROVIDERS.json": {
+      "sha256": "ec4802a33c0e1d41369da77b19b9b783dc812b2d3246e096fee13d29f226dd66",
+      "git_blob": "26be26b6d25be67327ae77623c2eaa0a9fe463dc"
+    },
+    "inputs/DISPATCH.json.gz": {
+      "sha256": "14fe756dcac93a0f3b2b7f38ba7b998dec89d56d5171b691af4fae45e5d83d11",
+      "git_blob": "4f4c2138d6be71dc649b8ee746385f059c242f21"
+    },
+    "inputs/PLAN.json.gz": {
+      "sha256": "afb3c5c8134fc2cfce0b50a21758490c225574994b2c3c5161e53e2355acc6fa",
+      "git_blob": "973f576bccc4b8021bfa9b4fff815b0949fe5932"
+    },
+    "inputs/GLOBAL-TEMPLATE.json.gz": {
+      "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e",
+      "git_blob": "114808c32b1799da53524bdc25cea67efb60009e"
+    },
+    "inputs/SOURCE-FILL.json.gz": {
+      "sha256": "dc96598624ee49d368e1130ec2148734be0bbc68402cc181e1f02ae9ca8e3d06",
+      "git_blob": "4a0d605902453ca2eb8bb2e318274022c136ab81"
+    },
+    "inputs/SOURCE-ORDER.json": {
+      "sha256": "aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667",
+      "git_blob": "7141bd58cc465e28f0189345713ddd366c814ca4"
+    },
+    "inputs/SOURCE-PROVIDERS.json": {
+      "sha256": "d8d90c3b906c66874f9fe07df67be24e53f3f3f9146565b56a272548108327b7",
+      "git_blob": "d49a003505049499afb213c09e1011cb511ebbcc"
+    }
+  }
+}
diff --git a/research/complex-routing-leaf-fusion/PROFILE.json b/research/complex-routing-leaf-fusion/PROFILE.json
new file mode 100644
index 0000000000..5bd9ded8e3
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/PROFILE.json
@@ -0,0 +1,10 @@
+{
+  "1": 1591740,
+  "2": 430902,
+  "3": 204396,
+  "4": 79920,
+  "5": 22532,
+  "8": 5328,
+  "32": 1,
+  "48": 26558
+}
diff --git a/research/complex-routing-leaf-fusion/PROOF.md b/research/complex-routing-leaf-fusion/PROOF.md
new file mode 100644
index 0000000000..ae74069fb0
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/PROOF.md
@@ -0,0 +1,208 @@
+# A credited frame refit on the joint twelve-source recovery word
+
+This construction composes Marius-Paul Dumitrean's one-gate refit from
+[PR2733](https://github.com/CrocSwap/integer-mult-bounds/pull/2733), head
+`a63c55ff56aaa8645d64d1162d1f017b59ded42a`, with Tekalign's joint twelve-source
+recovery from [PR2751](https://github.com/CrocSwap/integer-mult-bounds/pull/2751),
+head `4cfbb0cc8314d7fb4e8e754545a49a42eb590a69`. The refit is predecessor work;
+the new result is its valid composition with the changed recovery word and
+the resulting complete invoice. No new scalar identity or refit mechanism
+is claimed.
+
+The two source words do not contain this refit. Their unique gate
+`393 += 515` is B1151, with zero-based indexing, in both providers. PR2733
+performs the corresponding edit at B1149 in its different word. Matching a
+register pair is not enough to justify composition: the proof below checks
+the actual preceding and following frames in the PR2751 words. The local
+symbolic checks also retain the changed source recoveries and dirty-input
+corrections.
+
+## Exact changed gate and its legal frames
+
+Frames are binary subspaces of `F_2^9`, encoded by the listed integer vectors.
+Their use in the native complex construction retains the predecessor's
+common-label, realization and transport contracts. Let
+
+```
+P = span(407,66,36,9),                  dim P = 4,
+N = span(259,148,66,36,9),              dim N = 5,
+O = span(259,132,66,36,16,9),           dim O = 6.
+```
+
+At B1151 the current frame of register 393 is P and the current frame of
+register 515 is N. The existing gate executes at O. Replace that gate by
+
+```
+['add',393,515,1,1,[259,148,66,36,9]].
+```
+
+Both operands can reach N: `407 = 259 xor 148` proves `P <= N`, and
+`148 = 132 xor 16` gives `N < O`. Each operand's next touched frame has
+dimension 7 and contains O. Explicitly they are
+
+```
+Q393 = span(256,132,65,36,16,9,3),
+Q515 = span(259,128,66,32,16,9,4).
+```
+
+Consequently the smaller gate frame still lies between both preceding and
+following frames. Every other gate frame, start frame, final frame, warp
+entrance/exit, target level and centre frame is identical. This is a legal
+monotone frame assignment under the inherited calculus. It does not cross
+a warp or alter a private-buffer lifetime.
+
+The scalar gate, coefficient and order are identical. Thus the formal
+noncommuting-operator word is unchanged, including all source recoveries,
+anticipatory dirty-input corrections and inverse cleanup. The physical
+realization of a scalar operation at a legal common frame is an inherited
+contract, not a consequence of binary subspace containment alone. The
+independent replay checks the complete arbitrary-input maps in both forward
+and dual orientations and checks all cleanup operations; native phase and
+wrapper replay remains a separate evidence layer.
+
+## Complete local and global paid change
+
+Only the following two frame paths change:
+
+| Register | Source path | Composed path | Paid ranks |
+| --- | --- | --- | --- |
+| 393 | 4 -> 6 -> 7 | 4 -> 5 -> 7 | `(2,1)` becomes `(1,2)` |
+| 515 | 5 -> 6 -> 7 | 5 -> 5 -> 7 | `(1,1)` becomes `(0,2)` |
+
+Zero-rank transitions require no child. Register 393's histogram is
+unchanged, while register 515 replaces two rank-one children by one rank-two
+child. The local change is therefore exactly `H2 - 2H1`, with unchanged
+rank mass. Both providers have the new local profile
+
+```
+{1:2364, 2:647, 3:297, 4:120, 5:26, 8:8}.
+```
+
+There remain 415 helpers and 72 private buffers per local word. Entrances,
+exits, residual widths and chronological owner lifetimes are unchanged.
+The source allocation has 666 call equivalents, so the complete change is
+`666*(H2-2H1)`. Retaining every source idle remainder gives
+
+```
+H = {1:1591740, 2:430902, 3:204396, 4:79920,
+     5:22532, 8:5328, 32:1, 48:26558}.
+```
+
+Its rank mass is 4,816,512. The dimension remains 73, live stock 66,304 and
+physical stock 66,801. All 276,390 owner-role reservations remain part of the
+construction. Their reuse is justified by the unchanged allocation inputs
+and residual interfaces, and checked by the independent owner replay. It is
+not permission to drop hosting, stock or other invoice terms.
+
+No scalar or adapter is added. The mathematical operation count changes
+because a recursive frame transition is replaced, not because an additive
+implementation constant is smaller. Native generation and the complete
+finite invoice accept the changed transition and its phases; the recorded
+full release checks this separately from the local proof.
+
+## Strict moment improvement and certified endpoint
+
+For saving `0<a<1`, the native complex moment is
+
+```
+M_H(a) = (1/66304) sum_r H_r (r/73)^(1-a).
+```
+
+The native exact-complex branch has no bad-class surcharge. This is the
+same source contract as PR2751; it is not a new justification for removing
+a surcharge. The complete difference from that source is
+
+```
+M_new(a)-M_source(a)
+  = 666 * 73^(a-1)/66304 * (2^(1-a)-2) < 0.
+```
+
+The inequality is strict because `0<1-a<1`. The rank mass is unchanged,
+so the moments agree at a=0; a rank-mass check alone cannot detect this
+gain. Each rank satisfies r<73, hence the moment is strictly increasing
+in a. A strict sign at each endpoint therefore certifies a unique root
+between
+
+```
+L = 0.001717256973467002308270,
+U = 0.001717256973467002308271.
+```
+
+`exact_moment_checker.py` supplies a separately implemented rational
+enclosure without importing a producer or predecessor arithmetic module.
+For x>=1 it writes x=2^k y with 1<=y<2 and uses
+
+```
+log(y) = 2 sum_(j>=0) z^(2j+1)/(2j+1),  z=(y-1)/(y+1).
+```
+
+After 36 terms the positive remainder is at most
+`2 z^73/[73(1-z^2)]`. Scaling by k gives exact lower/upper logarithm
+enclosures. The argument `a log(73/r)` is less than 1/100 in the checker
+domain. Its exponential is bounded by the degree 20 Taylor polynomial
+and the tail `next_term/(1-x/22)`. Positive weights preserve interval
+orientation. All comparisons use rational arithmetic; fixed-point
+dyadic rounding is only a compact outward representation of the resulting
+slacks.
+
+The checker proves `M_new(L)<1<M_new(U)`. It also proves the unchanged
+source fails at L. Controls reject the unchanged source, the reversed
+mass-preserving fusion, reversed endpoints, the upper endpoint presented
+as an accepted lower endpoint and a changed live denominator. These are
+finite pricing checks, not validation of native execution or an outer
+multiplication theorem.
+
+## Conditional outer target and scope
+
+The admitted conditional target is the exact rational
+
+```
+kappa = L - 10^-46 - 10^-70.
+```
+
+This uses the inherited **modern outer** contract of PR2751 and its pinned
+source chain. The corresponding complete release and ordinary-recurrence
+witness were regenerated at the new endpoint and passed; strict native moment
+acceptance by itself would be insufficient. See VALIDATION.md for exact
+execution coverage and source-bound reuse. `CLAIM.json` records the target and
+the current replay status. The retained bit supplier must remain
+nonbinding, and every changed source/claim binding must be checked.
+
+Relative to PR2751's reported conditional target, the certified increase is
+approximately 1.15387118576e-7, or 0.00671972 percent. This is a small genuine
+paid-profile improvement, not a large mechanism change. It is not a
+measured running-time improvement.
+
+The accepted selected record at this task's base still reports
+`kappa=0.001672660197076918` under its own retained classical transfer and
+supplier assumptions. The larger numerical difference from that accepted
+record cannot be attributed to this one refit: it includes the predecessor
+complex constructions and a changed inherited outer contract. This package
+does not edit the selected frontier or promote pending source claims.
+
+The all-size compiler, common-label/source-access realization, physical
+hosting/routing, precision and fixed-tape contracts, exact recovery,
+ordinary recursion, bit supplier and analytic transfer hypotheses remain.
+In particular this finite complex transport fusion does not discharge the
+separate all-size BIT routing/leaf H2 obligation. A faster implementation
+of that already assumed BIT contract alone would not change the binding
+complex paid moment.
+
+The written proof gives the local frame implication and strict moment
+comparison. Finite evidence gives exact words, complete finite invoices
+and the explicitly recorded replay results. Neither is a proof-assistant
+verification or an unconditional multiplication theorem.
+
+## Attribution
+
+Dumitrean supplied the one-gate refit; Tekalign supplied the joint twelve
+source-recovery word and its independent symbolic, owner and moment
+checkers. Mason Hale's concentrated assignments, Philippe Van Velzen's
+pre-life hosting and earlier refits, Jeremy Kothe's invocation order and
+allocation, and the source-partner/native/bit/outer lineage retain their
+source notices. The exact atanh/Taylor method is standard and retains the
+repository's prior interval-pricing attribution, including PR2751.
+
+New composition and checks by David Arias with substantial OpenAI Codex
+assistance, including separate mathematical and implementation agents.
+Apache-2.0. No independent human review is claimed.
diff --git a/research/complex-routing-leaf-fusion/README.md b/research/complex-routing-leaf-fusion/README.md
new file mode 100644
index 0000000000..a26b09c2a1
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/README.md
@@ -0,0 +1,152 @@
+# A cheaper completed routing frame for the joint twelve-source word
+
+This composes Marius-Paul Dumitrean's [PR #2733](https://github.com/CrocSwap/integer-mult-bounds/pull/2733)
+frame refit with both complete words from Tekalign's
+[PR #2751](https://github.com/CrocSwap/integer-mult-bounds/pull/2751).
+The latter's generated words retain the earlier, more expensive frame. The
+composition replaces **1,332 rank-one recursive transports with 666 rank-two
+transports**, at unchanged rank mass, physical stock, helper inventory, source
+recoveries, dirty-input endpoint and cleanup.
+
+The certified conditional saving is **κ ≈ 0.001717256973467002308270**,
+about **0.00671972% above [PR #2751](https://github.com/CrocSwap/integer-mult-bounds/pull/2751)**. The exact rational is the certified
+lower endpoint minus `10^-46 + 10^-70`; see [CLAIM.json](CLAIM.json).
+This is an incremental paid-cost improvement. The frame refit itself is
+credited predecessor work, and the larger difference from the selected
+κ = 0.001672660197076918 includes predecessor constructions and their
+changed outer contract. The selected record is unchanged.
+
+**Release status:** complete finite native, supplier and modern outer release
+passed. Four native provider chains and retained parent admission were run
+fresh; the public wrapper then reused their fully authenticated same-session
+cache. [VALIDATION.md](VALIDATION.md) records exact commands, coverage and
+receipts. The result retains the predecessor's all-size theorem assumptions;
+finite checks do not prove the full multiplication theorem.
+
+## What changes and why it reduces the bill
+
+At zero-based B1151, `393 += 515` can use a rank-five common frame instead
+of rank six. The exact adjacent frame paths are:
+
+| Register | Before | After | Recursive bill |
+| --- | --- | --- | --- |
+| 393 | 4 → 6 → 7 | 4 → 5 → 7 | `H2+H1` → `H1+H2` |
+| 515 | 5 → 6 → 7 | 5 → 5 → 7 | `2H1` → `H2` |
+
+For `0<p<1`, `2^p<2`, so the second change strictly lowers the paid child
+moment. It saves one child per local invocation, without moving that cost
+to an inverse, source recovery or idle remainder. Both actual words are
+regenerated and checked; matching register numbers alone would not prove
+the composition legal. [PROOF.md](PROOF.md) gives the subspace containments,
+full invoice, exact moment and inherited assumptions.
+
+New local profile: `{1:2364,2:647,3:297,4:120,5:26,8:8}`.
+Complete profile:
+`{1:1591740,2:430902,3:204396,4:79920,5:22532,8:5328,32:1,48:26558}`.
+The fixed-word coverage relaxation gives a complex cap below
+0.001750493235223; the achieved complex endpoint is 98.10132018% of that
+upper cap. This is a generic relaxation, not an attainable packing optimum
+or a global limit for different words. See [PACKING-CAP.json](PACKING-CAP.json).
+
+Rank mass remains 4,816,512; all 276,390 owner roles, 415 helpers and 72
+private buffers remain charged. Live/physical stock is 66,304/66,801.
+
+## Reproduce
+
+The bounded, standard-library replay runs on Python 3.12:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/complex-routing-leaf-fusion
+```
+
+It authenticates every consumed predecessor file before import, regenerates
+both complete words, checks both arbitrary-input orientations, every frame
+and cleanup operation, all owner reservations, the full moment and meaningful
+failure controls. `independent_check.py` implements a separate endpoint/frame
+checker. `exact_moment_checker.py` independently certifies the adjacent
+24-decimal root bracket using rational logarithm/exponential enclosures.
+The public-entrypoint controls include a Git-free export, source corruption,
+an omitted refit, a typed receipt fault and output-preservation checks.
+
+For complete native/supplier/outer release, install `requirements.txt`
+in a separate environment and run:
+
+```sh
+python3 -B research/complex-routing-leaf-fusion/full_replay.py --work /tmp/FRESH-routing-leaf
+```
+
+The full replay authenticates its pending predecessor sources, derives the
+changed runtime in a fresh external directory, and retains the predecessor's
+mathematical rejection controls. The readable runtime/admission patches make
+the derivative changes reviewable. Exact commands, environment, execution
+coverage and any explicit same-session native-cache reuse are recorded in
+[VALIDATION.md](VALIDATION.md).
+
+To regenerate only the two candidate words into a fresh directory:
+
+```sh
+python3 -B research/complex-routing-leaf-fusion/generate.py \
+  --source research/complex-routing-leaf-fusion/vendor/pr2751 \
+  --out /tmp/FRESH-frame-words
+```
+
+Generation refuses an existing output directory. Verification is read-only;
+mathematical equality compares decompressed JSON, not gzip container bytes.
+
+## Scope, overlap and source history
+
+The task began from canonical main
+`6b6b3ab304ca60eab7493e73f264fd23c146be4c`, priority revision 5. Initial
+complete pagination covered 705 open PRs and 1,393 Discussion/comment/reply
+records without warnings. [TASK.json](TASK.json) records scope, subsequent
+freshness and the explicit user assignment. The final refresh covered 711
+open PRs and 1,400 Discussion/comment/reply records, with complete pagination
+and no warnings; see [OVERLAP.json](OVERLAP.json). Metadata search is not proof
+of novelty. No public coordination message or selected-frontier change was made.
+
+The initial target was the BIT caller's `O(wV)` route and leaf routines.
+The selected complex supplier already binds, so completing that assumed BIT
+contract alone cannot change the selected κ at its current precision.
+[PR #2399](https://github.com/CrocSwap/integer-mult-bounds/pull/2399) and
+[PR #2457](https://github.com/CrocSwap/integer-mult-bounds/pull/2457) already
+provide conditional fast-callee and spectator adapters. The single bounded
+pivot here targets actual paid complex transport instead. This package does
+**not** discharge BIT H2 or supply a new physical fixed-tape compiler.
+
+PR #2751 is pinned at `4cfbb0cc8314d7fb4e8e754545a49a42eb590a69` and PR #2733
+at `a63c55ff56aaa8645d64d1162d1f017b59ded42a`. Their earlier scalar words,
+source recoveries, frames and outer hypotheses remain credited and explicit.
+Only this scoped directory is added. `PREDECESSOR.json`, `CREDIT-PINS.json`
+and the full-replay manifests identify exact source hashes and Git blobs.
+
+The all-size compiler, common-label/source access, physical hosting/routing,
+precision/fixed-tape, exact recovery, ordinary recursion, bit supplier and
+analytic-transfer obligations remain inherited. No measured multiplication
+speedup, unconditional theorem, proof-assistant verification, global frame
+optimum or independent human review is claimed.
+
+## Open next questions
+
+- Can a changed source or restoration boundary eliminate more paid transport?
+  Start from these complete words and price all new source reads, adapters,
+  cleanup and owner lifetimes before searching. A local saving is insufficient
+  unless the complete bill improves.
+- Can an actual route or leaf implementation discharge an inherited physical
+  interface? Start with one named fixed-tape boundary and its uniform cost
+  proof. The finite words and the source-level BIT caller do not supply the
+  complete multiplication machine.
+
+The corresponding structured questions and blockers are in TASK.json.
+
+## Credit
+
+Marius-Paul Dumitrean supplied the rank-five refit; Tekalign supplied joint
+twelve-source recovery. Mason Hale's assignments, Philippe Van Velzen's
+pre-life hosting, Jeremy Kothe's owner allocation, and the preserved
+source-partner, geometry, native, BIT and outer lineage remain credited in
+[the original notice](vendor/pr2751/SOURCE-NOTICE) and the unchanged source
+exports. This composition does not claim authorship of those mechanisms.
+
+Prepared for David Arias with substantial OpenAI Codex assistance, including
+separate mathematical and implementation-checking agents. New work is
+Apache-2.0; retained source licenses and notices remain in place.
diff --git a/research/complex-routing-leaf-fusion/RESULT.json b/research/complex-routing-leaf-fusion/RESULT.json
new file mode 100644
index 0000000000..b66136192a
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/RESULT.json
@@ -0,0 +1,671 @@
+{
+  "authenticated_files": 21,
+  "calls": 666,
+  "complex_lower": "171725697346700230827/100000000000000000000000",
+  "complex_upper": "1717256973467002308271/1000000000000000000000000",
+  "controls": [
+    "base:drop_anticipatory",
+    "base:reverse_anticipatory",
+    "base:reverse_recovery",
+    "base:omitted_refit",
+    "extra:drop_anticipatory",
+    "extra:reverse_anticipatory",
+    "extra:reverse_recovery",
+    "extra:omitted_refit",
+    "out_of_bin",
+    "old_profile"
+  ],
+  "kappa": "17172569734670023082699999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000",
+  "profile": {
+    "1": 1591740,
+    "2": 430902,
+    "3": 204396,
+    "32": 1,
+    "4": 79920,
+    "48": 26558,
+    "5": 22532,
+    "8": 5328
+  },
+  "providers": {
+    "extra": {
+      "center_paths": [
+        {
+          "center": 92,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            12,
+            100,
+            103,
+            17,
+            72,
+            94,
+            70,
+            62,
+            101,
+            54,
+            18,
+            40,
+            0,
+            57,
+            98,
+            48,
+            45,
+            107,
+            49,
+            34,
+            108,
+            22
+          ]
+        },
+        {
+          "center": 57,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            6,
+            82,
+            93,
+            58,
+            72,
+            94,
+            70,
+            62,
+            83,
+            73,
+            59,
+            30,
+            0,
+            57,
+            80,
+            67,
+            8,
+            95,
+            68,
+            5,
+            96,
+            64
+          ]
+        },
+        {
+          "center": 81,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            6,
+            82,
+            93,
+            58,
+            12,
+            100,
+            103,
+            17,
+            101,
+            54,
+            18,
+            40,
+            83,
+            73,
+            59,
+            30,
+            27,
+            7,
+            13,
+            16,
+            15,
+            42
+          ]
+        },
+        {
+          "center": 224,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            27,
+            7,
+            98,
+            48,
+            45,
+            107,
+            80,
+            67,
+            8,
+            95,
+            13,
+            16,
+            15,
+            42,
+            68,
+            5,
+            96,
+            64,
+            49,
+            34,
+            108,
+            22
+          ]
+        },
+        {
+          "center": 11,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            75,
+            1,
+            28,
+            86,
+            56,
+            31,
+            38,
+            77,
+            91,
+            10,
+            36,
+            20,
+            32,
+            85,
+            24,
+            35,
+            3,
+            88,
+            66,
+            26,
+            53,
+            105
+          ]
+        },
+        {
+          "center": 240,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            91,
+            10,
+            102,
+            55,
+            19,
+            39,
+            84,
+            74,
+            60,
+            29,
+            36,
+            20,
+            53,
+            105,
+            69,
+            4,
+            97,
+            65,
+            50,
+            33,
+            109,
+            23
+          ]
+        },
+        {
+          "center": 9,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            56,
+            31,
+            38,
+            77,
+            89,
+            79,
+            84,
+            74,
+            60,
+            29,
+            111,
+            46,
+            3,
+            88,
+            66,
+            26,
+            51,
+            44,
+            50,
+            33,
+            109,
+            23
+          ]
+        },
+        {
+          "center": 256,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            75,
+            1,
+            28,
+            86,
+            89,
+            79,
+            102,
+            55,
+            19,
+            39,
+            111,
+            46,
+            32,
+            85,
+            24,
+            35,
+            51,
+            44,
+            69,
+            4,
+            97,
+            65
+          ]
+        }
+      ],
+      "inventory": {
+        "4": 26,
+        "5": 9,
+        "7": 62,
+        "8": 78,
+        "9": 240
+      },
+      "profile": {
+        "1": 2364,
+        "2": 647,
+        "3": 297,
+        "4": 120,
+        "5": 26,
+        "8": 8
+      },
+      "section_profiles": {
+        "A": {
+          "1": 924,
+          "2": 24,
+          "4": 56
+        },
+        "B": {
+          "1": 1076,
+          "2": 511,
+          "3": 226,
+          "4": 64,
+          "5": 26
+        },
+        "cut": {
+          "8": 8
+        },
+        "ends": {
+          "1": 317,
+          "2": 74,
+          "3": 63
+        },
+        "restore": {
+          "1": 47,
+          "2": 38,
+          "3": 8
+        }
+      }
+    },
+    "gauge44": {
+      "center_paths": [
+        {
+          "center": 92,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            12,
+            100,
+            103,
+            17,
+            72,
+            94,
+            70,
+            62,
+            101,
+            54,
+            18,
+            40,
+            0,
+            57,
+            98,
+            48,
+            45,
+            107,
+            49,
+            34,
+            108,
+            22
+          ]
+        },
+        {
+          "center": 57,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            6,
+            82,
+            93,
+            58,
+            72,
+            94,
+            70,
+            62,
+            83,
+            73,
+            59,
+            30,
+            0,
+            57,
+            80,
+            67,
+            8,
+            95,
+            68,
+            5,
+            96,
+            64
+          ]
+        },
+        {
+          "center": 81,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            6,
+            82,
+            93,
+            58,
+            12,
+            100,
+            103,
+            17,
+            101,
+            54,
+            18,
+            40,
+            83,
+            73,
+            59,
+            30,
+            27,
+            7,
+            13,
+            16,
+            15,
+            42
+          ]
+        },
+        {
+          "center": 224,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            27,
+            7,
+            98,
+            48,
+            45,
+            107,
+            80,
+            67,
+            8,
+            95,
+            13,
+            16,
+            15,
+            42,
+            68,
+            5,
+            96,
+            64,
+            49,
+            34,
+            108,
+            22
+          ]
+        },
+        {
+          "center": 11,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            75,
+            1,
+            28,
+            86,
+            56,
+            31,
+            38,
+            77,
+            91,
+            10,
+            36,
+            20,
+            32,
+            85,
+            24,
+            35,
+            3,
+            88,
+            66,
+            26,
+            53,
+            105
+          ]
+        },
+        {
+          "center": 240,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            91,
+            10,
+            102,
+            55,
+            19,
+            39,
+            84,
+            74,
+            60,
+            29,
+            36,
+            20,
+            53,
+            105,
+            69,
+            4,
+            97,
+            65,
+            50,
+            33,
+            109,
+            23
+          ]
+        },
+        {
+          "center": 9,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            56,
+            31,
+            38,
+            77,
+            89,
+            79,
+            84,
+            74,
+            60,
+            29,
+            111,
+            46,
+            3,
+            88,
+            66,
+            26,
+            51,
+            44,
+            50,
+            33,
+            109,
+            23
+          ]
+        },
+        {
+          "center": 256,
+          "paid_degrees": [
+            8
+          ],
+          "reader_lines": [
+            []
+          ],
+          "start_rank": 8,
+          "target_offsets": [
+            75,
+            1,
+            28,
+            86,
+            89,
+            79,
+            102,
+            55,
+            19,
+            39,
+            111,
+            46,
+            32,
+            85,
+            24,
+            35,
+            51,
+            44,
+            69,
+            4,
+            97,
+            65
+          ]
+        }
+      ],
+      "inventory": {
+        "4": 26,
+        "5": 9,
+        "7": 62,
+        "8": 78,
+        "9": 240
+      },
+      "profile": {
+        "1": 2364,
+        "2": 647,
+        "3": 297,
+        "4": 120,
+        "5": 26,
+        "8": 8
+      },
+      "section_profiles": {
+        "A": {
+          "1": 924,
+          "2": 24,
+          "4": 56
+        },
+        "B": {
+          "1": 1076,
+          "2": 511,
+          "3": 226,
+          "4": 64,
+          "5": 26
+        },
+        "cut": {
+          "8": 8
+        },
+        "ends": {
+          "1": 317,
+          "2": 74,
+          "3": 63
+        },
+        "restore": {
+          "1": 47,
+          "2": 38,
+          "3": 8
+        }
+      }
+    }
+  },
+  "rank_mass": 4816512,
+  "roles": 276390,
+  "scope": "Complete finite words and allocation; fresh native and outer release are separate.",
+  "status": "PASS_COMPLETE_FRAME_COMPOSITION"
+}
diff --git a/research/complex-routing-leaf-fusion/RUNTIME-CHANGES.patch b/research/complex-routing-leaf-fusion/RUNTIME-CHANGES.patch
new file mode 100644
index 0000000000..0f183854cd
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/RUNTIME-CHANGES.patch
@@ -0,0 +1,34 @@
+--- pr2751/new/rebuild_borrow.py
++++ derived/new/rebuild_borrow.py
+@@ -120,6 +120,17 @@
+         kok&=[(x_['h'],x_['L']) for x_ in e0]==[(653,563)] and len(e1)==0
+         (RCP/f'ALIAS-ENUMERATION-43{wt}.json').write_text(json.dumps(dict(prelife_refit_state=dict(counts=s0,pairs=[{k_:x_[k_] for k_ in('h','L','p1','d','s','f1','width','dprof')} for x_ in e0]),shipped=dict(counts=s1,pairs=len(e1)),
+             note='counts: h_used_in_A_or_early = helpers first used before B (needs the prelude/lifted-target mechanism); the other counts are (h,L) pairs failing that condition'),indent=1)+'\n')
++    # Compose PR2733's exact five-frame refit with PR2751's twelve-source word.
++    # Gate identity and both profiles are checked; no original control is removed.
++    import copy as refit_copy
++    previous_joint=chain[-1]
++    assert previous_joint['B'][1151]==['add',393,515,1,1,[259,132,66,36,16,9]]
++    assert previous_joint['report']['local_profile']=={'1':2366,'2':646,'3':297,'4':120,'5':26,'8':8}
++    refined=refit_copy.deepcopy(previous_joint)
++    refined['B'][1151][-1]=[259,148,66,36,9]
++    refined['report']['local_profile']={'1':2364,'2':647,'3':297,'4':120,'5':26,'8':8}
++    assert refined['cleanup']==previous_joint['cleanup']
++    chain.append(refined);steps.append('joint-twelve-refit393')
+     final=json.loads(gzip.decompress(shipped.read_bytes()))
+     same=final==chain[-1]
+     # audits: the pinned pre-refit/pre-kernel word against the canonical base; every later state independently (forward + dual free-algebra replay; refit and kernel change frames inside the pinned sections)
+@@ -132,6 +143,13 @@
+     ok&=same and kok and all(x==0 for x in ps) and r.returncode==0
+     res=dict(rebuild_plus_patches_equals_shipped=same,patches=steps,kernel_edit_exact=kok,prior_state_audit_rc=ps,audit_rc=r.returncode)
+     if '--no-controls' not in sys.argv:
++        # Undo just this refit while retaining its cheaper invoice: reject it.
++        omitted=refit_copy.deepcopy(final);omitted['B'][1151][-1]=previous_joint['B'][1151][-1]
++        omitted_path=Path(tempfile.mkdtemp())/'refit393_omitted.json.gz'
++        omitted_path.write_bytes(gzip.compress(json.dumps(omitted,separators=(',',':')).encode(),mtime=0))
++        omitted_run=run_audit(omitted_path,None,omitted_path.parent/'audit.json')
++        omitted_ok=omitted_run.returncode!=0 and 'paid profile mismatch' in (omitted_run.stdout+omitted_run.stderr)
++        ok&=omitted_ok;res['refit393_omission_rejected_by_profile']=omitted_ok
+         c=subprocess.run([sys.executable,'-B',str(D/'borrow_controls.py'),str(tmp),base,str(RCP/f'CONTROLS-43{wt}.json')],capture_output=True,text=True)
+         ok&=c.returncode==0;res['controls_rc']=c.returncode
+         if lpatch:
diff --git a/research/complex-routing-leaf-fusion/SOURCES.json b/research/complex-routing-leaf-fusion/SOURCES.json
new file mode 100644
index 0000000000..71f53cf629
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/SOURCES.json
@@ -0,0 +1,31 @@
+{
+  "schema_version": 1,
+  "base_commit": "6b6b3ab304ca60eab7493e73f264fd23c146be4c",
+  "files": [
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "889b95d936746df124872133ae1e7cc339adcb92",
+      "sha256": "7d185cd8c2af35988d638d969748ad7b670f902606444dbfc748e4402c340df6"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/community-batch1099-review.md",
+      "usage": "provenance",
+      "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099",
+      "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb"
+    },
+    {
+      "path": "docs/research/research-family-status.md",
+      "usage": "provenance",
+      "git_blob": "1a2195004c5d681679279f0095b7964fb14a01e6",
+      "sha256": "c37c7e0f6a1134983990e1b3efef55e65239b38be780e8a4cc10f5aefdaf2df5"
+    }
+  ],
+  "external_dependencies": "PREDECESSOR.json and full-replay source manifests pin consumed pending evidence separately."
+}
diff --git a/research/complex-routing-leaf-fusion/TASK.json b/research/complex-routing-leaf-fusion/TASK.json
new file mode 100644
index 0000000000..779d28371a
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/TASK.json
@@ -0,0 +1,118 @@
+{
+  "schema_version": 1,
+  "task_id": "scalar-to-moment",
+  "priority_revision": 5,
+  "base_commit": "6b6b3ab304ca60eab7493e73f264fd23c146be4c",
+  "started_at_utc": "2026-10-15T20:32:53.326401+00:00",
+  "assignment": "Explicit user request: routing and leaf-cost bottleneck, aim at actual kappa improvement, current main, separate PR. No random task draw.",
+  "scope_status": "changed",
+  "actual_scope": "Compose the credited PR2733 rank-five routing frame with both complete PR2751 twelve-source words, then verify the full native/hosting/outer bill.",
+  "scope_change_reason": "The unchanged complex cap is less than one selected 1e-18 tick above the selected kappa, so improving only BIT route/leaf execution cannot meet the numerical target. PR2399 already covers conditional fast-callee substitution. The single permitted pivot targets the binding paid complex leaf profile.",
+  "declared_milestone": "Fully priced conditional kappa improvement under the pending modern outer assumptions; complete finite release passed.",
+  "changed_hypothesis": "The latest twelve-source word is allowed to use the earlier proven rank-five frame at its relocated B1151 gate; scalar chronology, dirty boundary, source recoveries and hosting remain fixed.",
+  "dependencies": {
+    "2751": "4cfbb0cc8314d7fb4e8e754545a49a42eb590a69",
+    "2733": "a63c55ff56aaa8645d64d1162d1f017b59ded42a",
+    "2753": "7dba5452a4071a856a0b11cebdcd2d3b6bcd7659",
+    "2399": "14458fda3cac4441c27980d584582ebbbb3e9233"
+  },
+  "method": "Exact symbolic operator endpoint and finite-field frame containment; exact rational completed moment only after full owner/idle and native pricing.",
+  "success_test": "Strict improvement over pinned2751 paid moment with every introduced adapter, helper, restoration, owner and leaf priced; complete independent endpoint and native release.",
+  "falsification_test": "Reject local identities that change a dirty endpoint, violate a warp/copy interface, merely move cost to cleanup, or fail the optimistic full bill.",
+  "compute_cap": "Default approximately 60 minute session, one pivot, final quarter reserved for validation; stop unsupported construction rather than manufacture peripheral PR.",
+  "overlap": {
+    "open_prs": 705,
+    "discussion_records": 1393,
+    "open_prs_at": "2026-10-15T20:28:25.864465+00:00",
+    "discussions_at": "2026-10-15T20:30:58.147156+00:00",
+    "complete_pagination": true,
+    "warnings": [],
+    "scope": "Titles/bodies and full discussion/comments/replies plus local package notes, not arbitrary unpublished code."
+  },
+  "public_coordination": "No new Discussion post authorized directly; local task card retained. Separate contribution PR explicitly authorized.",
+  "obligation_ledger": {
+    "unchanged_selected_binding": "Verified exact source-bound baseline; complex binds.",
+    "new_word": "Both complete generated words pass arbitrary-input forward/dual, frames and cleanup checks.",
+    "native_geometry": "Four complete native five-stage chains freshly passed, including changed providers and retained parent providers.",
+    "hosting": "Complete allocation regenerated unchanged; all 276390 roles, 66304 live and 66801 physical stock retained.",
+    "outer": "Exact complete strict assembly and modern outer release passed at 24 decimal endpoint; universal assumptions explicitly inherited.",
+    "physical_all_size": "Inherited conditional assumptions remain; no unconditional theorem claim."
+  },
+  "outcome": "completed",
+  "ai_assistance": "Substantial OpenAI Codex assistance including mathematical and implementation subagents.",
+  "original_card": {
+    "id": "scalar-to-moment",
+    "question": "Can one known scalar simplification be converted into an actual paid-profile improvement?",
+    "starting_points": [
+      "research/r439-bsection-stars-seed01/README.md",
+      "certificates/selected-result.json"
+    ],
+    "methods": [
+      "Derive the changed legal frame itinerary and exact child histogram.",
+      "Prove a scoped obstruction showing why that scalar gain cannot change the paid contract."
+    ],
+    "acceptance_gate": "An unchanged histogram is not a kappa gain; record any separate runtime or proof benefit explicitly.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/r439-bsection-stars-seed01/verify.py"
+      ],
+      "expected": "PASS_R439_BSECTION_STARS",
+      "inspect": "Observe that the positive control improves scalar counts while retaining the paid histogram.",
+      "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Choose one simplification and derive the complete changed frame itinerary, or prove why it cannot change the histogram.",
+    "bottleneck_link": "A legal change to the histogram, not addition count alone, is the bridge to an exponent gain.",
+    "allowed_variations": [
+      "One existing scalar simplification and one proposed frame-path change."
+    ],
+    "scope_change_triggers": [
+      "Submitting only another scalar count as completion of a paid-profile task."
+    ],
+    "overlap_terms": [
+      "scalar simplification",
+      "paid profile",
+      "R439"
+    ]
+  },
+  "author": "David Arias",
+  "budget_minutes": 60,
+  "bottleneck_link": "Replace two paid rank-one recursive transports with one rank-two transport at each of 666 complex calls; the strict concave moment decreases without increasing any helper or physical capacity.",
+  "evidence": "Complete word regeneration; source-authenticated forward/dual, frame, cleanup and 276390-role audit; independent exact endpoint/frame/moment; four fresh five-stage native chains, fresh retained parent admission and full source-bound supplier/modern outer release passed. See VALIDATION.md.",
+  "upstream_refresh": {
+    "commit": "936fac15b1b1b59dc5285c713a77f9f3c07b2906",
+    "at_utc": "2026-10-15T20:48:00Z",
+    "guidance_selected_record": "unchanged"
+  },
+  "family_expansion_decision": "Continue one explicit complete-cost composition. The independent paired-frame/commuting-gate scouts did not supply a better construction; no broad optimizer or optimality claim.",
+  "open_questions": [
+    {
+      "question": "Can a changed source or restoration boundary remove more paid recursive transport?",
+      "why_it_matters": "This composition gains only one child fusion per local call; the complex paid profile still limits the bound.",
+      "first_step": "Pin the complete new word and price a changed endpoint/read contract, including all inverse cleanup and hosting, before a broader search.",
+      "blocked_by": "Single local gate savings or an optimistic profile are insufficient without complete native and supplier admission."
+    },
+    {
+      "question": "Can the inherited routing and leaf machine contracts be discharged for the resulting finite supplier?",
+      "why_it_matters": "The numerical improvement remains a conditional theorem statement until these all-size physical obligations are proved.",
+      "first_step": "Choose a named leaf or route boundary in the pinned native/outer sources and give an actual fixed-tape implementation with a uniform cost proof.",
+      "blocked_by": "The source-level BIT caller and finite native replays do not establish the full physical multiplication machine."
+    }
+  ],
+  "stop_rule": "One fully priced composition with complete native and outer admission, or stop at the compute cap with the precise failed obligation; no peripheral fallback PR.",
+  "final_overlap": {
+    "report": "OVERLAP.json",
+    "open_prs": {
+      "fetched_at": "2026-10-15T20:48:19.409017+00:00",
+      "complete_pagination": true,
+      "records": 711
+    },
+    "discussions": {
+      "fetched_at": "2026-10-15T20:50:51.632152+00:00",
+      "complete_pagination": true,
+      "records": 1400
+    },
+    "warnings": []
+  }
+}
diff --git a/research/complex-routing-leaf-fusion/VALIDATION.md b/research/complex-routing-leaf-fusion/VALIDATION.md
new file mode 100644
index 0000000000..6f48894dc4
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/VALIDATION.md
@@ -0,0 +1,134 @@
+# Validation and execution coverage
+
+All results below concern this exact finite construction and its inherited
+conditional outer theorem. They do not establish an unconditional integer
+multiplication bound or benchmark a physical multiplication implementation.
+
+## Portable registered replay
+
+Run from the repository root with Python 3.12:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/complex-routing-leaf-fusion
+```
+
+The five commands in VERIFY.json authenticate the original PR2751 export,
+regenerate the complete words, check forward and dual arbitrary-input maps,
+all binary frames and cleanup, regenerate the complete unchanged owner
+allocation, check all 276,390 roles and derive the full paid histogram.
+The primary check retains ten mathematical rejection controls. A separate
+endpoint/frame implementation runs under `-O` with three controls. A separate
+rational moment implementation runs under `-O` with five controls. The
+packing-cap checker uses the pinned unchanged ceiling engine.
+
+`test_integrity.py` runs the public primary checker in a temporary Git-free
+export with an empty PATH, checks read-only file inventory, and rejects source
+corruption, an omitted frame edit, and a float substituted into the typed
+receipt. It also checks the primary checker's explicit refusal of `-O` and
+that generation preserves an existing output directory. These controls test
+failure modes beyond merely matching the producer's JSON.
+
+`RESULT.json` is the expected full typed primary output, not an acceptance
+flag. `FINAL-PORTABLE-REVIEW.json` in evidence binds the final portable bytes
+to the separately completed full release. The initial full-release wrapper
+ran the earlier primary checker; its native, supplier and outer inputs did
+not change when the portable primary gained the final exact CLAIM checks.
+The final portable replay reruns those strengthened checks explicitly rather
+than replacing the historical release receipt's script hash.
+
+## Complete native, supplier and outer release
+
+The full environment was Python 3.12.15 with numpy 2.5.4, scipy 1.18.1,
+sympy 1.14.0 and mpmath 1.3.0 on macOS arm64. Exact dependency pins are in
+requirements.txt. No source archive, upstream package or selected frontier
+was edited.
+
+The default public command starts with a fresh external directory:
+
+```sh
+python3 -B research/complex-routing-leaf-fusion/full_replay.py \
+  --work /tmp/FRESH-routing-leaf
+```
+
+It authenticates four pinned PR2751 composition files, authenticates all 491
+retained PR2679 source files, checks the complete overlay, applies the
+reviewable generator/runtime patch, regenerates both changed words, and
+runs native and full supplier/outer admission. No cached result from a
+different word is accepted. It retains the mathematical rejection controls.
+
+The actual public invocation in this session was:
+
+```sh
+/tmp/routing-leaf-env/bin/python -B \
+  research/complex-routing-leaf-fusion/full_replay.py \
+  --source /tmp/routing-leaf-2679/research/gmx-t74-borrow43-handoff \
+  --composition-source /tmp/routing-leaf-2751/research/t74-joint-twelve \
+  --prepared-native-cache /tmp/routing-leaf-native/native-cache \
+  --work /tmp/routing-leaf-public-replay --jobs 4
+```
+
+Before that invocation, **all four complete native five-stage chains were
+executed fresh in this session**, for the two changed providers and the two
+retained-parent providers. The retained parent admission was also freshly
+executed. Their exact commands, script and log hashes, and elapsed times
+are in evidence/FRESH-NATIVE-STAGES.json. The public wrapper explicitly reused
+that same-session complete cache after validating every file and word hash;
+see evidence/NATIVE-RECEIPT.json. This is source-bound reuse, not a claim that
+every process was rerun inside a single invocation. The one-shot default
+network-download path was not separately executed end to end.
+
+The public wrapper passed in 196.77 seconds after native preparation:
+
+- Owner reconstruction, retained-parent lift, source rebind and complete
+  allocation discovery.
+- Both exact outer-ledger implementations, union-schedule simulation and
+  all 19 retained exact evidence replays.
+- Full supplier emission, native global audit and strict modern outer
+  assembly, at the exact 24-decimal candidate lower endpoint.
+- All retained rejection controls: admission 114, BIT 12, controller 15,
+  independent owner 8, geometry 6 and strict outer 47. Regeneration also
+  rejects omission of the newly composed refit.
+
+The complete release marker is
+`PASS_T74_JOINT_TWELVE_REFIT_COLD_COMPLETE_RELEASE`.
+The exact final κ is
+`0.0017172569734670023082699999999999999999999998999999999999999999999999`.
+All 276,390 owner roles remain paid; the scalar prefix 1,443 is charged as
+2,048. The physical row coefficient 19,545 stays below its 20,161 budget.
+These are finite invoice checks, not new physical machine proofs.
+
+Compact inspectable receipts are retained under evidence/:
+
+- FULL-REPLAY-RESULT.json and ADMISSION-RESULT.json: exact sources, profile,
+  endpoint, κ, commands and stage coverage.
+- FULL-REPLAY-DERIVATION.json and REBUILD-CONTROLS.json: generator changes,
+  source rebinding and retained mathematical rejection checks.
+- RELEASE-RECEIPT.json, SUPPLIER-RESULT.json and STRICT-ASSEMBLY.json:
+  complete supplier and outer acceptance.
+- FULL-REPLAY-COMMAND.json, FRESH-NATIVE-STAGES.json and NATIVE-RECEIPT.json:
+  environment, fresh execution and explicit cache coverage.
+
+The runtime manifest is
+`1e75eabffe1ce311cc3bddc05e76118cbdedfc806200a906c57fbc5a5dd213eb`.
+It changes four files from the authenticated PR2751 overlay: two complete
+words, their provider profile, and the generator that applies and checks
+the refit. Existing mathematical checks were not removed or weakened.
+Full generated native artifacts and logs stay in the external work directory;
+committed evidence records their hashes and the command that rebuilds them.
+
+## Review and limits
+
+The final cap-loader review exercised a valid-timestamp forged bytecode cache
+in a temporary export. The original import-loader path triggered the fault;
+the corrected checker compiled authenticated source bytes and passed under
+`-I -O -B`. Equivalent binary frame bases also preserve the separate geometric
+checker's result, while the exact artifact checker correctly binds its declared
+generator output.
+
+Separate mathematical and implementation agents reviewed the frame proof,
+exact root, source binding, patches and public replay. This is AI-assisted
+review, not an independent human review or proof-assistant verification.
+The conditional physical, compiler, source-access, precision, fixed-tape,
+BIT, recurrence and analytic assumptions remain those listed in PROOF.md.
+The selected construction was not changed, so its unrelated historical cold
+replays were not rerun. The contribution adds only this scoped package.
diff --git a/research/complex-routing-leaf-fusion/VERIFY.json b/research/complex-routing-leaf-fusion/VERIFY.json
new file mode 100644
index 0000000000..37b5a56c9a
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/VERIFY.json
@@ -0,0 +1,62 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 240,
+      "checks": "Authenticate predecessor before import; regenerate both complete words; literal forward/dual, frames, cleanup, physical owner allocation and exact full-profile delta; ten mathematical failure controls and typed receipt."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/independent_check.py"
+      ],
+      "timeout_seconds": 240,
+      "checks": "Separately implemented full free-operator endpoint and Gaussian-elimination frame audit, optimized execution and three failure controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/exact_moment_checker.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Independent rational atanh/Taylor adjacent root certificate and five pricing/normalization controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/test_integrity.py"
+      ],
+      "timeout_seconds": 300,
+      "checks": "Git-free public replay, read-only source inventory, source/candidate/typed-receipt faults, optimized primary refusal and no-overwrite generation."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/packing_cap.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Pinned exact ceiling engine, fixed-word coverage identity, relaxed rank51 cap and fraction of the cap realized."
+    }
+  ]
+}
diff --git a/research/complex-routing-leaf-fusion/derive_runtime.py b/research/complex-routing-leaf-fusion/derive_runtime.py
new file mode 100644
index 0000000000..d5142a7c47
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/derive_runtime.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Apply the credited PR2733 frame refit to an authenticated PR2751 runtime.
+The predecessor is copied before this function runs. Its four changed paths,
+exact preimages, and complete final manifest are checked; all original audits
+and mutations remain in the runtime, with one new omission control added.
+"""
+import json,gzip,hashlib,shutil
+from pathlib import Path
+
+REBUILD_INSERT="    # Compose PR2733's exact five-frame refit with PR2751's twelve-source word.\n    # Gate identity and both profiles are checked; no original control is removed.\n    import copy as refit_copy\n    previous_joint=chain[-1]\n    assert previous_joint['B'][1151]==['add',393,515,1,1,[259,132,66,36,16,9]]\n    assert previous_joint['report']['local_profile']=={'1':2366,'2':646,'3':297,'4':120,'5':26,'8':8}\n    refined=refit_copy.deepcopy(previous_joint)\n    refined['B'][1151][-1]=[259,148,66,36,9]\n    refined['report']['local_profile']={'1':2364,'2':647,'3':297,'4':120,'5':26,'8':8}\n    assert refined['cleanup']==previous_joint['cleanup']\n    chain.append(refined);steps.append('joint-twelve-refit393')\n"
+REBUILD_CONTROL="        # Undo just this refit while retaining its cheaper invoice: reject it.\n        omitted=refit_copy.deepcopy(final);omitted['B'][1151][-1]=previous_joint['B'][1151][-1]\n        omitted_path=Path(tempfile.mkdtemp())/'refit393_omitted.json.gz'\n        omitted_path.write_bytes(gzip.compress(json.dumps(omitted,separators=(',',':')).encode(),mtime=0))\n        omitted_run=run_audit(omitted_path,None,omitted_path.parent/'audit.json')\n        omitted_ok=omitted_run.returncode!=0 and 'paid profile mismatch' in (omitted_run.stdout+omitted_run.stderr)\n        ok&=omitted_ok;res['refit393_omission_rejected_by_profile']=omitted_ok\n"
+
+def derive_runtime(D, C):
+    def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest()
+    orig=json.loads((D/'MANIFEST.json').read_text());patch=json.loads((C/'PATCH.json').read_text())
+    for tag in ['base','extra']:
+     src=C/'inputs'/f'WORD-{tag}.json.gz';dst=D/f'new/borrow/words/BORROW-WORD-43{tag}.json.gz'
+     assert sha(dst)==patch['providers'][tag]['source_sha256'];shutil.copy2(src,dst)
+    p=D/'new/BORROW-PROVIDERS.json';j=json.loads(p.read_text())
+    for v in j.values():
+     assert v['actual_paid_profile']=={'1':2366,'2':646,'3':297,'4':120,'5':26,'8':8}
+     v['actual_paid_profile']={'1':2364,'2':647,'3':297,'4':120,'5':26,'8':8}
+    p.write_text(json.dumps(j,sort_keys=True,indent=2)+'\n')
+    p=D/'new/rebuild_borrow.py';s=p.read_text();old='    final=json.loads(gzip.decompress(shipped.read_bytes()))\n';assert s.count(old)==1
+    new=REBUILD_INSERT+old
+    s=s.replace(old,new)
+    old="    if '--no-controls' not in sys.argv:\n";assert s.count(old)==1
+    new=old+REBUILD_CONTROL
+    s=s.replace(old,new);p.write_text(s)
+    # Exclude only root manifest; nested manifests remain authenticated.
+    new={p.relative_to(D).as_posix():sha(p) for p in sorted(D.rglob('*')) if p.is_file() and p!=D/'MANIFEST.json'}
+    assert set(new)==set(orig)
+    (D/'MANIFEST.json').write_text(json.dumps(new,sort_keys=True,indent=2)+'\n')
+    changes={n:{'before':orig[n],'after':h} for n,h in new.items() if h!=orig[n]}
+    return changes
diff --git a/research/complex-routing-leaf-fusion/evidence/ADMISSION-RESULT.json b/research/complex-routing-leaf-fusion/evidence/ADMISSION-RESULT.json
new file mode 100644
index 0000000000..e0ce90caca
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/evidence/ADMISSION-RESULT.json
@@ -0,0 +1,168 @@
+{
+  "complex_lower": "171725697346700230827/100000000000000000000000",
+  "fill_sha256": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1",
+  "gain": "115387118575970161/1000000000000000000000000",
+  "kappa": "17172569734670023082699999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000",
+  "kappa_decimal": "0.0017172569734670023082699999999999999999999998999999999999999999999999",
+  "native_receipt_sha256": "a071e074d35f4182060f39a64616b63c4fb734f0cdd9bce451fdbee60bfc1eee",
+  "order_sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7",
+  "package_manifest_sha256": "82a1e95d70100a690834c88cdf6bfc0d161894f6823904aebbe04d65e5e7b05d",
+  "patches": [
+    {
+      "after_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b",
+      "before_sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af",
+      "path": "new/rebind.py",
+      "replacements": [
+        [
+          "physical=spec['expected']['live'] + 8 + R + 2)",
+          "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))"
+        ]
+      ]
+    },
+    {
+      "after_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce",
+      "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800",
+      "path": "verify_release.py",
+      "replacements": [
+        [
+          "Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)",
+          "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))"
+        ],
+        [
+          "epsilon=1-(1025/1024)e-3080",
+          "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}"
+        ],
+        [
+          "at the one 3000-digit rejection call",
+          "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call"
+        ]
+      ]
+    }
+  ],
+  "profile": {
+    "1": 1591740,
+    "2": 430902,
+    "3": 204396,
+    "32": 1,
+    "4": 79920,
+    "48": 26558,
+    "5": 22532,
+    "8": 5328
+  },
+  "release_receipt_sha256": "5be2a287e2ec842152915d78898e767645f7ee5ebd002db6fd6b290de943afb7",
+  "scope": "Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.",
+  "source_commit": "local-joint12-refit393",
+  "source_manifest_sha256": "1e75eabffe1ce311cc3bddc05e76118cbdedfc806200a906c57fbc5a5dd213eb",
+  "stages": [
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/private/tmp/routing-leaf-public-replay/admission/package/reconstruct.py",
+        "--out",
+        "/private/tmp/routing-leaf-public-replay/admission/owners"
+      ],
+      "exit_code": 0,
+      "log_sha256": "590db66077dbde02b0f3bf2d5d0e0b44ce5e9e435874be38e5ceaa753458684e",
+      "name": "owners",
+      "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa",
+      "seconds": 2.2994952089793514
+    },
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/private/tmp/routing-leaf-public-replay/admission/package/lift_parent.py",
+        "--owners",
+        "/private/tmp/routing-leaf-public-replay/admission/owners",
+        "--out",
+        "/private/tmp/routing-leaf-public-replay/admission/parent-data"
+      ],
+      "exit_code": 0,
+      "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4",
+      "name": "parent-lift",
+      "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e",
+      "seconds": 4.277545499993721
+    },
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/private/tmp/routing-leaf-public-replay/admission/package/new/rebind.py",
+        "/private/tmp/routing-leaf-public-replay/admission/package",
+        "/private/tmp/routing-leaf-public-replay/native-cache/80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local",
+        "/private/tmp/routing-leaf-public-replay/native-cache/88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/local",
+        "/private/tmp/routing-leaf-public-replay/admission/rebound"
+      ],
+      "exit_code": 0,
+      "log_sha256": "d5992c9e0b86c0d1a4dd774b488fdf0b7f910bfec71bc14394d7409c42948cd0",
+      "name": "rebind",
+      "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b",
+      "seconds": 0.47542187498766
+    },
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/private/tmp/routing-leaf-public-replay/admission/layout/packing74/replay.py",
+        "--data",
+        "/private/tmp/routing-leaf-public-replay/admission/layout/packing74/candidate",
+        "--work",
+        "/private/tmp/routing-leaf-public-replay/admission/discovery",
+        "--local",
+        "/private/tmp/routing-leaf-public-replay/native-cache/80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local",
+        "--discover"
+      ],
+      "exit_code": 0,
+      "log_sha256": "998977e5f656f56fd4c630afeab1a1e9be55cc0367d1f53cdfe8bd9493e90047",
+      "name": "discovery",
+      "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955",
+      "seconds": 39.46016516702366
+    },
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/private/tmp/routing-leaf-public-replay/admission/package/outer/check_ledger.py"
+      ],
+      "exit_code": 0,
+      "log_sha256": "936eea82cd97b9ee7f98839b699a538be7b78031475a547a135e7bffd8cb064f",
+      "name": "outer-check_ledger.py",
+      "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e",
+      "seconds": 0.02458912500878796
+    },
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/private/tmp/routing-leaf-public-replay/admission/package/outer/independent_check.py"
+      ],
+      "exit_code": 0,
+      "log_sha256": "3714958add69d46de94eb9823a21957c7d9ae5b2618daa6417e14bca5fb24d9e",
+      "name": "outer-independent_check.py",
+      "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7",
+      "seconds": 0.018336249981075525
+    },
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/private/tmp/routing-leaf-public-replay/admission/package/verify_release.py",
+        "--main",
+        "/private/tmp",
+        "--work",
+        "/private/tmp/routing-leaf-public-replay/admission/release",
+        "--native-cache",
+        "/private/tmp/routing-leaf-public-replay/native-cache",
+        "--jobs",
+        "4"
+      ],
+      "exit_code": 0,
+      "log_sha256": "88c23365b80122abdfd106dd45f1405efbbf1d94cf4dd30a70691e818ac6fa37",
+      "name": "release",
+      "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce",
+      "seconds": 145.84062241701758
+    }
+  ],
+  "status": "PASS_COMPOSED_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE"
+}
diff --git a/research/complex-routing-leaf-fusion/evidence/FINAL-PORTABLE-REVIEW.json b/research/complex-routing-leaf-fusion/evidence/FINAL-PORTABLE-REVIEW.json
new file mode 100644
index 0000000000..37f0f227bf
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/evidence/FINAL-PORTABLE-REVIEW.json
@@ -0,0 +1,54 @@
+{
+  "claim_complex_lower": "0.001717256973467002308270",
+  "claim_kappa": "17172569734670023082699999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000",
+  "command": [
+    "/tmp/routing-leaf-env/bin/python",
+    "-B",
+    "/Users/david/.codex/worktrees/routing-leaf-cost/interger-mult-bounds/research/complex-routing-leaf-fusion/verify.py"
+  ],
+  "complete_release_sha256": "767b9e07c8a1114f03b2a59974c88194c53a56184dd2d39ac7d5b333f80cf01b",
+  "exit_code": 0,
+  "files_sha256": {
+    "CLAIM.json": "399e20ffb8bac62363f7d48c59021d5afef5f62bb6c51986ca847b02ec1e73a8",
+    "FULL-REPLAY-CHANGES.patch": "dfe4503d026d34d9a8c9769ea4ee9ed486c3ad2d05815bc110129c278ef26ae4",
+    "FULL-REPLAY-PINS.json": "c61cbbc0c323d13af87e7cb32800877aba5e5f654b7bd86d00a5edd773620cbd",
+    "PREDECESSOR.json": "876bd508cd260dc2819ffc96dd7a5f60d8dd905693918fb71a7d7ba5f73d622a",
+    "PROFILE.json": "9fde4722b0064c72aa0537b96a0a050143006e149f8c943949d1be452a0d5195",
+    "RESULT.json": "fc76a920e7e85ed196fadf38645277e2d4b8b3f1476a99d8e8af73ac59c193d6",
+    "RUNTIME-CHANGES.patch": "5b0e021322a58583095d136909e2a3b0bdb8a149115dc0498df7330e68c87cfe",
+    "derive_runtime.py": "23b0ee70f1408bae8d16bc5715b72aaa29f500b83618d7574d2f8b7fd8c454df",
+    "full_replay.py": "a6467d6eb8d1b66ed0c4bcfd837d18b0f400e932720ccfaa0719a91618112756",
+    "generate.py": "86f3bb4793b484e86e0c054848b3bf7ef3c6038e10127b8326c3227dc51a1ffa",
+    "inputs/WORD-base.json.gz": "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790",
+    "inputs/WORD-extra.json.gz": "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6",
+    "requirements.txt": "f95b588f39c53b58fa36c3b65b65cc770e3a051a6a12555a9188808e771d1d13",
+    "vendor/pr2751/CLAIM.json": "78e99222196fca8b74a895b9e2db40a0e4afd1d69cd4fb52f38bfb157bac2438",
+    "vendor/pr2751/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+    "vendor/pr2751/PROFILE.json": "36e76f32570bac074cf70a6076b7c54e6d5b0fc3b505f404bc58fd02abf7967d",
+    "vendor/pr2751/PROOF.md": "6ecefda5d853e3ede1ee06aab08de24dfde960d98178a71844340ed86ae0d9b9",
+    "vendor/pr2751/README.md": "d8501fbc11b3dc87fc618122c83f10a56cd4457c7abdab792e2f9506bab4666e",
+    "vendor/pr2751/SOURCE-NOTICE": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420",
+    "vendor/pr2751/composition.py": "f202f8ce9730b778c9ee1213d63d444d117df5ff7d47933037a924723a37e3f4",
+    "vendor/pr2751/exact_moment.py": "f170292f7983773d4f142afdac4677c1615fb7b781dbabf395200aea886dcade",
+    "vendor/pr2751/independent_local.py": "ee1faab70095fa312fc61d375ddf015b76104cb1a542ae7876a149e7999faa20",
+    "vendor/pr2751/independent_owners.py": "4e0785a659b4a6516581f15476c054de1581aa4b3763ce45b1fd20e45c2bb5af",
+    "vendor/pr2751/inputs/DISPATCH.json.gz": "14fe756dcac93a0f3b2b7f38ba7b998dec89d56d5171b691af4fae45e5d83d11",
+    "vendor/pr2751/inputs/FILL.json.gz": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1",
+    "vendor/pr2751/inputs/GLOBAL-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e",
+    "vendor/pr2751/inputs/ORDER.json": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7",
+    "vendor/pr2751/inputs/PLAN.json.gz": "afb3c5c8134fc2cfce0b50a21758490c225574994b2c3c5161e53e2355acc6fa",
+    "vendor/pr2751/inputs/PROVIDERS.json": "ec4802a33c0e1d41369da77b19b9b783dc812b2d3246e096fee13d29f226dd66",
+    "vendor/pr2751/inputs/SOURCE-FILL.json.gz": "dc96598624ee49d368e1130ec2148734be0bbc68402cc181e1f02ae9ca8e3d06",
+    "vendor/pr2751/inputs/SOURCE-ORDER.json": "aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667",
+    "vendor/pr2751/inputs/SOURCE-PROVIDERS.json": "d8d90c3b906c66874f9fe07df67be24e53f3f3f9146565b56a272548108327b7",
+    "vendor/pr2751/inputs/WORD-base.json.gz": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a",
+    "vendor/pr2751/inputs/WORD-extra.json.gz": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127",
+    "verify.py": "73b8d8174a28b272b8fbb0427835a127e53d1690f8bed89bc2862f9149b9dbec"
+  },
+  "log_sha256": "fc76a920e7e85ed196fadf38645277e2d4b8b3f1476a99d8e8af73ac59c193d6",
+  "native_receipt_sha256": "a071e074d35f4182060f39a64616b63c4fb734f0cdd9bce451fdbee60bfc1eee",
+  "python": "3.12.15 (main, Oct 14 2026, 00:55:37) [Clang 23.1.3 ]",
+  "scope": "Final portable checker and all its source/data inputs rerun after final source freeze. Exact endpoint, kappa and complete profile agree with the full native/strict/outer release. Documentation and separate packing-cap evidence are not part of this replay.",
+  "seconds": 3.5806418749853037,
+  "status": "PASS_FINAL_PORTABLE_REVIEW_BOUND_TO_COMPLETE_RELEASE"
+}
diff --git a/research/complex-routing-leaf-fusion/evidence/FRESH-NATIVE-STAGES.json b/research/complex-routing-leaf-fusion/evidence/FRESH-NATIVE-STAGES.json
new file mode 100644
index 0000000000..2f36275889
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/evidence/FRESH-NATIVE-STAGES.json
@@ -0,0 +1,76 @@
+[
+  {
+    "command": [
+      "/tmp/routing-leaf-env/bin/python",
+      "-B",
+      "/tmp/routing-leaf-native/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py",
+      "/tmp/routing-leaf-derived/vendor/pr1297/extra-word.json.gz",
+      "/tmp/routing-leaf-native/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905"
+    ],
+    "exit_code": 0,
+    "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514",
+    "name": "native-retained-extra",
+    "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6",
+    "seconds": 105.99251187502523
+  },
+  {
+    "command": [
+      "/tmp/routing-leaf-env/bin/python",
+      "-B",
+      "/tmp/routing-leaf-native/retained-layout/joint1148-round45/source/research/k8-eight-ends/replay_native.py",
+      "/tmp/routing-leaf-derived/vendor/pr1297/gauge44-word.json.gz",
+      "/tmp/routing-leaf-native/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e"
+    ],
+    "exit_code": 0,
+    "log_sha256": "5ca9f310247cb601c905ff30597baa4634847395d7826e9ab926a9876ced2514",
+    "name": "native-retained-base",
+    "script_sha256": "1fb596fbafdb19140f483cd34db2994c571e3b962e33b8ea9b3ddc486e37def6",
+    "seconds": 106.26472070798627
+  },
+  {
+    "command": [
+      "/tmp/routing-leaf-env/bin/python",
+      "-B",
+      "/tmp/routing-leaf-derived/new/run_native_borrow.py",
+      "/tmp/routing-leaf-derived/new/borrow/words/BORROW-WORD-43extra.json.gz",
+      "/tmp/routing-leaf-native/native-cache/88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6"
+    ],
+    "exit_code": 0,
+    "log_sha256": "3dc4d50086fe068064ec1db7a7963ff2506877cd029f7332fe1667c710388282",
+    "name": "native-extra",
+    "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8",
+    "seconds": 126.61621729200124
+  },
+  {
+    "command": [
+      "/tmp/routing-leaf-env/bin/python",
+      "-B",
+      "/tmp/routing-leaf-derived/new/run_native_borrow.py",
+      "/tmp/routing-leaf-derived/new/borrow/words/BORROW-WORD-43base.json.gz",
+      "/tmp/routing-leaf-native/native-cache/80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790"
+    ],
+    "exit_code": 0,
+    "log_sha256": "6d3409e43df37a40b88123a83715212ce79988caf69466e0b088e7db941a591c",
+    "name": "native-base",
+    "script_sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8",
+    "seconds": 127.57507812499534
+  },
+  {
+    "command": [
+      "/tmp/routing-leaf-env/bin/python",
+      "-B",
+      "/tmp/routing-leaf-derived/vendor/pr1297/verify.py",
+      "--work",
+      "/tmp/routing-leaf-native/retained-parent",
+      "--base-native-from",
+      "/tmp/routing-leaf-native/native-cache/e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e",
+      "--extra-native-from",
+      "/tmp/routing-leaf-native/native-cache/7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905"
+    ],
+    "exit_code": 0,
+    "log_sha256": "cdf3315263df90f032f2b0ac822507c6fbee03f980edd8083513f229fb3c1b24",
+    "name": "retained-parent",
+    "script_sha256": "358ad8dfd967f4fd69a0cc298eae3508ad8b57b1e419ebaa0d621e199f534345",
+    "seconds": 74.47712083300576
+  }
+]
diff --git a/research/complex-routing-leaf-fusion/evidence/FULL-REPLAY-COMMAND.json b/research/complex-routing-leaf-fusion/evidence/FULL-REPLAY-COMMAND.json
new file mode 100644
index 0000000000..c94659725e
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/evidence/FULL-REPLAY-COMMAND.json
@@ -0,0 +1,20 @@
+{
+  "command": [
+    "/tmp/routing-leaf-env/bin/python",
+    "-B",
+    "/Users/david/.codex/worktrees/routing-leaf-cost/interger-mult-bounds/research/complex-routing-leaf-fusion/full_replay.py",
+    "--source",
+    "/tmp/routing-leaf-2679/research/gmx-t74-borrow43-handoff",
+    "--composition-source",
+    "/tmp/routing-leaf-2751/research/t74-joint-twelve",
+    "--prepared-native-cache",
+    "/tmp/routing-leaf-native/native-cache",
+    "--work",
+    "/tmp/routing-leaf-public-replay",
+    "--jobs",
+    "4"
+  ],
+  "fresh_native_stages": "FRESH-NATIVE-STAGES.json",
+  "native_cache_use": "The four provider chains and retained parent admission were freshly executed in this session. This public replay explicitly reuses their complete hash-authenticated cache. The default command without --prepared-native-cache regenerates them.",
+  "result": "FULL-REPLAY-RESULT.json"
+}
diff --git a/research/complex-routing-leaf-fusion/evidence/FULL-REPLAY-DERIVATION.json b/research/complex-routing-leaf-fusion/evidence/FULL-REPLAY-DERIVATION.json
new file mode 100644
index 0000000000..d8de1eaa9f
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/evidence/FULL-REPLAY-DERIVATION.json
@@ -0,0 +1,18 @@
+{
+  "new/BORROW-PROVIDERS.json": {
+    "after": "edc688ebc44e64e4e285160265e3cbc1c5d2f42fd275d27039e58c9250c388a6",
+    "before": "ec4802a33c0e1d41369da77b19b9b783dc812b2d3246e096fee13d29f226dd66"
+  },
+  "new/borrow/words/BORROW-WORD-43base.json.gz": {
+    "after": "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790",
+    "before": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a"
+  },
+  "new/borrow/words/BORROW-WORD-43extra.json.gz": {
+    "after": "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6",
+    "before": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127"
+  },
+  "new/rebuild_borrow.py": {
+    "after": "12ddbb4ee0e993ebeb4c998e6f011369821c1122daadd3de3a60f9f07aaa406b",
+    "before": "2fa4035394be981d287a6e106a8af05d614704e6814fcebb9274b072a5cd03e2"
+  }
+}
diff --git a/research/complex-routing-leaf-fusion/evidence/FULL-REPLAY-RESULT.json b/research/complex-routing-leaf-fusion/evidence/FULL-REPLAY-RESULT.json
new file mode 100644
index 0000000000..4a7536a09a
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/evidence/FULL-REPLAY-RESULT.json
@@ -0,0 +1,221 @@
+{
+  "cold_seconds": 196.7701440419769,
+  "cold_stages": [
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/Users/david/.codex/worktrees/routing-leaf-cost/interger-mult-bounds/research/complex-routing-leaf-fusion/verify.py"
+      ],
+      "exit_code": 0,
+      "log_sha256": "b8bfda57cfc8b10f597074abc04ca83d4a0ed4f13121ad51d43e1268e6f62db5",
+      "name": "literal-review",
+      "script_sha256": "f7288b8b70f9c12c4e6b3caa416ae3400441ef72d22904e6eaa9d104d4177210",
+      "seconds": 3.6113045420206618
+    },
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/private/tmp/routing-leaf-public-replay/admit.py",
+        "--source",
+        "/private/tmp/routing-leaf-public-replay/source",
+        "--fill",
+        "/Users/david/.codex/worktrees/routing-leaf-cost/interger-mult-bounds/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/FILL.json.gz",
+        "--order",
+        "/Users/david/.codex/worktrees/routing-leaf-cost/interger-mult-bounds/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/ORDER.json",
+        "--native-cache",
+        "/private/tmp/routing-leaf-public-replay/native-cache",
+        "--native-receipt",
+        "/private/tmp/routing-leaf-public-replay/NATIVE-RECEIPT.json",
+        "--work",
+        "/private/tmp/routing-leaf-public-replay/admission",
+        "--jobs",
+        "4"
+      ],
+      "exit_code": 0,
+      "log_sha256": "6ed027afce19281691d838306c61e0cbc1061971eb4f73701d5bfb31132a6f82",
+      "name": "complete-admission",
+      "script_sha256": "5e4b1908f04b035e1e3f07a0d4aa09d7743c608141fb1368ffe748bbb224ef46",
+      "seconds": 192.91108745901147
+    }
+  ],
+  "complex_lower": "171725697346700230827/100000000000000000000000",
+  "environment": {
+    "executable": "/tmp/routing-leaf-env/bin/python",
+    "python": "3.12.15",
+    "versions": {
+      "mpmath": "1.3.0",
+      "numpy": "2.5.4",
+      "scipy": "1.18.1",
+      "sympy": "1.14.0"
+    }
+  },
+  "explicit_native_cache_reuse": true,
+  "fill_sha256": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1",
+  "gain": "115387118575970161/1000000000000000000000000",
+  "kappa": "17172569734670023082699999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000",
+  "kappa_decimal": "0.0017172569734670023082699999999999999999999998999999999999999999999999",
+  "native_receipt_sha256": "a071e074d35f4182060f39a64616b63c4fb734f0cdd9bce451fdbee60bfc1eee",
+  "order_sha256": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7",
+  "package_manifest_sha256": "82a1e95d70100a690834c88cdf6bfc0d161894f6823904aebbe04d65e5e7b05d",
+  "patches": [
+    {
+      "after_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b",
+      "before_sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af",
+      "path": "new/rebind.py",
+      "replacements": [
+        [
+          "physical=spec['expected']['live'] + 8 + R + 2)",
+          "physical=spec['expected']['live'] + 8 + R + 2 + max(len(rd(d / 'CANONICAL-WORD.json.gz').get('zero_buffers', [])) for d in locs.values()))"
+        ]
+      ]
+    },
+    {
+      "after_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce",
+      "before_sha256": "245b244984355da7a43d6b89359c6d4cd723bc29abccd6f1788fefe044385800",
+      "path": "verify_release.py",
+      "replacements": [
+        [
+          "Fraction(1, 10 ** 3046) - Fraction(1, 10 ** 3022)",
+          "Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 46)) - Fraction(1, 10 ** (spec['outer_refinement']['endpoint_digits'] + 22))"
+        ],
+        [
+          "epsilon=1-(1025/1024)e-3080",
+          "epsilon=1-(1025/1024)e-{spec['outer_refinement']['endpoint_digits']+80}"
+        ],
+        [
+          "at the one 3000-digit rejection call",
+          "at the one {spec['outer_refinement']['endpoint_digits']}-digit rejection call"
+        ]
+      ]
+    }
+  ],
+  "profile": {
+    "1": 1591740,
+    "2": 430902,
+    "3": 204396,
+    "32": 1,
+    "4": 79920,
+    "48": 26558,
+    "5": 22532,
+    "8": 5328
+  },
+  "release_receipt_sha256": "5be2a287e2ec842152915d78898e767645f7ee5ebd002db6fd6b290de943afb7",
+  "scope": "Conditional finite construction and modern outer arithmetic. Exact inherited theorem obligations remain. Both native providers explicitly reused from authenticated fresh five-stage runs.",
+  "source_commit": "local-joint12-refit393",
+  "source_files_sha256": "4191b13800d48048f8b3b736c888040445d02c31ee7756915c21e011da62f5a1",
+  "source_manifest_sha256": "1e75eabffe1ce311cc3bddc05e76118cbdedfc806200a906c57fbc5a5dd213eb",
+  "stages": [
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/private/tmp/routing-leaf-public-replay/admission/package/reconstruct.py",
+        "--out",
+        "/private/tmp/routing-leaf-public-replay/admission/owners"
+      ],
+      "exit_code": 0,
+      "log_sha256": "590db66077dbde02b0f3bf2d5d0e0b44ce5e9e435874be38e5ceaa753458684e",
+      "name": "owners",
+      "script_sha256": "1f1145b4c5aab399c69ee5f90b735367bd0bd01a8f0970dce443d22c1e03d9aa",
+      "seconds": 2.2994952089793514
+    },
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/private/tmp/routing-leaf-public-replay/admission/package/lift_parent.py",
+        "--owners",
+        "/private/tmp/routing-leaf-public-replay/admission/owners",
+        "--out",
+        "/private/tmp/routing-leaf-public-replay/admission/parent-data"
+      ],
+      "exit_code": 0,
+      "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4",
+      "name": "parent-lift",
+      "script_sha256": "525ca25a4530cee9e645a9e9078227f91f48c3d43d218583f2bb1cf9bded8a6e",
+      "seconds": 4.277545499993721
+    },
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/private/tmp/routing-leaf-public-replay/admission/package/new/rebind.py",
+        "/private/tmp/routing-leaf-public-replay/admission/package",
+        "/private/tmp/routing-leaf-public-replay/native-cache/80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local",
+        "/private/tmp/routing-leaf-public-replay/native-cache/88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/local",
+        "/private/tmp/routing-leaf-public-replay/admission/rebound"
+      ],
+      "exit_code": 0,
+      "log_sha256": "d5992c9e0b86c0d1a4dd774b488fdf0b7f910bfec71bc14394d7409c42948cd0",
+      "name": "rebind",
+      "script_sha256": "52f8b4cec2dab69cbe590e1fd0f7a68e1b35de5a540bd22fd2adfce07a92b46b",
+      "seconds": 0.47542187498766
+    },
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/private/tmp/routing-leaf-public-replay/admission/layout/packing74/replay.py",
+        "--data",
+        "/private/tmp/routing-leaf-public-replay/admission/layout/packing74/candidate",
+        "--work",
+        "/private/tmp/routing-leaf-public-replay/admission/discovery",
+        "--local",
+        "/private/tmp/routing-leaf-public-replay/native-cache/80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local",
+        "--discover"
+      ],
+      "exit_code": 0,
+      "log_sha256": "998977e5f656f56fd4c630afeab1a1e9be55cc0367d1f53cdfe8bd9493e90047",
+      "name": "discovery",
+      "script_sha256": "3ec4330ede0db3c6daa453b0366817be9435c85c8c3213a0c35c442c96c1a955",
+      "seconds": 39.46016516702366
+    },
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/private/tmp/routing-leaf-public-replay/admission/package/outer/check_ledger.py"
+      ],
+      "exit_code": 0,
+      "log_sha256": "936eea82cd97b9ee7f98839b699a538be7b78031475a547a135e7bffd8cb064f",
+      "name": "outer-check_ledger.py",
+      "script_sha256": "9e12909c73d3b3a31a45d801ae76c034510d6306400412e474df79bc4f1dc67e",
+      "seconds": 0.02458912500878796
+    },
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/private/tmp/routing-leaf-public-replay/admission/package/outer/independent_check.py"
+      ],
+      "exit_code": 0,
+      "log_sha256": "3714958add69d46de94eb9823a21957c7d9ae5b2618daa6417e14bca5fb24d9e",
+      "name": "outer-independent_check.py",
+      "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7",
+      "seconds": 0.018336249981075525
+    },
+    {
+      "command": [
+        "/tmp/routing-leaf-env/bin/python",
+        "-B",
+        "/private/tmp/routing-leaf-public-replay/admission/package/verify_release.py",
+        "--main",
+        "/private/tmp",
+        "--work",
+        "/private/tmp/routing-leaf-public-replay/admission/release",
+        "--native-cache",
+        "/private/tmp/routing-leaf-public-replay/native-cache",
+        "--jobs",
+        "4"
+      ],
+      "exit_code": 0,
+      "log_sha256": "88c23365b80122abdfd106dd45f1405efbbf1d94cf4dd30a70691e818ac6fa37",
+      "name": "release",
+      "script_sha256": "ebc59b6af8b8eef9390715b15848a504498fba26e69840741afd0a31051711ce",
+      "seconds": 145.84062241701758
+    }
+  ],
+  "status": "PASS_T74_JOINT_TWELVE_REFIT_COLD_COMPLETE_RELEASE"
+}
diff --git a/research/complex-routing-leaf-fusion/evidence/NATIVE-RECEIPT.json b/research/complex-routing-leaf-fusion/evidence/NATIVE-RECEIPT.json
new file mode 100644
index 0000000000..171bab9878
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/evidence/NATIVE-RECEIPT.json
@@ -0,0 +1,127 @@
+{
+  "cache_files": {
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/CACHE.json": "78adaa6d6e7ddff01cf3d1ea76bace5f1240d61ed35a936f4d5945817057b6c8",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/STEPS.json": "1de8c781997ccef8e56ae1672b19636174ae64e0709f9cef698b2fbad2766571",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/ledgers.log": "2f40f12c67d436dde2ea415ea3e033ec60a9d43cc71427dcc1bf987962da34d7",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local-replay.log": "dd643a58258431c3b07d3b06d9060c49677fa23b4fafc9f10988ed1f6867bd9a",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CANONICAL-WORD.json.gz": "e38e2136e5a4a75bb843735a59158543eff04bd06384d73752b220d6938af73d",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-RECIPES.json": "cf410b60c9e3d9e7f99d94b5b28c4e3ae61c4b32892df4e03257b60fe5a37b02",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/CLIFFORD-REVIEW.json": "ea2a1672c68023337a99a01c78d75f7d05b51688d67280d609281171a7325768",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/FULL-WORD.json.gz": "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/INDEPENDENT-LOCAL-REPLAY.json": "39874d664110d1ee85da901e2cd56e7cd0f27e0153813d4608c98122a90815da",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-CHECKS.json": "ef01cb5b6d1779518282c69a20d1dbcdbf57cb89ba616e2101bb209b37d80286",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/LOCAL-PROGRAMS.json.gz": "26c2fd119125bfca1ae655bb8a57df064da250370e60a85e1e8e8c4649e6a904",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/RESIDUAL-ADAPTERS.json": "0102fa3b62b095c14a34d5af95cc321db38e5f5e03a4f226828e8ebf6fdbe20b",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/SCALAR-FRAME-AUDIT.json": "ebb3cb16bb88df752a9431bd5c367056e50e1ace9324d81d93df030f71d40561",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/local/WRAPPER-CHECKS.json": "84a5bc26df5fb70dc12852a868962bcdfad3b85d85408edfd1f343e898a78c0e",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/native.log": "33b15d037b7fb0d9d8abdb9eb0068406e88a1e84f5f6e8900aca09b03a0a146e",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/phases.log": "85878ee373a2b543bcb51dd5d4000bb862e4a4cc3bec7abda628b045e5d14388",
+    "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/CACHE.json": "82bc0a753a424c73b8524ef7416bdccd2ac281a6a8db2db15a4ada293eccbbf0",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/STEPS.json": "d7c2a459a6120156d67f8cff70c859501fbe7d73f987ec817b03bc3ce39f2960",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/ledgers.log": "2d9134d3c2bb3e5197292a484f30e7fd58e435bdbc414324ba2f3f830d664ef7",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local/CANONICAL-WORD.json.gz": "538e885dbb75d2a184982a2af5b70efc7c2792d3eeb6539fe228a22dee31fb3d",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local/CLIFFORD-RECIPES.json": "49437c6094c4393bee059a5cd21548b912fa35671903a99952458200d7c10db9",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local/CLIFFORD-REVIEW.json": "b3041bd059b569a1001b765339e61c9148126204bf5d1c49b40d0ff6ebae3597",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local/FULL-WORD.json.gz": "9afa050cf437b17c347ca21601bdfde1b48914ca223a6ebf2c24c0fc50d478f3",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local/INDEPENDENT-LOCAL-REPLAY.json": "6077842f1c26a6d0f256890f8be0451fd0fd5111bbdfa60618a2521eabb472c0",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local/LOCAL-CHECKS.json": "c23a2cde2617dd37c6f2097a43c4fef7cf6571964b3f1f460feadc176816a5ab",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local/LOCAL-PROGRAMS.json.gz": "03513f863ac505d3cd787134735f8c89f9a69e3e40c8f6015aacc41dd4fe4193",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local/RESIDUAL-ADAPTERS.json": "6a807c59d857faed1140f9d7dd4dee863553f7a00a95ddd4601ef4dc8ea93b12",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local/SCALAR-FRAME-AUDIT.json": "f0545a8d32fb32c51e6364a9cdc71f0d940aa952474b6ca8d133a7a5a46f09c3",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local/WARP-RECIPE-CHECKS.json": "f79617ccec5a86f78f9d0eaf686cd9afcad476f4a893bea29a7036d49ad0fec5",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/local/WRAPPER-CHECKS.json": "508fe304ad6bd06c2c80b93b724cbd94368330f1f06f597f20fbcf2db9b4d771",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/native.log": "2099e78f2eecbec3c6c22c0f6288d7cf18931272fdb9ee972c8c6f415c2a62da",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/phases.log": "f6bb25f3c047485a94df814d7129e415958ea088c3e918021c31f01540aff770",
+    "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790/wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/CACHE.json": "29d6f4f777299f37794f24c4acf11d8eb444b5f1b2b28ed96c41949124c72928",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/STEPS.json": "563ef7b78d61d15daef40ee38351ffa9f051c0b3d83be19854f8b33e5124ff65",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/ledgers.log": "2d9134d3c2bb3e5197292a484f30e7fd58e435bdbc414324ba2f3f830d664ef7",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/local/CANONICAL-WORD.json.gz": "77419c939dd3c5f00364497b983dbf640a64ab5ed925b0b6bc44cd73d8bc6e69",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/local/CLIFFORD-RECIPES.json": "1f92f1a65833690e6e040b84499a96d9f710ab370eb590986abe64eb87e6cba6",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/local/CLIFFORD-REVIEW.json": "7ad869fd80f4a90aa7961dd44c7ea9724489e817c71d2342bf2e51f4ef8b3e23",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/local/FULL-WORD.json.gz": "429fc19af95bcfdf4b5b6f0409b2f45b97883b5a06f9ef43ebaa3662713a3352",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/local/INDEPENDENT-LOCAL-REPLAY.json": "18604bc0fae7b8cda98defa44039171eb90ce409306141aea5312e8a6619a773",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/local/LOCAL-CHECKS.json": "c23a2cde2617dd37c6f2097a43c4fef7cf6571964b3f1f460feadc176816a5ab",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/local/LOCAL-PROGRAMS.json.gz": "03513f863ac505d3cd787134735f8c89f9a69e3e40c8f6015aacc41dd4fe4193",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/local/RESIDUAL-ADAPTERS.json": "c4dd3cf0ce67c9ef6ab86b051026c0d884c3548dfc6118f047d6f56bb7331352",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/local/SCALAR-FRAME-AUDIT.json": "a50889847b0ef63511e7f657793be66357e7baf8676126f5c0f41ad638916bca",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/local/WARP-RECIPE-CHECKS.json": "4a914f957edea5fd1acc7981849158a7c672478921329ca4bb0c34e5ff8fffa3",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/local/WRAPPER-CHECKS.json": "508fe304ad6bd06c2c80b93b724cbd94368330f1f06f597f20fbcf2db9b4d771",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/native.log": "0a8208178fac29d6e4aaa5a18761235ee02691693c58b18e36fe08dfc4586486",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/phases.log": "35420092659726424da39cf2d84da38d7bda0d7fcb817ef3b9ccfc944bfdad7e",
+    "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6/wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa",
+    "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RECEIPT.json": "38e9fb2074c8b2b9a157e9393d723509baf88ae8b622dee640c8e4b2e408c6e1",
+    "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/RESULT.json": "ecd9c7c67587c0a63b64f2e807eee7745430982a1ac22931e44e7b5c890ccfa4",
+    "_receipts/e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4/STAGES.json": "41fd428aa45b95f58fc29a8943f9fb122a75fc99c38b76a0115bc26dce9bb359",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/CACHE.json": "a65bbfc1a2c64f6a28aabe6546f4834d1079cc417183cef62ab8546628251272",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/STEPS.json": "aac3c24e65b6b58feb162f276c694f5e028b429783814edc8bac3e5b01cdc3a5",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/ledgers.log": "2f40f12c67d436dde2ea415ea3e033ec60a9d43cc71427dcc1bf987962da34d7",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local-replay.log": "dd643a58258431c3b07d3b06d9060c49677fa23b4fafc9f10988ed1f6867bd9a",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CANONICAL-WORD.json.gz": "f69c0ca2c217eab87a231b67e548cd6491286314b1215e19f0b1d7463afd5e91",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-RECIPES.json": "f1b5a509e39293f5d7ffea7b269fd9e5443e625a9286a022caa1fd4b62af8063",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/CLIFFORD-REVIEW.json": "5b4495aa703f1c8667abb280f039ed5c7ece7fc26cf041c5696f2ef58ca6d5ea",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/FULL-WORD.json.gz": "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/INDEPENDENT-LOCAL-REPLAY.json": "70b4b787a5a4529452a58e9ac48826e848748a35b95a9b20c5358f4355705058",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-CHECKS.json": "e52e7feece9cb22e83c1d687c0f98731f8d50b7e8c863732ec662c89453fbcd4",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/LOCAL-PROGRAMS.json.gz": "81d4aefacaa27f2f215e7d35559d5a079ca521f4ca2eb9a9c6a6bd7062179bff",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/RESIDUAL-ADAPTERS.json": "89e5779ba4fcc1b1a76bed05c9b36600bc1dc3c6efd7e623865692ec715c30c5",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/SCALAR-FRAME-AUDIT.json": "3a6ec50f66781cc63f94b47de1212bdbd1eda10c60796e13352bb5db166df4a0",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/local/WRAPPER-CHECKS.json": "fc7e24778302326fdacfd08dd3d5e63483cf4539cd5022a6c77f016752fac1a3",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/native.log": "d1a3d3dd54a349ae8d37d2f10ffd1bd6a933726540ae605aca96e2eb57a16506",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/phases.log": "90b1ca43aad74ce6dfac1520a646aa9ee718fb9b5a603e00bd02d994f3bfcb21",
+    "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e/wrappers.log": "74b13cf8570ca2f32ce0018575b1b73e95af77a28e59d09556fec59260bdbba5"
+  },
+  "manifest_sha256": "1e75eabffe1ce311cc3bddc05e76118cbdedfc806200a906c57fbc5a5dd213eb",
+  "providers": {
+    "base": {
+      "complete_native_files": {
+        "STEPS.json": "d7c2a459a6120156d67f8cff70c859501fbe7d73f987ec817b03bc3ce39f2960",
+        "ledgers.log": "2d9134d3c2bb3e5197292a484f30e7fd58e435bdbc414324ba2f3f830d664ef7",
+        "local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402",
+        "local/CANONICAL-WORD.json.gz": "538e885dbb75d2a184982a2af5b70efc7c2792d3eeb6539fe228a22dee31fb3d",
+        "local/CLIFFORD-RECIPES.json": "49437c6094c4393bee059a5cd21548b912fa35671903a99952458200d7c10db9",
+        "local/CLIFFORD-REVIEW.json": "b3041bd059b569a1001b765339e61c9148126204bf5d1c49b40d0ff6ebae3597",
+        "local/FULL-WORD.json.gz": "9afa050cf437b17c347ca21601bdfde1b48914ca223a6ebf2c24c0fc50d478f3",
+        "local/INDEPENDENT-LOCAL-REPLAY.json": "6077842f1c26a6d0f256890f8be0451fd0fd5111bbdfa60618a2521eabb472c0",
+        "local/LOCAL-CHECKS.json": "c23a2cde2617dd37c6f2097a43c4fef7cf6571964b3f1f460feadc176816a5ab",
+        "local/LOCAL-PROGRAMS.json.gz": "03513f863ac505d3cd787134735f8c89f9a69e3e40c8f6015aacc41dd4fe4193",
+        "local/RESIDUAL-ADAPTERS.json": "6a807c59d857faed1140f9d7dd4dee863553f7a00a95ddd4601ef4dc8ea93b12",
+        "local/SCALAR-FRAME-AUDIT.json": "f0545a8d32fb32c51e6364a9cdc71f0d940aa952474b6ca8d133a7a5a46f09c3",
+        "local/WARP-RECIPE-CHECKS.json": "f79617ccec5a86f78f9d0eaf686cd9afcad476f4a893bea29a7036d49ad0fec5",
+        "local/WRAPPER-CHECKS.json": "508fe304ad6bd06c2c80b93b724cbd94368330f1f06f597f20fbcf2db9b4d771",
+        "native.log": "2099e78f2eecbec3c6c22c0f6288d7cf18931272fdb9ee972c8c6f415c2a62da",
+        "phases.log": "f6bb25f3c047485a94df814d7129e415958ea088c3e918021c31f01540aff770",
+        "wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa"
+      },
+      "word_sha256": "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790"
+    },
+    "extra": {
+      "complete_native_files": {
+        "STEPS.json": "563ef7b78d61d15daef40ee38351ffa9f051c0b3d83be19854f8b33e5124ff65",
+        "ledgers.log": "2d9134d3c2bb3e5197292a484f30e7fd58e435bdbc414324ba2f3f830d664ef7",
+        "local-replay.log": "2fac3873f6c1a23bc0393c701003ea73ac06fa077eb049dea0e4e158903ec402",
+        "local/CANONICAL-WORD.json.gz": "77419c939dd3c5f00364497b983dbf640a64ab5ed925b0b6bc44cd73d8bc6e69",
+        "local/CLIFFORD-RECIPES.json": "1f92f1a65833690e6e040b84499a96d9f710ab370eb590986abe64eb87e6cba6",
+        "local/CLIFFORD-REVIEW.json": "7ad869fd80f4a90aa7961dd44c7ea9724489e817c71d2342bf2e51f4ef8b3e23",
+        "local/FULL-WORD.json.gz": "429fc19af95bcfdf4b5b6f0409b2f45b97883b5a06f9ef43ebaa3662713a3352",
+        "local/INDEPENDENT-LOCAL-REPLAY.json": "18604bc0fae7b8cda98defa44039171eb90ce409306141aea5312e8a6619a773",
+        "local/LOCAL-CHECKS.json": "c23a2cde2617dd37c6f2097a43c4fef7cf6571964b3f1f460feadc176816a5ab",
+        "local/LOCAL-PROGRAMS.json.gz": "03513f863ac505d3cd787134735f8c89f9a69e3e40c8f6015aacc41dd4fe4193",
+        "local/RESIDUAL-ADAPTERS.json": "c4dd3cf0ce67c9ef6ab86b051026c0d884c3548dfc6118f047d6f56bb7331352",
+        "local/SCALAR-FRAME-AUDIT.json": "a50889847b0ef63511e7f657793be66357e7baf8676126f5c0f41ad638916bca",
+        "local/WARP-RECIPE-CHECKS.json": "4a914f957edea5fd1acc7981849158a7c672478921329ca4bb0c34e5ff8fffa3",
+        "local/WRAPPER-CHECKS.json": "508fe304ad6bd06c2c80b93b724cbd94368330f1f06f597f20fbcf2db9b4d771",
+        "native.log": "0a8208178fac29d6e4aaa5a18761235ee02691693c58b18e36fe08dfc4586486",
+        "phases.log": "35420092659726424da39cf2d84da38d7bda0d7fcb817ef3b9ccfc944bfdad7e",
+        "wrappers.log": "22847743670811f7f5ec80ea71b7c10e5ad6878d2b40734baa78e51c4ee5ddaa"
+      },
+      "word_sha256": "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6"
+    }
+  },
+  "retained_parent_receipt_sha256": "38e9fb2074c8b2b9a157e9393d723509baf88ae8b622dee640c8e4b2e408c6e1",
+  "source_commit": "local-joint12-refit393",
+  "status": "PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE"
+}
diff --git a/research/complex-routing-leaf-fusion/evidence/REBUILD-CONTROLS.json b/research/complex-routing-leaf-fusion/evidence/REBUILD-CONTROLS.json
new file mode 100644
index 0000000000..e4274f3499
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/evidence/REBUILD-CONTROLS.json
@@ -0,0 +1,118 @@
+{
+  "providers": {
+    "extra": {
+      "alias1_controls_rc": 0,
+      "audit_rc": 0,
+      "controls_rc": 0,
+      "cut_centre_guard_negative_control_rejected": true,
+      "cut_centre_guard_violations": 0,
+      "dim1_delivery_rejected": true,
+      "entrance_widths_bound_to_providers": true,
+      "helper_index_guard_negative_control_rejected": true,
+      "helper_index_guard_violations": 0,
+      "kernel_controls_rejected": {
+        "alias8_coefficient_doubled": true,
+        "alias8_sign_flipped": true,
+        "alias8_warp_dropped": true,
+        "entrance_start_frame_dropped": true,
+        "entrance_start_frame_widened": true,
+        "handoff_coefficient_doubled": true,
+        "handoff_sign_flipped": true,
+        "kernel_coefficient_doubled": true,
+        "kernel_read_dropped": true,
+        "kernel_read_moved_to_neighbour_register": true,
+        "kernel_sign_flipped": true
+      },
+      "kernel_edit_exact": true,
+      "lowfour_controls_rc": 0,
+      "patches": [
+        "refit",
+        "kernel",
+        "handoff",
+        "entrance",
+        "lowfour",
+        "alias8",
+        "prelife",
+        "refit563",
+        "alias1",
+        "joint-twelve-refit393"
+      ],
+      "prelife_controls_ok": true,
+      "prior_state_audit_rc": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "raised_buffers": 24,
+      "rebuild_plus_patches_equals_shipped": true,
+      "refit393_omission_rejected_by_profile": true,
+      "refit563_undone_rejected_by_warp_frame_mismatch": true,
+      "refit_tamper_rejected": true
+    },
+    "gauge44": {
+      "alias1_controls_rc": 0,
+      "audit_rc": 0,
+      "controls_rc": 0,
+      "cut_centre_guard_negative_control_rejected": true,
+      "cut_centre_guard_violations": 0,
+      "dim1_delivery_rejected": true,
+      "entrance_widths_bound_to_providers": true,
+      "helper_index_guard_negative_control_rejected": true,
+      "helper_index_guard_violations": 0,
+      "kernel_controls_rejected": {
+        "alias8_coefficient_doubled": true,
+        "alias8_sign_flipped": true,
+        "alias8_warp_dropped": true,
+        "entrance_start_frame_dropped": true,
+        "entrance_start_frame_widened": true,
+        "handoff_coefficient_doubled": true,
+        "handoff_sign_flipped": true,
+        "kernel_coefficient_doubled": true,
+        "kernel_read_dropped": true,
+        "kernel_read_moved_to_neighbour_register": true,
+        "kernel_sign_flipped": true
+      },
+      "kernel_edit_exact": true,
+      "lowfour_controls_rc": 0,
+      "patches": [
+        "refit",
+        "kernel",
+        "handoff",
+        "entrance",
+        "lowfour",
+        "alias8",
+        "prelife",
+        "refit563",
+        "alias1",
+        "joint-twelve-refit393"
+      ],
+      "prelife_controls_ok": true,
+      "prior_state_audit_rc": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "raised_buffers": 24,
+      "rebuild_plus_patches_equals_shipped": true,
+      "refit393_omission_rejected_by_profile": true,
+      "refit563_undone_rejected_by_warp_frame_mismatch": true,
+      "refit_tamper_rejected": true
+    }
+  },
+  "source_log_sha256": "8983c97d1ce6c9f06a9f32898096c62d95985a5b3f1b1f6f7984bd918aacd183",
+  "status": "PASS_REBUILD_BORROW"
+}
diff --git a/research/complex-routing-leaf-fusion/evidence/REGISTERED-REPLAY.json b/research/complex-routing-leaf-fusion/evidence/REGISTERED-REPLAY.json
new file mode 100644
index 0000000000..1c9a5e65ef
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/evidence/REGISTERED-REPLAY.json
@@ -0,0 +1,84 @@
+{
+  "status": "PASS_REGISTERED_REPLAY_READ_ONLY",
+  "command": [
+    "/Users/david/.local/bin/python3.12",
+    "-B",
+    "scripts/research_package.py",
+    "--package",
+    "research/complex-routing-leaf-fusion"
+  ],
+  "python": "3.12.15",
+  "platform": "macOS-27.0.1-arm64-arm-64bit",
+  "elapsed_seconds": 13.937063082994428,
+  "exit_code": 0,
+  "log_sha256": "7db9de1c10cac686c2664f9916f8c376f547c2f0dd28968cf246b26ac0828f57",
+  "source_files_sha256": {
+    "CAP-SOURCE.json": "2b15613f40fbe95d0a6908c1b2510f8c35ab4d13a522c405b1dfda0ba41c5be2",
+    "CLAIM.json": "399e20ffb8bac62363f7d48c59021d5afef5f62bb6c51986ca847b02ec1e73a8",
+    "CREDIT-PINS.json": "d719f9f5243ff17f73592dae33381f5b7f9f496d1a89ff13ef284aa23d150943",
+    "FULL-REPLAY-CHANGES.patch": "dfe4503d026d34d9a8c9769ea4ee9ed486c3ad2d05815bc110129c278ef26ae4",
+    "FULL-REPLAY-PINS.json": "c61cbbc0c323d13af87e7cb32800877aba5e5f654b7bd86d00a5edd773620cbd",
+    "OVERLAP.json": "f50e3fc2637d463af73783d23c2f32ff7c5e9eaa362585abbb480581ea59f5dc",
+    "PACKING-CAP.json": "9626826598a616c10637779d50e135ddda0782b30cb55e6de862f15bc3c034e1",
+    "PATCH.json": "341fa0c052f90f885d43a95812aaf141e539cce13db6c7ee3126dfa63ab53a6e",
+    "PREDECESSOR.json": "876bd508cd260dc2819ffc96dd7a5f60d8dd905693918fb71a7d7ba5f73d622a",
+    "PROFILE.json": "9fde4722b0064c72aa0537b96a0a050143006e149f8c943949d1be452a0d5195",
+    "PROOF.md": "ffdde6010edd1dd25c2187cfa9980f42603a3d03296e8e69fe23c74169feaa60",
+    "README.md": "894fe76ab46f1521c0d97c0af1e4d051449a4746a789c3d67b5c9301dd030739",
+    "RESULT.json": "fc76a920e7e85ed196fadf38645277e2d4b8b3f1476a99d8e8af73ac59c193d6",
+    "RUNTIME-CHANGES.patch": "5b0e021322a58583095d136909e2a3b0bdb8a149115dc0498df7330e68c87cfe",
+    "SOURCES.json": "51cd336c9c03da9a893d56fb8b7d9a03a99883df6004678f46fbcb32cd01052a",
+    "TASK.json": "6688b5ff8cf0c59ee260c0a3dba6aed2af9cddb6bca9fd93f6db309e43b08eee",
+    "VALIDATION.md": "22bce897b1fa17335c6faac116bd47bd0ac207485f0c45aa8fffaabd623ed77d",
+    "VERIFY.json": "67221f1f75c7c280c64c425e5755777ac1a332e4b8d66c74c799df80d05be718",
+    "derive_runtime.py": "23b0ee70f1408bae8d16bc5715b72aaa29f500b83618d7574d2f8b7fd8c454df",
+    "evidence/ADMISSION-RESULT.json": "e4d24d69989e23b590e59d4593a87e71a1d7227196f793d5687ac1be950f941b",
+    "evidence/FINAL-PORTABLE-REVIEW.json": "f3e483eebfd169f106f7b8be575051811d24e2fbd138068a0b4bda64da8a9318",
+    "evidence/FRESH-NATIVE-STAGES.json": "db20f5a85c5835346471f87c751f40ecac703f490003b1746952daefc642f121",
+    "evidence/FULL-REPLAY-COMMAND.json": "2ac90621c77a607dd27ff4231365399cd35df9beac330198ea13fa1f16ae7c2b",
+    "evidence/FULL-REPLAY-DERIVATION.json": "b1f7b22a98bc5fa187a19685ba323e497272321cb3b38276e37793c21060be26",
+    "evidence/FULL-REPLAY-RESULT.json": "767b9e07c8a1114f03b2a59974c88194c53a56184dd2d39ac7d5b333f80cf01b",
+    "evidence/NATIVE-RECEIPT.json": "a071e074d35f4182060f39a64616b63c4fb734f0cdd9bce451fdbee60bfc1eee",
+    "evidence/REBUILD-CONTROLS.json": "5328e1422a18958190d96556a6b9fd46b94f07905ec38ccba298e3b233e6a39a",
+    "evidence/RELEASE-RECEIPT.json": "5be2a287e2ec842152915d78898e767645f7ee5ebd002db6fd6b290de943afb7",
+    "evidence/STRICT-ASSEMBLY.json": "c2d73942e92ae99f5716c0968f628fcd1767f1d0cacfad75559a732abc0f396f",
+    "evidence/SUPPLIER-RESULT.json": "7d1b0b95c6816191981c0d68c813d01ba0fee6efc54929127d851a99a5dce406",
+    "exact_moment_checker.py": "a5d1b93afde948cda00d4bb2adea2b6a1e79738f1c1b9045cfe50a96a23617ef",
+    "full_replay.py": "a6467d6eb8d1b66ed0c4bcfd837d18b0f400e932720ccfaa0719a91618112756",
+    "generate.py": "86f3bb4793b484e86e0c054848b3bf7ef3c6038e10127b8326c3227dc51a1ffa",
+    "independent_check.py": "fcbed696350e525ab5db5bc299ead371eb500cda121318ca7a3f726ec08eea4e",
+    "inputs/WORD-base.json.gz": "80e309cc16d0a86a0854d32f4f43e0d856768ea3cf5b6437061b427997ae4790",
+    "inputs/WORD-extra.json.gz": "88e55acb7e274c62fbb0deab7f420d85fde3c2a471735222f0b5d039bc34e2e6",
+    "packing_cap.py": "ef08584047e27807a238529215ad79c321b4594fb7c15d3ab7f38c4b52f827ad",
+    "references/pr2733/CLAIM.json": "7402be1dcf6225f36fe727f0d0d5ae801de3b5dfda5bf18f8c1290e71d6f25c1",
+    "references/pr2733/NOTICE": "43b0546bcdf17863c8c2199b2da3f436b4fa92b634ae36a0e793ef10ce3f8b98",
+    "references/pr2733/PROOF.md": "7e029f68b0ff7beb0b1ba1f9013d525ec97060c0309026b3838d4d2680cc5dd0",
+    "requirements.txt": "f95b588f39c53b58fa36c3b65b65cc770e3a051a6a12555a9188808e771d1d13",
+    "test_integrity.py": "c8d3f443ade801cf9990cb62e5076de184ba5433a1f9daf4ed393b194002699c",
+    "vendor/ceiling.py": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc",
+    "vendor/pr2751/CLAIM.json": "78e99222196fca8b74a895b9e2db40a0e4afd1d69cd4fb52f38bfb157bac2438",
+    "vendor/pr2751/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+    "vendor/pr2751/PROFILE.json": "36e76f32570bac074cf70a6076b7c54e6d5b0fc3b505f404bc58fd02abf7967d",
+    "vendor/pr2751/PROOF.md": "6ecefda5d853e3ede1ee06aab08de24dfde960d98178a71844340ed86ae0d9b9",
+    "vendor/pr2751/README.md": "d8501fbc11b3dc87fc618122c83f10a56cd4457c7abdab792e2f9506bab4666e",
+    "vendor/pr2751/SOURCE-NOTICE": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420",
+    "vendor/pr2751/composition.py": "f202f8ce9730b778c9ee1213d63d444d117df5ff7d47933037a924723a37e3f4",
+    "vendor/pr2751/exact_moment.py": "f170292f7983773d4f142afdac4677c1615fb7b781dbabf395200aea886dcade",
+    "vendor/pr2751/independent_local.py": "ee1faab70095fa312fc61d375ddf015b76104cb1a542ae7876a149e7999faa20",
+    "vendor/pr2751/independent_owners.py": "4e0785a659b4a6516581f15476c054de1581aa4b3763ce45b1fd20e45c2bb5af",
+    "vendor/pr2751/inputs/DISPATCH.json.gz": "14fe756dcac93a0f3b2b7f38ba7b998dec89d56d5171b691af4fae45e5d83d11",
+    "vendor/pr2751/inputs/FILL.json.gz": "9ce94578640b4927cb9c73244692b1f79ac2999179d309f6bf0c015c06f7a2f1",
+    "vendor/pr2751/inputs/GLOBAL-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e",
+    "vendor/pr2751/inputs/ORDER.json": "129e791d5b45c279443ff9e1edef5ac33d5abc51717ecbae8265abea5c247ae7",
+    "vendor/pr2751/inputs/PLAN.json.gz": "afb3c5c8134fc2cfce0b50a21758490c225574994b2c3c5161e53e2355acc6fa",
+    "vendor/pr2751/inputs/PROVIDERS.json": "ec4802a33c0e1d41369da77b19b9b783dc812b2d3246e096fee13d29f226dd66",
+    "vendor/pr2751/inputs/SOURCE-FILL.json.gz": "dc96598624ee49d368e1130ec2148734be0bbc68402cc181e1f02ae9ca8e3d06",
+    "vendor/pr2751/inputs/SOURCE-ORDER.json": "aa7c53c188c90fd74421a804f4c6fb13aa1187c06dbac51fa147830a40e00667",
+    "vendor/pr2751/inputs/SOURCE-PROVIDERS.json": "d8d90c3b906c66874f9fe07df67be24e53f3f3f9146565b56a272548108327b7",
+    "vendor/pr2751/inputs/WORD-base.json.gz": "ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a",
+    "vendor/pr2751/inputs/WORD-extra.json.gz": "1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127",
+    "verify.py": "73b8d8174a28b272b8fbb0427835a127e53d1690f8bed89bc2862f9149b9dbec"
+  },
+  "read_only_inventory_unchanged": true,
+  "scope": "All five commands in VERIFY.json; final complete package inventory stable during execution. Full native and outer execution has separate receipts."
+}
diff --git a/research/complex-routing-leaf-fusion/evidence/RELEASE-RECEIPT.json b/research/complex-routing-leaf-fusion/evidence/RELEASE-RECEIPT.json
new file mode 100644
index 0000000000..3c909398a9
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/evidence/RELEASE-RECEIPT.json
@@ -0,0 +1,7 @@
+{
+  "status": "PASS_RELEASE",
+  "kappa_decimal": "0.0017172569734670023082699999999999999999999998999999999999999999999999",
+  "manifest_sha256": "82a1e95d70100a690834c88cdf6bfc0d161894f6823904aebbe04d65e5e7b05d",
+  "proof": "Supplier: the package's own unchanged `verify.py` (retained PR1297 provider and parent admission, owner reconstruction, parent lift, strict T74 admission, geometry controls): `PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION`, native reuse {'base': 'e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e', 'extra': '7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905'}; its complex endpoint 171725697346700230827/10000000... brackets the ledger's b = 171725697346700230826999999999999999999999999999999999999999999999999999999999999999999999999999999999/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000. Outer (PR1673 capped phase-cell fusion): regenerated exact ledger (63 strict inequalities: the 62 retained rows plus the explicit main-binding row gaussian_above_main, the fixed-grid maximum kappa = C - 1/F - B asserted, 17 rejecting controls incl. the old g-factor union row, the old linear and old-theta chirp guards, the old 2*beta tag test, epsilon at 1 or at the r0 slack and beta outside its window, larger endpoint rejected by the native moment), independent balance derivation, the exact union-schedule simulation, the (retained, not used for kappa) structured-boundary displacement-rank check, the gauge-free identity/symbol/circuit checks, PR1786's finite prime/underflow controls and 19 exact evidence replays all pass. Conditional kappa 0.0017172569734670023082699999999999999999999998999999999999999999999999 (union schedule outer/UNION-SCHEDULE.md; explicit Strassen boundary tau=45/16 (the structured boundary of outer/STRUCTURED-BOUNDARY.md is not used); gauge-free interiors outer/GAUGEFREE-INTERIORS.md; fine source-prime padding PR1786 at the free point epsilon=1-(1025/1024)e-104, outer/FINE-PADDING-COMPOSITION.md; fixed-grid maximum of PR2180/PR2161 (dataisfire), outer/PROOF-GRID-MAX.md; exact-integer coarse exponential PR2168/PR2184 (dataisfire) at the one 24-digit rejection call).",
+  "seconds": 145.82
+}
diff --git a/research/complex-routing-leaf-fusion/evidence/STRICT-ASSEMBLY.json b/research/complex-routing-leaf-fusion/evidence/STRICT-ASSEMBLY.json
new file mode 100644
index 0000000000..70bf70f217
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/evidence/STRICT-ASSEMBLY.json
@@ -0,0 +1,516 @@
+{
+  "status": "PASS_GAUGE44_NATIVE_EXACT_GLOBAL_ASSEMBLY",
+  "kappa": "1714313057414451/1000000000000000000",
+  "kappa_decimal": "0.001714313057414451",
+  "complex_lower": "171725697346700230827/100000000000000000000000",
+  "complex_decimal": "0.00171725697346700230827",
+  "bit_lower": "1733427039589844234749/1000000000000000000000000",
+  "bit_decimal": "0.001733427039589844234749",
+  "binding": "complex",
+  "gain_over_pr635_percent": "2.23382935556285050480921133363275394134195252390139677473927803495949522087234348438061251873665229608042900995260107752419638485699604066177537567837396401933736733547685284307730646970193079208268320088749076118503348482375145037386461268287292764733311659443350172494731156729981795464598968693948080052247103968689535910711907687784381021643360566916280371901449513927893581530519386230393839484868566413031189805320819185360990476739858582948226534219607390464661958312591169344230598610977705836781754949726773455276795340099408783922739713254026016439134374592331997325273663732166339850525339803611024089629873728794064186711657873867355848871814556466277638304446726435407418547643387559640055691941517877394272298293916297020035891918871191659082754221921594019474773026000754379753678856587970158087313100259883211912010403826222965006250273307955251686862116197499760525446565139915519440508532398738468510466153556138189647166686149759929615533851985311946651873051085219821324427164529747641954740385803488169203922514655942985574420451473207531924390271139912127036679683747369321355823383930216951139609812870306283931264222227365199915461523116309176595290035504424984109855015870949486957379575674239507066729059119133939429468010732760958838046292084643892243844503566084024002899516019513556664763788187684098234697903337072198314843697158554994424589935680942874077060509592007172186063862470967461056486968260409054164158705564198267144072254592916831969584329661574588085283572049585873101790319744989168679346537708558173021993473541189260518444870994042266769001552291681758220643643029804935183976453316366236075533202451642448207989463302635620471093226298523367610132098295773277954370973869608060786728004942739733919708464348507200573834148838577881979177913497721554948800141579066539774634165942310443915331306727724610009125257406611770079451623995487259916127557863928435608490406595209859588521900297226345872450572492978352827783697592368264958670274155804675519352920841829250553630123900474585689128976896632914977206748785085609053373447304232062293482304013028570202042106605593017082263894351101673975910707844429430649783887851606130976117696188856329989098748488104543403563745258091458144465251016886126590030029909996603638823119178330814798111508611676521471508029811785151338711291546514173446772544223243035357253701997244619973954656930063259177331529720490836453684907815620543423376516739811929960343867676177241344808229283475784098365142032546118543388078586385922593742311179845832579221935709847722508848586715067714087766231782390434201693396845688576283578308205585965746906610580515826327923291993966902545360306393861729943408845633994900772250962202569250586589543888277071528451276602309232326661823644776942707859267946393116267687629556121276103144641824440434760161604098353802621719252974023762839250597031231734225760360925052986301046049251571826255490470106350346327923553295633163788348103784745922687153993760769248712287344226264928075773794617713081673268926953975843423886402984231094226976453995689516563582437316494870734311811962263334996684064",
+  "complex_profile": {
+    "1": 1591740,
+    "2": 430902,
+    "3": 204396,
+    "4": 79920,
+    "5": 22532,
+    "8": 5328,
+    "32": 1,
+    "48": 26558
+  },
+  "provider_counts": {
+    "extra": 417,
+    "gauge44": 249
+  },
+  "surcharge_model": {
+    "complex": false,
+    "bit": true
+  },
+  "conservative_complex_lower": "858628485267240703269/500000000000000000000000",
+  "conservative_complex_decimal": "0.001717256970534481406538",
+  "conservative_kappa": "214289131811497/125000000000000000",
+  "conservative_kappa_decimal": "0.001714313054491976",
+  "conservative_moments": [
+    {
+      "side": "conservative_complex",
+      "surcharge": true,
+      "endpoint": "858628485267240703269/500000000000000000000000",
+      "accept": true,
+      "mercator": [
+        "-41346855682045618429852026429366817960220205/26959946667150639794667015087019630673637144422540572481103610249216",
+        "-41346855682045618429852026429366817960220203/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "base_two": [
+        "-7668200671495663261069/5000000000000000000000000000000000000000000000",
+        "-15336391342991326521993/10000000000000000000000000000000000000000000000"
+      ]
+    },
+    {
+      "side": "conservative_complex",
+      "surcharge": true,
+      "endpoint": "1717256970534481406539/1000000000000000000000000",
+      "accept": false,
+      "mercator": [
+        "35703767310105754952579390610077529845733639/26959946667150639794667015087019630673637144422540572481103610249216",
+        "35703767310105754952579390610077529845733641/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "base_two": [
+        "662162932868412943597/500000000000000000000000000000000000000000000",
+        "2648653731473651774417/2000000000000000000000000000000000000000000000"
+      ]
+    }
+  ],
+  "conservative_bootstrap": [
+    {
+      "step": 0,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "bf1ceaab2a8560a3824798ffb8cc01a9394f2d8b5a5dfcbac61e1100c5b6c3f6",
+      "gap_numerator_sha256": "e3e5835be7953369066e2c5cdc0d95d55433daff5ff182aa59018b788fd590a1",
+      "log2C_bound_sha256": "1a1cf797fabe7f95836fabeca626907c77b3e6c9aff7c2290b396a238c69362e",
+      "cutoff_log2_power_of_two_exponent": 45,
+      "carry_bits_bit_length": 36
+    },
+    {
+      "step": 1,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "5b8fbb91301658e06b2b001b5cd48f4b6023e39d9e0ca6fff62f354472d088e2",
+      "gap_numerator_sha256": "97028be72891d410a6023aeb68075b965333243eed758e4466b8bad4b7a3ee19",
+      "log2C_bound_sha256": "7da97e7eefd7eb3cda7505e85975943c6abc72943558804efa854687ce54699b",
+      "cutoff_log2_power_of_two_exponent": 66,
+      "carry_bits_bit_length": 48
+    },
+    {
+      "step": 2,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "9960c9f5f8578d1eec5d603b01c99a387a4d1f0c7c206fcb848850628eea1210",
+      "gap_numerator_sha256": "24bf4f69961e656f937f357b16996fc900980d897d4dc728d6c17a8740c54216",
+      "log2C_bound_sha256": "941cea2af6756220563c664cc60c973843f4fde16ecfe77563bff89e88a37e94",
+      "cutoff_log2_power_of_two_exponent": 87,
+      "carry_bits_bit_length": 60
+    },
+    {
+      "step": 3,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "97df78c5df95f40d6060da1bb2250956dca7cc9046ed589cb21e23c59ea49d3e",
+      "gap_numerator_sha256": "86da4e362fb97370c6bf3aa57c5b56e9fa071189d297d9510d03dd39d328dfe9",
+      "log2C_bound_sha256": "825be5db5874a7214b3265107cf976929bb2096903bc52971533c167f2621046",
+      "cutoff_log2_power_of_two_exponent": 108,
+      "carry_bits_bit_length": 72
+    },
+    {
+      "step": 4,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "acf69ce4f0c5245487fac161f6a8c67c28cb053e41fc5ee6dcf5f946788ee754",
+      "gap_numerator_sha256": "b4c990bb02ec7f4f1297b68c7628aebb4319d13f51dda7f3c8fbfabf13d6e9c7",
+      "log2C_bound_sha256": "a9a427247de16d26879fb129023eee5fd3837cb5d0fc436c86aa56d63c4390de",
+      "cutoff_log2_power_of_two_exponent": 130,
+      "carry_bits_bit_length": 85
+    },
+    {
+      "step": 5,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "a6095c8a6894b8ad753282a0f40fa0fb6b164ae7313b232746b7904e9e238995",
+      "gap_numerator_sha256": "51cb840cacab28d06d6cbbf34b663b36aa36089fe3636dce098d1ca703ddbc99",
+      "log2C_bound_sha256": "215369a5c005a8e695a2d986ef40e453a538973db2a715844ed22530c214163e",
+      "cutoff_log2_power_of_two_exponent": 152,
+      "carry_bits_bit_length": 97
+    },
+    {
+      "step": 6,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "e63c5ff586459493c15535bca729085863a811e8942170eea00c648a8036277f",
+      "gap_numerator_sha256": "cc2db1bd7143196423248a566adf005a66d0921d274b8b2a9fb2fea1b0751805",
+      "log2C_bound_sha256": "a6b5fd6e0585b55aa2d08db5926d21ffe7ce938339272a4a01cf83fdd5406d21",
+      "cutoff_log2_power_of_two_exponent": 173,
+      "carry_bits_bit_length": 109
+    },
+    {
+      "step": 7,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "c4313fbc2ab88709d7a0e52d79cf25f1fba218a2f4c85123ad9d278d8d398c4e",
+      "gap_numerator_sha256": "d7236d733dd984d9a600bdea8d0faa82a47e4012fdb3c25a8b816dd4c252caf1",
+      "log2C_bound_sha256": "7558df2567923cb85485f64bc93030d98cdec28cf43717085cc80e79c99eb887",
+      "cutoff_log2_power_of_two_exponent": 194,
+      "carry_bits_bit_length": 121
+    },
+    {
+      "step": 8,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "b9f51eda51110a5429cacd70732002d62da1c7f059397cf543865c3344da55b9",
+      "gap_numerator_sha256": "db09fb623ec0f6d655e9fc8814a1d3f7c8b4dbb6a3dcb7c72952a8e3d656fee1",
+      "log2C_bound_sha256": "998f5925c6a82ad56b1c7725a8434a49a30bb70719c0a92d4a11dcabfad834fd",
+      "cutoff_log2_power_of_two_exponent": 215,
+      "carry_bits_bit_length": 133
+    },
+    {
+      "step": 9,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "ab89849ee2ac0799c0dc33b11b98fbe44f09bfa069457589d22ca48f550b0408",
+      "gap_numerator_sha256": "61423fe1ad1f0981c72180ad3cb3e1dc3f492fa922cf3d3a15e74d243753568b",
+      "log2C_bound_sha256": "dd50d3c5237b730521876c619358c6f21d71b4710731764cbfbbf543ece09da5",
+      "cutoff_log2_power_of_two_exponent": 237,
+      "carry_bits_bit_length": 146
+    },
+    {
+      "step": 10,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "854af468c3c220dd19846e14b6e57e85b9f60a9e8637f7a038b1a4214845f5e2",
+      "gap_numerator_sha256": "3db488f25b6bdb81e73967a651479655fa786006e6fb282ed50b80fa16c91db9",
+      "log2C_bound_sha256": "d13830187905956fc8a9de34bb014c24a9f830ea8871c9626328883c88e8faa4",
+      "cutoff_log2_power_of_two_exponent": 259,
+      "carry_bits_bit_length": 158
+    },
+    {
+      "step": 11,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "8ffe29be9623eacdb1f776f98154f5dc45771871402923738b031e8a0cd90a1d",
+      "gap_numerator_sha256": "08f0e4327c75e0f271c86fd10b15cf4036cd8ce3cb8827ffec73f2014a7d0446",
+      "log2C_bound_sha256": "bc899a4c230bb7018ccd9f4b1540d6c3bebd72d6278f2d187cd80b151e0a75b8",
+      "cutoff_log2_power_of_two_exponent": 280,
+      "carry_bits_bit_length": 170
+    },
+    {
+      "control": "uncarried_cutoffs_fail_carry_rule",
+      "stages_checked": [
+        2,
+        3,
+        4,
+        5,
+        6,
+        7
+      ],
+      "all_rejected": true
+    }
+  ],
+  "conservative_outer": {
+    "bit_positive": "20078190993232405467654628944985808935358217341/11692013098647223345629478661730264157247460343808",
+    "complex_above_bit": "189365942402685251756357798149995619/696898287454081973172991196020261297061888000000000000000000000000",
+    "complex_below_one_over32": "14766371514732759296731/500000000000000000000000",
+    "beta_positive": "1/10000000000000000000000000000",
+    "beta_below_one": "9999999999999999999999999999/10000000000000000000000000000",
+    "leaf_saving_above_bit": "2596177094216598262222575628289861601433277817967228051/25961484292674138142652481646100480000000000000000000000000000000000000000000000000000",
+    "q_positive": "100390954966162027338273144704850853683558681237345371055014191064641782659/58460065493236116728147393308651320786237301719040000000000000000000000000000",
+    "q_below_internal": "20078190993232405467654628944985808935358217341/58460065493236116728147393308651320786237301719040000000000000000000000000000",
+    "q_below_leaf": "1545206432955458758919315650173352498018498655923283274386916253/3484491437270409865864955980101306485309440000000000000000000000000000000000000000000000000000",
+    "c_positive": "20078190993232405467654629233270498202892319888206040754259442144114865127/11692013098647223345629478661730264157247460343808000000000000000000000000000",
+    "c_below_one": "11671934907653990940161824032496993659044568023919793959245740557855885134873/11692013098647223345629478661730264157247460343808000000000000000000000000000",
+    "q_below_reservations": "1/40000000000000000000000000000",
+    "lambda_above_tau": "20078190993232405467654628944985808935358217341/116920130986472233456294786617302641572474603438080000000000000000000000000000",
+    "lambda_above_sigma": "51848524180566499954962570473454577925525257341/116920130986472233456294786617302641572474603438080000000000000000000000000000",
+    "lambda_above_internal": "20078190993232405467654628944985808935358217341/116920130986472233456294786617302641572474603438080000000000000000000000000000",
+    "lambda_prime_above_lambda": "20078190993232405467654628944985808935358217341/116920130986472233456294786617302641572474603438080000000000000000000000000000",
+    "compact_leaf": "1545206432955458758919315650173352498018498655923283274386916253/3484491437270409865864955980101306485309440000000000000000000000000000000000000000000000000000",
+    "compact_reservations": "1/40000000000000000000000000000",
+    "lambda_prime_below_one": "100390954966162027338273144704850853683558681237345371055014191064641782659/58460065493236116728147393308651320786237301719040000000000000000000000000000",
+    "epsilon_positive": "6495562832581790747571932589200590470768187782913917852126096435708474425344/6506717383133586528387296272595130182213428933364149485672779354562737975851",
+    "epsilon_below_one": "11154550551795780815363683394539711445241150450231633546682918854263550507/6506717383133586528387296272595130182213428933364149485672779354562737975851",
+    "guard_width": "11154550551795780815363683394539711445241150450231633546682918854263550507/6506717383133586528387296272595130182213428933364149485672779354562737975851",
+    "K_geometry": "976565334997627768298862625058996512904276397527134004528251049127123873903/13013434766267173056774592545190260364426857866728298971345558709125475951702000000000000000000000000000",
+    "K_dominates_log": "22309101103591561630727365812514087892854532601600642034369324804250703486865995471748950872876126097/13013434766267173056774592545190260364426857866728298971345558709125475951702000000000000000000000000000",
+    "record_suffix": "11154550551795780815363683394539711445241150450231633546682918854263550507/6506717383133586528387296272595130182213428933364149485672779354562737975851",
+    "phase_local": "892364044143662465229094665056459532485705507631234411139503326127655107195850514327220645437262024149/520537390650686922270983701807610414577074314669131958853822348365019038068080000000000000000000000000000",
+    "phase_boundary": "178472808828732493045818927805917999990271878816409864151796519454787874747850514327220645437262024149/104107478130137384454196740361522082915414862933826391770764469673003807613616000000000000000000000000000",
+    "gamma_sublinear": "1/20000000000000000000000000000",
+    "cell_above_band": "129911256651635814951438651777505092032230169129891060769926798531956059573515850514327220645437262024149/260268695325343461135491850903805207288537157334565979426911174182509519034040000000000000000000000000000",
+    "prime_interval_packing": "11154550551795780815363683394539711445241150450231633546682918854263550507/6506717383133586528387296272595130182213428933364149485672779354562737975851",
+    "alpha_positive": "223091011035915616307273661384076845771236480617336398338528194871842076775850514327220645437262024149/130134347662671730567745925451902603644268578667282989713455587091254759517020000000000000000000000000000",
+    "alpha_below_one": "129911256651635814951438651790518526798497342186665653315117058896382917440244149485672779354562737975851/130134347662671730567745925451902603644268578667282989713455587091254759517020000000000000000000000000000",
+    "alpha_below_one_fourth": "32310495904632017025629207701591574065295908186203411030025368577941847802479149485672779354562737975851/130134347662671730567745925451902603644268578667282989713455587091254759517020000000000000000000000000000",
+    "delta_positive": "1/80000000000000000000000000000",
+    "delta_below_one_eighth": "9999999999999999999999999999/80000000000000000000000000000",
+    "short_record_fallback": "75815562607274816981309951707405945165396157136228954255668400918130755469189035087848641629069239347750805154118727401237761/76076624872793477367397823041330580408767912559942946375230984182216701226723708422207092930120392116324736345616906461380608",
+    "small_field_exposure": "1/10000000000000000000000000000",
+    "artificial_boundary": "3644654098598952118362115007344356231104540254305104131478276462610114637317212448457018338063688213927553/520537390650686922270983701807610414577074314669131958853822348365019038068080000000000000000000000000000",
+    "literal_scalar_guard": "1",
+    "row_product_gap": "23971789/25",
+    "balanced_prefix_above_kappa": "651578283807596808605754626106142442754358240803363950379659592045329841053/813339672891698316048412034074391272776678616670518685709097419320342246981375000000000000000",
+    "coordinate_movement_above_kappa": "131303043099559437440465832816156271504131035753787919093/44601490397061246283071436545296723011960832000000000000000000",
+    "compact_phase_layer_above_kappa": "52126262698101027305326783560104099147753529082055687097008617877953607929677262024149/65067173831335865283872962725951301822134289333641494856727793545627379758510000000000000000000000000000",
+    "bulk_exposure_above_kappa": "131303043099559437440465832816156271504131035753787919093/44601490397061246283071436545296723011960832000000000000000000",
+    "Gaussian_arithmetic_above_kappa": "83402020320865674118403005613198936399962724640617156715232278296129440300221262024149/104107478130137384454196740361522082915414862933826391770764469673003807613616000000000000000000000000000",
+    "scalar_work_above_kappa": "417010101630355240124549374179543867090194143931939499309617989423338318919357262024149/520537390650686922270983701807610414577074314669131958853822348365019038068080000000000000000000000000000",
+    "dimension_above_kappa": "810551035253749371496149397033353153521122955164103220076784930410140309734284592045329841053/813339672891698316048412034074391272776678616670518685709097419320342246981375000000000000000"
+  },
+  "conservative_controls": [
+    "next_grid",
+    "zero_eta",
+    "zero_beta",
+    "unit_beta"
+  ],
+  "model_controls": [
+    "native_complex_endpoint_rejected_with_old_surcharge",
+    "omitting_bit_surcharge_would_fail_next_endpoint_rejection"
+  ],
+  "native_correction_gain": "2.922475E-12",
+  "template_sha256": "4249b6d4f081f30dbd4a814e6ad91d1453c525e21cfb0def213477d533661f66",
+  "input_sha256": {
+    "owner_audit": "d3dd8074b3b09a6ca92191a9356074489c0a000ccfb69d9277ef3fe08e7ce934",
+    "fresh_invoice": "97e224d69a3ff00607b5a4c8e399171b4dad4dcc36ed52480c7327be09d313fb",
+    "package:inputs/PR589-EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4",
+    "engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482",
+    "engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098",
+    "engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c"
+  },
+  "bit_supplier": {
+    "pr": 589,
+    "repository": "CrocSwap/integer-mult-bounds",
+    "commit": "a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46",
+    "merged_as": "b3eb785ac5b4b1ca2beea0f80db078a505626a90",
+    "path": "research/e8-bit-p111-tuned/tune/EXPECTED.json",
+    "git_blob_sha1": "e293ddc557742637f9f679f083a1a282d87b1b13",
+    "word": {
+      "v": 111,
+      "decoder_constant": 63,
+      "copy_ranks": [
+        7,
+        7,
+        7,
+        7,
+        7,
+        7,
+        7,
+        7,
+        7
+      ]
+    },
+    "derived_deficit": 10272,
+    "deficit_formula": "T(2Kv-L*cst), L=9 T=32 K=4 M=64",
+    "replay_scope": "Cited unchanged supplier; this assembly reprices its full profile and does not rebuild its bit circuit."
+  },
+  "moments": [
+    {
+      "side": "bit",
+      "surcharge": true,
+      "endpoint": "1733427039589844234749/1000000000000000000000000",
+      "accept": true,
+      "mercator": [
+        "-43100600330766044577088869872467188970742291/26959946667150639794667015087019630673637144422540572481103610249216",
+        "-43100600330766044577088869872467188970742289/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "base_two": [
+        "-799345163337715793503/500000000000000000000000000000000000000000000",
+        "-3197378653350863173989/2000000000000000000000000000000000000000000000"
+      ]
+    },
+    {
+      "side": "bit",
+      "surcharge": true,
+      "endpoint": "6933708158359376939/4000000000000000000000",
+      "accept": false,
+      "mercator": [
+        "22502934905675809315035333485365686073718547/13479973333575319897333507543509815336818572211270286240551805124608",
+        "5625733726418952328758833371341421518429637/3369993333393829974333376885877453834204643052817571560137951281152"
+      ],
+      "base_two": [
+        "8346798366759439729359/5000000000000000000000000000000000000000000000",
+        "16693606733518879458833/10000000000000000000000000000000000000000000000"
+      ]
+    },
+    {
+      "side": "complex",
+      "surcharge": false,
+      "endpoint": "171725697346700230827/100000000000000000000000",
+      "accept": true,
+      "mercator": [
+        "-72797190278745559727282522701879611404801473/26959946667150639794667015087019630673637144422540572481103610249216",
+        "-72797190278745559727282522701879611404801471/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "base_two": [
+        "-1350099/500000000000000000000000000000",
+        "-2700197/1000000000000000000000000000000"
+      ]
+    },
+    {
+      "side": "complex",
+      "surcharge": false,
+      "endpoint": "1717256973467002308271/1000000000000000000000000",
+      "accept": false,
+      "mercator": [
+        "4253432713269041357802430160359428111041907/26959946667150639794667015087019630673637144422540572481103610249216",
+        "4253432713269041357802430160359428111041909/26959946667150639794667015087019630673637144422540572481103610249216"
+      ],
+      "base_two": [
+        "19721/125000000000000000000000000000",
+        "157769/1000000000000000000000000000000"
+      ]
+    }
+  ],
+  "bootstrap": [
+    {
+      "step": 0,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "2eb1b4221d4386282f151ce1a2c84c5db8286c365aef039991f313380979351a",
+      "gap_numerator_sha256": "770a99cfeb60e9eb611ce5eec04a96ede553ca374b4b38bc97aecff33c4e5270",
+      "log2C_bound_sha256": "1a1cf797fabe7f95836fabeca626907c77b3e6c9aff7c2290b396a238c69362e",
+      "cutoff_log2_power_of_two_exponent": 45,
+      "carry_bits_bit_length": 36
+    },
+    {
+      "step": 1,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "690fd0ba49969e4de0ae8c0bb071ac6ac496ae945f89c65e8fe538006e91e148",
+      "gap_numerator_sha256": "d53614859e79a2e6d565ed8cf2adc8cc15da8e172b743b6e4281fcfb789d4fc8",
+      "log2C_bound_sha256": "8972d7b58aec750d04e4ae5908aa09945de8c4ecccf94102fec2ac240fcc4711",
+      "cutoff_log2_power_of_two_exponent": 66,
+      "carry_bits_bit_length": 48
+    },
+    {
+      "step": 2,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "4407999b89c4ce85302c5b49ae5168db7bc0557957a045ed17973385b306c75a",
+      "gap_numerator_sha256": "4ce5697760846c849bdd6c12f378c6baf786aa243b6bb211643fbba5f5905e2b",
+      "log2C_bound_sha256": "7db765732f839ab66a38c9770581bf1a390314d926573312e102132787976e48",
+      "cutoff_log2_power_of_two_exponent": 87,
+      "carry_bits_bit_length": 60
+    },
+    {
+      "step": 3,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "abd3542afaab26f3b7d09cd556d3fe5d4cce18e0c662776cd1af9abdbec36c94",
+      "gap_numerator_sha256": "9863b4602e0a8915040ec9e491d0cc89a6a3c41afa927120e66e5be8d3ea8abc",
+      "log2C_bound_sha256": "5084bc9b2a0dfde461c4e79c638b7dccebdd657bc0d190d652bb8fc8c5abdfbc",
+      "cutoff_log2_power_of_two_exponent": 108,
+      "carry_bits_bit_length": 72
+    },
+    {
+      "step": 4,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "9ff1c0ddd7e6c49fe23e922a28657154962702087f29bc55f955cb9e95897c1c",
+      "gap_numerator_sha256": "032053337c19acc27ad3b480683b4a271d744af525339f7f1a30db35621811e5",
+      "log2C_bound_sha256": "6531a8a3bd57dcd0154b07b600b79341dc484a19377084aef770449514897326",
+      "cutoff_log2_power_of_two_exponent": 130,
+      "carry_bits_bit_length": 85
+    },
+    {
+      "step": 5,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "33c81b97e1b88e230316a6c2445070d8357900438802e338962cb3e3b85a2cc8",
+      "gap_numerator_sha256": "c019c2e07796a215ab7a9013a5df8bee44c0650aaad661ea44dd9dcce7983e5a",
+      "log2C_bound_sha256": "8408884773a59c546ca4c857359a8e3c0bccfe03ec45ec6dabd4c40d59ea51df",
+      "cutoff_log2_power_of_two_exponent": 152,
+      "carry_bits_bit_length": 97
+    },
+    {
+      "step": 6,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "b8db0840fe37370cb8d10e8f1123c390480a7eebd6bafadb0e3010b75d65b6d0",
+      "gap_numerator_sha256": "4db7d757b58af25ccff531dfa2a0dbea554cbb03b843e5e91c0b17ac97836c17",
+      "log2C_bound_sha256": "1e6887c08e19d6e83ba21f9d33f5657ffd3ad0f5aa65ac0c31a621206fd65929",
+      "cutoff_log2_power_of_two_exponent": 173,
+      "carry_bits_bit_length": 109
+    },
+    {
+      "step": 7,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "ea96e5fca840a60fecc609b0b4d63552b8d091234795020caba55633a6398e26",
+      "gap_numerator_sha256": "3fd67798b77fb3a51f27054736baa5b1150e1e5d3bfd81504c5571ee60304a2b",
+      "log2C_bound_sha256": "ee413dcc48f5a7bfe0e6ebca46ce19e1a9f19503e53ae5851586acd897db6921",
+      "cutoff_log2_power_of_two_exponent": 194,
+      "carry_bits_bit_length": 121
+    },
+    {
+      "step": 8,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "7c1f83b2ea95e743645c60fb812b50c47edbe742b42ea9412490b19df657e5cb",
+      "gap_numerator_sha256": "423efc58c0c1531d02ef4165c53bd92136580eb3b0bfc6e6bb3229a1f080d56f",
+      "log2C_bound_sha256": "598310fc18e40420909daaef61349b0dc4046cdcd19ceff41f16da00f60e211d",
+      "cutoff_log2_power_of_two_exponent": 215,
+      "carry_bits_bit_length": 133
+    },
+    {
+      "step": 9,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "1214a40d843fbbdc02c58f6294946cf600fe9fac532987b3469484e1f67d26a2",
+      "gap_numerator_sha256": "dc9e2f861212d3963573ca0e9b4aca0a6ef66ebf1f491bfc679d2746b9a91677",
+      "log2C_bound_sha256": "18285c33871a48508488d6ea38282f46939c581a3d371c5e9937bdf4cd9a6870",
+      "cutoff_log2_power_of_two_exponent": 237,
+      "carry_bits_bit_length": 146
+    },
+    {
+      "step": 10,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "4eaa16dd90a0c4a00744186d053782ec55a01c36013451114af3984c6a7c0b73",
+      "gap_numerator_sha256": "ba51080925d3b115fc18696828717a2a2063a9ce487ff28518c4cc51c2316f84",
+      "log2C_bound_sha256": "a6fddb95497ea5b875bca2880eda03b0af62f8177374be75ba8414d8951dd541",
+      "cutoff_log2_power_of_two_exponent": 259,
+      "carry_bits_bit_length": 158
+    },
+    {
+      "step": 11,
+      "grid_bits": 164,
+      "exponent_numerator_sha256": "a5eec8f8a48577e55f9c152888f472ea29d553343a36aa2a2b7f98f395d5fa33",
+      "gap_numerator_sha256": "8ae84c4f67b994d3f64dfa10cdb216da532118e3d50fb500bb754bb2fc5b1268",
+      "log2C_bound_sha256": "67db1d4543a424874131c22e58341d24b063c50fc96c46f09554a20d0491c8ff",
+      "cutoff_log2_power_of_two_exponent": 280,
+      "carry_bits_bit_length": 170
+    },
+    {
+      "control": "uncarried_cutoffs_fail_carry_rule",
+      "stages_checked": [
+        2,
+        3,
+        4,
+        5,
+        6,
+        7
+      ],
+      "all_rejected": true
+    }
+  ],
+  "outer": {
+    "bit_positive": "20078191027519478262761939819869169598187509813/11692013098647223345629478661730264157247460343808",
+    "complex_above_bit": "37873188521413848668297238389702127/139379657490816394634598239204052259412377600000000000000000000000",
+    "complex_below_one_over32": "2953274302653299769173/100000000000000000000000",
+    "beta_positive": "1/10000000000000000000000000000",
+    "beta_below_one": "9999999999999999999999999999/10000000000000000000000000000",
+    "leaf_saving_above_bit": "519235418843447147905437342633396151495425668387509983/5192296858534827628530496329220096000000000000000000000000000000000000000000000000000",
+    "q_positive": "100390955137597391313809699079267656963418070802238060180130830401812490187/58460065493236116728147393308651320786237301719040000000000000000000000000000",
+    "q_below_internal": "20078191027519478262761939819869169598187509813/58460065493236116728147393308651320786237301719040000000000000000000000000000",
+    "q_below_leaf": "309041286999842622803024624884536113100926315727849748114719249/696898287454081973172991196020261297061888000000000000000000000000000000000000000000000000000",
+    "c_positive": "100390955137597391313809700540769294294320989005922892896413850057745033163/58460065493236116728147393308651320786237301719040000000000000000000000000000",
+    "c_below_one": "58359674538098519336833583608110551491942980730034077107103586149942254966837/58460065493236116728147393308651320786237301719040000000000000000000000000000",
+    "q_below_reservations": "1/40000000000000000000000000000",
+    "lambda_above_tau": "20078191027519478262761939819869169598187509813/116920130986472233456294786617302641572474603438080000000000000000000000000000",
+    "lambda_above_sigma": "51848524249143516487728695853245407615109109813/116920130986472233456294786617302641572474603438080000000000000000000000000000",
+    "lambda_above_internal": "20078191027519478262761939819869169598187509813/116920130986472233456294786617302641572474603438080000000000000000000000000000",
+    "lambda_prime_above_lambda": "20078191027519478262761939819869169598187509813/116920130986472233456294786617302641572474603438080000000000000000000000000000",
+    "compact_leaf": "309041286999842622803024624884536113100926315727849748114719249/696898287454081973172991196020261297061888000000000000000000000000000000000000000000000000000",
+    "compact_reservations": "1/40000000000000000000000000000",
+    "lambda_prime_below_one": "100390955137597391313809699079267656963418070802238060180130830401812490187/58460065493236116728147393308651320786237301719040000000000000000000000000000",
+    "epsilon_positive": "5314551408476010611649763027527755839719426367838660060830442538306933620736/5323677858943064919951018455248235313018247253622021641834557348218346590017",
+    "epsilon_below_one": "9126450467054308301255427720479473298820885783361581004114809911412969281/5323677858943064919951018455248235313018247253622021641834557348218346590017",
+    "guard_width": "9126450467054308301255427720479473298820885783361581004114809911412969281/5323677858943064919951018455248235313018247253622021641834557348218346590017",
+    "K_geometry": "3995040006824062267038577698366296353088390661662356626626946713641613184833/53236778589430649199510184552482353130182472536220216418345573482183465900170000000000000000000000000000",
+    "K_dominates_log": "91264504670543083012554273209754726164146590795038111674851746025739031147643373373053286358386815167/53236778589430649199510184552482353130182472536220216418345573482183465900170000000000000000000000000000",
+    "record_suffix": "9126450467054308301255427720479473298820885783361581004114809911412969281/5323677858943064919951018455248235313018247253622021641834557348218346590017",
+    "phase_local": "730116037364344664100434212314680004962605942717908025080949479894790288857978358165442651781653409983/425894228715445193596081476419858825041459780289761731346764587857467727201360000000000000000000000000000",
+    "phase_boundary": "146023207472868932820086838203993713838069252582766840817601645564360254873978358165442651781653409983/85178845743089038719216295283971765008291956057952346269352917571493545440272000000000000000000000000000",
+    "gamma_sublinear": "1/20000000000000000000000000000",
+    "cell_above_band": "106291028169520212232995260545231438935445462436822182761360615453120425161097978358165442651781653409983/212947114357722596798040738209929412520729890144880865673382293928733863600680000000000000000000000000000",
+    "prime_interval_packing": "9126450467054308301255427720479473298820885783361581004114809911412969281/5323677858943064919951018455248235313018247253622021641834557348218346590017",
+    "alpha_positive": "182529009341086166025108549085911607033352795716213164834060885210012131997978358165442651781653409983/106473557178861298399020369104964706260364945072440432836691146964366931800340000000000000000000000000000",
+    "alpha_below_one": "106291028169520212232995260555878794653331592276724219671857086079156919668342021641834557348218346590017/106473557178861298399020369104964706260364945072440432836691146964366931800340000000000000000000000000000",
+    "alpha_below_one_fourth": "26435860285374238433729983727155264958057883472393895044338725855881720818087021641834557348218346590017/106473557178861298399020369104964706260364945072440432836691146964366931800340000000000000000000000000000",
+    "delta_positive": "1/80000000000000000000000000000",
+    "delta_below_one_eighth": "9999999999999999999999999999/80000000000000000000000000000",
+    "short_record_fallback": "62030914860314731280604415396384150638707844245918644374798718811945078022702166141741516061490239649485859818814135562665867/62244511259740520075250339553375468028122833117847335744648697438922909849934279650579268098116039648975193944087911240564736",
+    "small_field_exposure": "1/10000000000000000000000000000",
+    "artificial_boundary": "2981989717045480699836670769172621166730953327650854101273426005734241869712866064925503672044655039770051/425894228715445193596081476419858825041459780289761731346764587857467727201360000000000000000000000000000",
+    "literal_scalar_guard": "1",
+    "row_product_gap": "23971789/25",
+    "balanced_prefix_above_kappa": "4277067924783060833775709136063507233168270350324066987907255989085451864333/5323677858943064919951018455248235313018247253622021641834557348218346590017000000000000000000",
+    "coordinate_movement_above_kappa": "131303043547621627070084774561342165093680020465352294893/44601490397061246283071436545296723011960832000000000000000000",
+    "compact_phase_layer_above_kappa": "42770679242506930478814026440684053876434468190222422625450538249019961295111653409983/53236778589430649199510184552482353130182472536220216418345573482183465900170000000000000000000000000000",
+    "bulk_exposure_above_kappa": "131303043547621627070084774561342165093680020465352294893/44601490397061246283071436545296723011960832000000000000000000",
+    "Gaussian_arithmetic_above_kappa": "68433086791205295481468281257065097275444090292166824552894074183532672481109653409983/85178845743089038719216295283971765008291956057952346269352917571493545440272000000000000000000000000000",
+    "scalar_work_above_kappa": "342165433977321188843113665965129560198213392712907111778958457485001591798421653409983/425894228715445193596081476419858825041459780289761731346764587857467727201360000000000000000000000000000",
+    "dimension_above_kappa": "5305424958008956307625575524590337200196314618118805712994598078719587639362255989085451864333/5323677858943064919951018455248235313018247253622021641834557348218346590017000000000000000000"
+  },
+  "controls": [
+    "next_grid",
+    "zero_eta",
+    "zero_beta",
+    "unit_beta"
+  ],
+  "scope": "Conditional R480 seven-slot k8 construction with a source-bound replica count. The owner map attains the fixed-inventory bin bound. The full conservative invoice, native moment correction, PR589 bit surcharge and 47 outer inequalities are checked. Local admission and all-size/compiler, mutable-source, whole-call hosting, precision/tape, exact-recovery, analytic-transfer and bit H1-H5 assumptions remain."
+}
diff --git a/research/complex-routing-leaf-fusion/evidence/SUPPLIER-RESULT.json b/research/complex-routing-leaf-fusion/evidence/SUPPLIER-RESULT.json
new file mode 100644
index 0000000000..ee5d876a1c
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/evidence/SUPPLIER-RESULT.json
@@ -0,0 +1,98 @@
+{
+  "status": "PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION",
+  "kappa": "1714313057414451/1000000000000000000",
+  "kappa_decimal": "0.001714313057414451",
+  "manifest_sha256": "82a1e95d70100a690834c88cdf6bfc0d161894f6823904aebbe04d65e5e7b05d",
+  "native_reuse": {
+    "base": true,
+    "extra": true
+  },
+  "provider_verification": "PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION",
+  "roles": 276390,
+  "prefix_bits": 1443,
+  "charged_prefix_bits": 2048,
+  "physical_row_coefficient": 19545,
+  "row_limit": 20161,
+  "controls": {
+    "admission": 114,
+    "bit": 12,
+    "controller": 15,
+    "independent_owner": 8,
+    "geometry": 6
+  },
+  "stages": [
+    {
+      "name": "fine-engine-oracle",
+      "exit_code": 0,
+      "seconds": 1.8023287079995498,
+      "log_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3"
+    },
+    {
+      "name": "retained-provider-and-parent-admission",
+      "reused_receipt": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4",
+      "exit_code": 0,
+      "seconds": 0.19164125001407228
+    },
+    {
+      "name": "rebuild-words-566",
+      "exit_code": 0,
+      "seconds": 1.4432412079768255,
+      "log_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f"
+    },
+    {
+      "name": "reconstruct-owners",
+      "exit_code": 0,
+      "seconds": 2.904279749986017,
+      "log_sha256": "590db66077dbde02b0f3bf2d5d0e0b44ce5e9e435874be38e5ceaa753458684e"
+    },
+    {
+      "name": "lift-parent",
+      "exit_code": 0,
+      "seconds": 5.153019958001096,
+      "log_sha256": "9578ab17094f120d54af46f9e0601714c09a2978faa0d7949823099d06d931d4"
+    },
+    {
+      "name": "rebuild-borrow-words",
+      "exit_code": 0,
+      "seconds": 84.05528416699963,
+      "log_sha256": "8983c97d1ce6c9f06a9f32898096c62d95985a5b3f1b1f6f7984bd918aacd183"
+    },
+    {
+      "name": "audit-local-566-base",
+      "exit_code": 0,
+      "seconds": 0.4484120420238469,
+      "log_sha256": "2b1e0417fabc0f2e123fdd964fac0100461dfb94af00ef0d9fd060fad1a96162"
+    },
+    {
+      "name": "audit-local-566-extra",
+      "exit_code": 0,
+      "seconds": 0.46608199999900535,
+      "log_sha256": "23c2e64f554feb4e97bac263b4dce016fe5a33e1517c26b80ee769468667700f"
+    },
+    {
+      "name": "rebind-566",
+      "exit_code": 0,
+      "seconds": 0.43530408301739953,
+      "log_sha256": "d5992c9e0b86c0d1a4dd774b488fdf0b7f910bfec71bc14394d7409c42948cd0"
+    },
+    {
+      "name": "lemmag-labels",
+      "exit_code": 0,
+      "seconds": 15.689303124992875,
+      "log_sha256": "91fafdc76824e278546bb51465cf84d60a3513df3f2e8ab9854919c416cd3469"
+    },
+    {
+      "name": "strict-t74",
+      "exit_code": 0,
+      "seconds": 40.39444866697886,
+      "log_sha256": "78e5d30c4da63c51398b4569fc097ac612915471008b884426d0b023e62ff41d"
+    },
+    {
+      "name": "geometry-controls",
+      "exit_code": 0,
+      "seconds": 0.22379704201011918,
+      "log_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9"
+    }
+  ],
+  "scope": "Conditional finite construction only. All-size compiler, common-label/mutable-source realization, whole-call hosting, precision/tape, exact recovery, analytic transfer, PR559 recurrence correction and PR589 bit H1-H5 assumptions remain. No unconditional theorem, full Lean certification, or global packing claim."
+}
diff --git a/research/complex-routing-leaf-fusion/exact_moment_checker.py b/research/complex-routing-leaf-fusion/exact_moment_checker.py
new file mode 100644
index 0000000000..3f9ff81be4
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/exact_moment_checker.py
@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""Independent rational pricing of the credited PR2733/2751 composition.
+
+The atanh/Taylor method is standard and follows the retained exact-moment
+lineage, including Tekalign's PR2751. This implementation imports no producer
+or predecessor arithmetic. Finite pricing is not native or outer admission.
+David Arias, with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+import argparse
+from fractions import Fraction as Q
+from functools import lru_cache
+import json
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+DIMENSION, LIVE, CALLS, MASS = 73, 66304, 666, 4816512
+LOW = Q("0.001717256973467002308270")
+HIGH = LOW + Q(1, 10**24)
+KAPPA = LOW - Q(1, 10**46) - Q(1, 10**70)
+SCALE = 2**160
+
+
+def need(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def profile(raw):
+    need(isinstance(raw, dict) and raw, "nonempty rank histogram")
+    out = {}
+    for key, value in raw.items():
+        need(isinstance(key, str) and key.isdecimal(), "decimal rank key")
+        rank = int(key)
+        need(str(rank) == key and 0 < rank < DIMENSION, "canonical positive rank")
+        need(type(value) is int and value > 0, "positive integer multiplicity")
+        out[rank] = value
+    return out
+
+
+@lru_cache(None)
+def logarithm(x):
+    """Rational enclosure of log(x), x>=1, using 36 positive atanh terms."""
+    need(x >= 1, "logarithm input")
+    exponent = 0
+    reduced = x
+    while reduced >= 2:
+        reduced /= 2
+        exponent += 1
+
+    def core(y):
+        z = (y-1)/(y+1)
+        need(0 <= z <= Q(1, 3), "atanh reduction")
+        lo = 2*sum((z**(2*j+1)/Q(2*j+1) for j in range(36)), Q(0))
+        tail = 2*z**73/(73*(1-z*z))
+        return lo, lo+tail
+
+    lo, hi = core(reduced)
+    two_lo, two_hi = core(Q(2))
+    return lo+exponent*two_lo, hi+exponent*two_hi
+
+
+def exponential(x):
+    """Positive Taylor polynomial through degree 20 plus a geometric tail."""
+    need(0 <= x < Q(1, 100), "small exponential input")
+    term = total = Q(1)
+    for degree in range(1, 21):
+        term = term*x/degree
+        total += term
+    next_term = term*x/21
+    tail = next_term/(1-x/22)
+    return total, total+tail
+
+
+def moment(histogram, saving, live=LIVE):
+    need(type(live) is int and live == LIVE, "source-bound live normalization")
+    need(Q(0) < saving < Q(1, 500), "certified saving domain")
+    lo = hi = Q(0)
+    for rank, count in sorted(histogram.items()):
+        log_lo, log_hi = logarithm(Q(DIMENSION, rank))
+        exp_lo, _ = exponential(saving*log_lo)
+        _, exp_hi = exponential(saving*log_hi)
+        weight = Q(count*rank, DIMENSION*live)
+        lo += weight*exp_lo
+        hi += weight*exp_hi
+    return lo, hi
+
+
+def floor(x):
+    return x.numerator//x.denominator
+
+
+def dyadic(lo, hi):
+    """Small exact outward display; acceptance uses the full rational values."""
+    return {"lower_numerator": floor(lo*SCALE),
+            "upper_numerator": -floor(-hi*SCALE), "denominator": SCALE}
+
+
+def require_bracket(histogram, low, high):
+    need(low < high, "strictly ordered root endpoints")
+    a, b = moment(histogram, low)
+    c, d = moment(histogram, high)
+    need(b < 1 < c, "strict adjacent root bracket")
+    return {"lower_endpoint": str(low), "upper_endpoint": str(high),
+            "lower_moment_minus_one": dyadic(a-1, b-1),
+            "upper_moment_minus_one": dyadic(c-1, d-1)}
+
+
+def check(candidate_raw, source_raw, claim):
+    candidate, source = profile(candidate_raw), profile(source_raw)
+    need(sum(r*n for r, n in source.items()) == MASS, "source paid mass")
+    expected = dict(source)
+    expected[1] -= 2*CALLS
+    expected[2] += CALLS
+    need(candidate == expected, "complete 666-call H2-minus-2H1 invoice")
+    need(sum(r*n for r, n in candidate.items()) == MASS, "candidate paid mass")
+    need(Q(claim["complex_lower"]) == LOW and Q(claim["complex_upper"]) == HIGH,
+         "claim root endpoints")
+    need(Q(claim["kappa"]) == KAPPA, "conditional modern outer target")
+    need(profile(claim["profile"]) == candidate, "claim full profile")
+    bracket = require_bracket(candidate, LOW, HIGH)
+    source_lo, source_hi = moment(source, LOW)
+    need(source_lo > 1, "unchanged source does not certify the new endpoint")
+    # An exact sign comparison is independent of the transcendental engine:
+    # 0<p<1 implies 2^p<2. Thus 666*(2^p-2)/(W*73^p)<0.
+    need(0 < LOW < HIGH < 1, "strict concavity domain")
+    rejected = []
+
+    def reject(name, operation):
+        try:
+            operation()
+        except ValueError:
+            rejected.append(name)
+        else:
+            raise ValueError("control accepted: "+name)
+
+    reject("unmodified_source_at_new_endpoint", lambda: require_bracket(source, LOW, HIGH))
+    reject("reversed_root_endpoints", lambda: require_bracket(candidate, HIGH, LOW))
+    reject("upper_endpoint_admitted_as_lower",
+           lambda: require_bracket(candidate, HIGH, HIGH+Q(1, 10**21)))
+    reverse = dict(source)
+    reverse[1] += 2*CALLS
+    reverse[2] -= CALLS
+    need(sum(r*n for r, n in reverse.items()) == MASS, "control keeps paid mass")
+    reject("mass_preserving_reversed_fusion", lambda: require_bracket(reverse, LOW, HIGH))
+    reject("changed_live_denominator", lambda: moment(candidate, LOW, LIVE+1))
+    # Check the intervals on exact algebraic constants, not merely their signs
+    # at this one candidate. No logarithm/exp floating-point oracle is used.
+    need(logarithm(Q(1)) == (0, 0), "log one control")
+    need(exponential(Q(0)) == (1, 1), "exp zero control")
+    root2_lo, root2_hi = logarithm(Q(2))
+    root4_lo, root4_hi = logarithm(Q(4))
+    need((root4_lo, root4_hi) == (2*root2_lo, 2*root2_hi), "exact log scaling")
+    return {"status": "PASS_EXACT_COMPOSED_FRAME_MOMENT", "dimension": DIMENSION,
+            "live": LIVE, "call_equivalents": CALLS, "paid_mass": MASS,
+            "profile": {str(r): n for r, n in sorted(candidate.items())},
+            "bracket": bracket, "conditional_kappa": str(KAPPA),
+            "source_moment_at_candidate_lower_minus_one": dyadic(source_lo-1, source_hi-1),
+            "controls_rejected": rejected,
+            "scope": "Independent exact finite moment and invoice arithmetic; native, hosting and modern outer admission are separate."}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--candidate-profile", type=Path, default=HERE/"PROFILE.json")
+    parser.add_argument("--source-profile", type=Path, default=HERE/"vendor/pr2751/PROFILE.json")
+    parser.add_argument("--claim", type=Path, default=HERE/"CLAIM.json")
+    args = parser.parse_args()
+    read = lambda path: json.loads(path.read_text())
+    print(json.dumps(check(read(args.candidate_profile), read(args.source_profile), read(args.claim)),
+                     sort_keys=True, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/complex-routing-leaf-fusion/full_replay.py b/research/complex-routing-leaf-fusion/full_replay.py
new file mode 100644
index 0000000000..7ab53356c1
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/full_replay.py
@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Derived from Tekalign / PR2751 full_replay.py, with substantial OpenAI Codex assistance.
+# This derivative composes Marius-Paul Dumitrean / PR2733's exact frame refit.
+"""Cold reproduction of the twelve-source / five-frame composition.
+
+Default: authenticated source download, fresh native providers and retained
+parent admission, then the complete original supplier/release verifier. An
+explicit --prepared-native-cache must match every published reuse file hash.
+All large/generated artifacts remain under a fresh external --work directory.
+"""
+import argparse
+from concurrent.futures import ThreadPoolExecutor
+from fractions import Fraction as Q
+import gzip
+import hashlib
+import importlib
+import json
+import os
+from pathlib import Path, PurePosixPath
+import platform
+import shutil
+import subprocess
+import sys
+import tarfile
+import threading
+import time
+from urllib.parse import quote
+from urllib.request import Request, urlopen
+
+from derive_runtime import derive_runtime
+
+HERE = Path(__file__).resolve().parent
+REPOSITORY = HERE.parents[1]
+STEPS = ['native', 'ledgers', 'local-replay', 'wrappers', 'phases']
+
+
+def need(ok, why):
+    if not ok:
+        raise RuntimeError(why)
+
+
+def sha(path):
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def read(path):
+    data = path.read_bytes()
+    return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data)
+
+
+def write(path, value):
+    path.write_text(json.dumps(value, sort_keys=True, indent=2) + '\n')
+
+
+def tree(root, exclude=()):
+    result = {}
+    for path in sorted(root.rglob('*')):
+        need(not path.is_symlink(), 'unauthenticated symlink: ' + str(path))
+        name = path.relative_to(root).as_posix()
+        if path.is_file() and name not in exclude:
+            result[name] = sha(path)
+    return result
+
+
+def safe(name):
+    path = PurePosixPath(name)
+    need(isinstance(name, str) and '\\' not in name and path.parts and not path.is_absolute()
+         and '..' not in path.parts and path.as_posix() == name, 'unsafe source path')
+
+
+def download(url, expected):
+    for attempt in range(3):
+        try:
+            req = Request(url, headers={'User-Agent': 'integer-mult-prelife-priority/1', 'Accept-Encoding': 'identity'})
+            with urlopen(req, timeout=90) as response:
+                body = response.read()
+            need(hashlib.sha256(body).hexdigest() == expected, 'download hash mismatch')
+            return body
+        except (OSError, RuntimeError):
+            if attempt == 2:
+                raise
+            time.sleep(attempt + 1)
+
+
+def source_copy(source, destination, pins, jobs):
+    destination.mkdir()
+    entries = {'MANIFEST.json': pins['manifest_sha256'], **pins['files']}
+    need(len(pins['files']) == pins['count'] == 491, 'source file count')
+
+    def copy(item):
+        name, digest = item
+        safe(name)
+        target = destination / name
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if source:
+            need(not (source / name).is_symlink(), 'source symlink')
+            body = (source / name).read_bytes()
+            need(hashlib.sha256(body).hexdigest() == digest, 'source bytes: ' + name)
+        else:
+            body = download(pins['base_url'] + quote(name, safe='/'), digest)
+        target.write_bytes(body)
+
+    with ThreadPoolExecutor(max_workers=min(jobs, 8)) as pool:
+        for _ in pool.map(copy, sorted(entries.items())):
+            pass
+    need(read(destination / 'MANIFEST.json') == pins['files']
+         and tree(destination) == entries, 'complete source authentication')
+
+
+def bind_native(entry, word):
+    need(gzip.decompress((entry / 'local/FULL-WORD.json.gz').read_bytes()) == gzip.decompress(word.read_bytes()),
+         'native complete word binding')
+    stages = read(entry / 'STEPS.json')
+    need([s['step'] for s in stages] == STEPS and all(s['exit_code'] == 0 for s in stages), 'native stage coverage')
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--source', type=Path, help='Exact original PR2679 package directory; otherwise download pinned files.')
+    ap.add_argument('--work', type=Path, required=True)
+    ap.add_argument('--composition-source', type=Path, help='Exact PR2751 package; otherwise fetch four pinned composition files.')
+    ap.add_argument('--prepared-native-cache', type=Path, help='Explicit reuse of the complete published pinned cache.')
+    ap.add_argument('--jobs', type=int, default=4)
+    a = ap.parse_args()
+    need(not sys.flags.optimize and a.jobs > 0, 'enabled assertions and positive jobs required')
+    versions = {}
+    for name in ('numpy', 'sympy', 'scipy', 'mpmath'):
+        try:
+            versions[name] = str(importlib.import_module(name).__version__)
+        except ImportError as exc:
+            raise RuntimeError('install requirements.txt in this Python environment before full replay') from exc
+    need(versions['sympy'] == '1.14.0', 'pinned predecessor evidence requires sympy==1.14.0')
+    work = a.work.resolve()
+    need(not work.exists() and not work.is_relative_to(REPOSITORY), 'fresh external work required')
+    for path in (a.source, a.composition_source, a.prepared_native_cache):
+        need(path is None or (path.is_dir() and not work.is_relative_to(path.resolve())), 'input/work separation')
+    config, claim = read(HERE / 'FULL-REPLAY-PINS.json'), read(HERE / 'CLAIM.json')
+    reuse = read(HERE / 'evidence/NATIVE-RECEIPT.json') if a.prepared_native_cache else None
+    work.mkdir(parents=True)
+    composition = work / 'composition'
+    composition.mkdir()
+    for name, expected in config['files'].items():
+        safe(name)
+        body = ((a.composition_source / name).read_bytes() if a.composition_source
+                else download(config['base_url'] + quote(name, safe='/'), expected))
+        need(hashlib.sha256(body).hexdigest() == expected, 'composition source bytes: ' + name)
+        destination = composition / name
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        destination.write_bytes(body)
+    pins = read(composition / 'SOURCE-FILES.json')
+    env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONUTF8='1', PYTHONINTMAXSTRDIGITS='0',
+               OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1')
+    for name in ('PYTHONOPTIMIZE', 'WITNESS_SPEC', 'WITNESS_DISCOVER', 'WITNESS_RECORD'):
+        env.pop(name, None)
+    stages, lock = [], threading.Lock()
+    started = time.monotonic()
+
+    def run(name, script, *args):
+        begin = time.monotonic()
+        log = work / (name + '.log')
+        command = [sys.executable, '-B', str(script), *map(str, args)]
+        with log.open('w') as output:
+            result = subprocess.run(command, env=env, cwd=work, stdin=subprocess.DEVNULL,
+                                    stdout=output, stderr=subprocess.STDOUT)
+        with lock:
+            stages.append(dict(name=name, command=command, exit_code=result.returncode,
+                               script_sha256=sha(script), seconds=time.monotonic()-begin, log_sha256=sha(log)))
+            write(work / 'STAGES.json', stages)
+        need(result.returncode == 0, 'failed ' + name + '; see ' + str(log))
+        print('PASS', name, flush=True)
+
+    run('literal-review', HERE / 'verify.py')
+    source = work / 'source'
+    source_copy(a.source.resolve() if a.source else None, source, pins, a.jobs)
+    overlay = read(composition / 'OVERLAY-PINS.json')
+    need(sha(source/'MANIFEST.json') == overlay['original_manifest_sha256'], 'overlay base manifest')
+    need(sha(composition/'DERIVATIVE-OVERLAY.tar.gz') == overlay['archive_sha256'], 'overlay archive')
+    with tarfile.open(composition/'DERIVATIVE-OVERLAY.tar.gz') as archive:
+        members=archive.getmembers()
+        need(set(m.name for m in members)==set(overlay['files']) and len(members)==len(overlay['files']), 'exact overlay paths')
+        for member in members:
+            safe(member.name);need(member.isfile(), 'regular overlay file')
+            body=archive.extractfile(member).read()
+            need(hashlib.sha256(body).hexdigest()==overlay['files'][member.name], 'overlay member hash')
+            (source/member.name).write_bytes(body)
+    need(sha(source/'MANIFEST.json')==overlay['derived_manifest_sha256'] and
+         tree(source,('MANIFEST.json',))==read(source/'MANIFEST.json'), 'complete derived source tree')
+    changes = derive_runtime(source, HERE)
+    need(sha(source/'MANIFEST.json') == config['derived_manifest_sha256']
+         and tree(source, ('MANIFEST.json',)) == read(source/'MANIFEST.json'), 'complete refit source tree')
+    write(work/'DERIVATION.json', changes)
+    pins=dict(pins,commit=config['source_commit'],manifest_sha256=config['derived_manifest_sha256'])
+    # Only source bindings and the strict predecessor comparison change in the
+    # authenticated admission driver. Its physical costs and controls remain.
+    admission = (composition/'workflow/admit.py').read_text()
+    edits = [("SOURCE_COMMIT = 'local-joint12-pr2733'", "SOURCE_COMMIT = " + repr(config['source_commit'])),
+             ("SOURCE_MANIFEST = '7980dbde79b63de4093cde89d1564a18c6bf16a2e35d810e38cf9797fe09e0cf'",
+              "SOURCE_MANIFEST = " + repr(config['derived_manifest_sha256'])),
+             ("previous = Q('0.0017161404259974415161889999999999999999999998999999999999999999999999')",
+              "previous = Q(" + repr(read(HERE/'vendor/pr2751/CLAIM.json')['kappa']) + ")")]
+    for before, after in edits:
+        need(admission.count(before) == 1, 'exact admission patch preimage')
+        admission = admission.replace(before, after)
+    (work/'admit.py').write_text(admission)
+    write(work/'ADMISSION-CHANGES.json', edits)
+
+    cache = work / 'native-cache'
+    if a.prepared_native_cache:
+        need(tree(a.prepared_native_cache.resolve()) == reuse['cache_files'], 'published complete cache pins')
+        shutil.copytree(a.prepared_native_cache.resolve(), cache)
+        native_receipt = reuse
+    else:
+        cache.mkdir()
+        layout = work / 'retained-layout'
+        layout.mkdir()
+        old = source / 'vendor/pr1297'
+        with tarfile.open(old / 'upstream-layout.tar.gz') as archive:
+            need(all(m.isfile() and not Path(m.name).is_absolute() and '..' not in Path(m.name).parts
+                     for m in archive.getmembers()), 'retained archive paths')
+            archive.extractall(layout, filter='data')
+        retained_driver = layout / 'joint1148-round45/source/research/k8-eight-ends/replay_native.py'
+        words = {'base': source / 'new/borrow/words/BORROW-WORD-43base.json.gz',
+                 'extra': source / 'new/borrow/words/BORROW-WORD-43extra.json.gz',
+                 'retained-base': old / 'gauge44-word.json.gz', 'retained-extra': old / 'extra-word.json.gz'}
+
+        def fresh_native(tag):
+            word = words[tag]
+            entry = cache / sha(word)
+            script = retained_driver if tag.startswith('retained-') else source / 'new/run_native_borrow.py'
+            run('native-' + tag, script, word, entry)
+            bind_native(entry, word)
+            write(entry / 'CACHE.json', dict(word_sha256=sha(word), files=tree(entry)))
+
+        with ThreadPoolExecutor(max_workers=min(a.jobs, 4)) as pool:
+            for _ in pool.map(fresh_native, words):
+                pass
+        run('retained-parent', old / 'verify.py', '--work', work / 'retained-parent',
+            '--base-native-from', cache / sha(words['retained-base']),
+            '--extra-native-from', cache / sha(words['retained-extra']))
+        parent = read(work / 'retained-parent/RESULT.json')
+        need(parent['status'] == 'PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION'
+             and parent['kappa'] == read(old / 'CLAIM.json')['kappa'], 'fresh retained parent admission')
+        pm = sha(old / 'MANIFEST.json')
+        receipts = cache / '_receipts' / pm
+        receipts.mkdir(parents=True)
+        for name in ('RESULT.json', 'STAGES.json'):
+            shutil.copy2(work / 'retained-parent' / name, receipts / name)
+        write(receipts / 'RECEIPT.json', dict(schema='parent-receipt/1', vendor_manifest_sha256=pm,
+              claim_sha256=sha(old / 'CLAIM.json'), words={tag:sha(words['retained-'+tag]) for tag in ('base','extra')},
+              files={name:sha(receipts / name) for name in ('RESULT.json','STAGES.json')}))
+        providers = {tag:dict(word_sha256=sha(words[tag]), complete_native_files=tree(cache / sha(words[tag]), ('CACHE.json',)))
+                     for tag in ('base','extra')}
+        native_receipt = dict(status='PASS_COMPOSED_FRESH_NATIVE_PROVIDERS_AND_AUTHENTICATED_CACHE',
+                              source_commit=pins['commit'], manifest_sha256=pins['manifest_sha256'], providers=providers,
+                              retained_parent_receipt_sha256=sha(receipts / 'RECEIPT.json'), cache_files=tree(cache))
+    write(work / 'NATIVE-RECEIPT.json', native_receipt)
+    run('complete-admission', work / 'admit.py', '--source', source,
+        '--fill', HERE / 'vendor/pr2751/inputs/FILL.json.gz', '--order', HERE / 'vendor/pr2751/inputs/ORDER.json',
+        '--native-cache', cache, '--native-receipt', work / 'NATIVE-RECEIPT.json',
+        '--work', work / 'admission', '--jobs', a.jobs)
+    result = read(work / 'admission/RESULT.json')
+    need(result['status'] == 'PASS_COMPOSED_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE'
+         and Q(result['kappa']) == Q(claim['kappa']) and Q(result['complex_lower']) == Q(claim['complex_lower']),
+         'published complete claim binding')
+    need(result['profile'] == {str(k):v for k,v in read(HERE / 'CLAIM.json')['profile'].items()}, 'published complete profile binding')
+    result.update(status='PASS_T74_JOINT_TWELVE_REFIT_COLD_COMPLETE_RELEASE', explicit_native_cache_reuse=bool(a.prepared_native_cache),
+                  source_files_sha256=sha(composition / 'SOURCE-FILES.json'), native_receipt_sha256=sha(work / 'NATIVE-RECEIPT.json'),
+                  cold_stages=stages, cold_seconds=time.monotonic()-started,
+                  environment=dict(python=platform.python_version(), executable=sys.executable, versions=versions))
+    write(work / 'RESULT.json', result)
+    print(result['status'], result['kappa_decimal'], flush=True)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/complex-routing-leaf-fusion/generate.py b/research/complex-routing-leaf-fusion/generate.py
new file mode 100644
index 0000000000..b6aeec7004
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/generate.py
@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""Compose Dumitrean's PR2733 refit with Tekalign's PR2751 joint-twelve word.
+Does not certify native/global/outer admission. Outputs an exact word delta.
+"""
+import argparse,copy,gzip,hashlib,json
+from pathlib import Path
+SOURCE_HEAD='4cfbb0cc8314d7fb4e8e754545a49a42eb590a69'
+REFIT_HEAD='a63c55ff56aaa8645d64d1162d1f017b59ded42a'
+PINS={'base':'ae8b6b4d62a9da29331062fae1bd68b0341edf83152f5a5ef50c5109ba578f9a','extra':'1bb44a73d5841afb954b49ae94dba2e0c536b1eea9436ae5d89de87d8a04e127'}
+OLD=['add',393,515,1,1,[259,132,66,36,16,9]]
+NEW=['add',393,515,1,1,[259,148,66,36,9]]
+EXPECTED={'1':2366,'2':646,'3':297,'4':120,'5':26,'8':8}
+def need(x,m):
+ if not x:raise ValueError(m)
+def canonical(x):return json.dumps(x,sort_keys=True,separators=(',',':')).encode()
+def patch(w):
+ need(w['report']['local_profile']==EXPECTED,'Exact source local profile')
+ sites=[i for i,g in enumerate(w['B']) if g==OLD]
+ need(sites==[1151],'Exact unique source B1151')
+ out=copy.deepcopy(w);out['B'][1151]=copy.deepcopy(NEW)
+ out['report']['local_profile']['1']-=2;out['report']['local_profile']['2']+=1
+ return out
+if __name__=='__main__':
+ ap=argparse.ArgumentParser();ap.add_argument('--source',type=Path,required=True);ap.add_argument('--out',type=Path,required=True);a=ap.parse_args()
+ need(not a.out.exists(),'Output directory must be fresh')
+ outputs={};receipts={}
+ for tag,pin in PINS.items():
+  raw=(a.source/f'inputs/WORD-{tag}.json.gz').read_bytes();need(hashlib.sha256(raw).hexdigest()==pin,'Source bytes '+tag)
+  before=json.loads(gzip.decompress(raw));after=patch(before)
+  outputs[tag]=canonical(after)
+  receipts[tag]={'source_sha256':pin,'canonical_source_sha256':hashlib.sha256(canonical(before)).hexdigest(),'canonical_result_sha256':hashlib.sha256(outputs[tag]).hexdigest(),'section':'B','index':1151,'old':OLD,'new':NEW,'local_profile':after['report']['local_profile']}
+ sourceprofile=json.loads((a.source/'PROFILE.json').read_bytes());newprofile=sourceprofile.copy();newprofile['1']-=1332;newprofile['2']+=666
+ need(sum(int(r)*n for r,n in newprofile.items())==4816512,'Preserved full paid mass')
+ a.out.mkdir()
+ for tag,data in outputs.items():(a.out/f'WORD-{tag}.json.gz').write_bytes(gzip.compress(data,mtime=0))
+ receipt={'status':'EXACT_CREDITED_FRAME_REFIT_COMPOSITION','source_head':SOURCE_HEAD,'refit_head':REFIT_HEAD,'providers':receipts,'global_delta':{'1':-1332,'2':666},'global_profile':newprofile,'source_refit_authorship':'Marius-Paul Dumitrean PR2733; joint twelve-source recovery Tekalign PR2751','scope':'Generator only; independent algebra/frame checks and native/global/outer replay remain separate.'}
+ (a.out/'PATCH.json').write_text(json.dumps(receipt,indent=2)+'\n')
+ (a.out/'PROFILE.json').write_text(json.dumps(newprofile,indent=2)+'\n')
+ print(receipt['status'])
diff --git a/research/complex-routing-leaf-fusion/independent_check.py b/research/complex-routing-leaf-fusion/independent_check.py
new file mode 100644
index 0000000000..8cd75aec6f
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/independent_check.py
@@ -0,0 +1,324 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# David Arias, with substantial OpenAI Codex assistance.
+"""Independent literal-word replay for the credited PR2733/PR2751 composition.
+
+Uses only Python's standard library. No producer, predecessor checker, cached
+profile, or native audit is imported. Frames use binary Gaussian elimination;
+linear endpoints use sparse rational expressions in free noncommuting warp
+symbols. This verifies a finite construction, not the conditional analytic or
+fixed-tape assumptions of the complete multiplication theorem.
+"""
+from __future__ import annotations
+
+import argparse
+from collections import Counter, defaultdict
+import copy
+from fractions import Fraction
+import gzip
+import json
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+OLD_FRAME = [259, 132, 66, 36, 16, 9]
+NEW_FRAME = [259, 148, 66, 36, 9]
+GATE = 1151
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def read(path):
+    raw = path.read_bytes()
+    return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw)
+
+
+def normal(vectors):
+    """Canonical reduced binary row basis, with descending pivots."""
+    rows = {}
+    for vector in vectors:
+        require(isinstance(vector, int) and 0 <= vector < 512, 'binary coordinate')
+        for pivot in sorted(rows, reverse=True):
+            if vector >> pivot & 1:
+                vector ^= rows[pivot]
+        if vector:
+            pivot = vector.bit_length() - 1
+            for old in list(rows):
+                if rows[old] >> pivot & 1:
+                    rows[old] ^= vector
+            rows[pivot] = vector
+    return tuple(rows[p] for p in sorted(rows, reverse=True))
+
+
+def contained(small, large):
+    return normal((*large, *small)) == large
+
+
+FULL = normal(1 << i for i in range(9))
+
+
+def image(columns, vector):
+    value = 0
+    for i, column in enumerate(columns):
+        if vector >> i & 1:
+            value ^= column
+    return value
+
+
+def touched(gate):
+    return gate[1:3] if gate[0] == 'add' else gate[1:2]
+
+
+def endpoints(word):
+    live = set(range(704)) - set(word['removed'])
+    start = {r: normal([word['ports'][r]] if r < 112 else
+                       word['start_extra'].get(str(r), [])) for r in live}
+    finish = {r: FULL for r in live}
+    for i, port in enumerate(word['ports']):
+        require(port != 0, 'nonzero target port')
+        pivot = (port & -port).bit_length() - 1
+        finish[112 + i] = normal((1 << j) ^ (((port >> j) & 1) << pivot)
+                                 for j in range(9) if j != pivot)
+    for r, frame in word['helper_final'].items():
+        finish[int(r)] = normal(frame)
+    return start, finish
+
+
+def frame_replay(word):
+    start, finish = endpoints(word)
+    current = dict(start)
+    paid = Counter()
+    history = defaultdict(list)
+
+    def climb(r, frame, location):
+        frame = normal(frame)
+        require(contained(current[r], frame), f'frame inclusion at {location}/{r}')
+        degree = len(frame) - len(current[r])
+        if degree:
+            paid[degree] += 1
+        history[r].append((location, len(current[r]), len(frame)))
+        current[r] = frame
+
+    def warp(r, op, old, new, location):
+        columns = word['warps'][abs(op) - 1][2]
+        require(len(normal(columns)) == 9, f'invertible warp {op}')
+        old, new = normal(old), normal(new)
+        require(current[r] == old, f'warp entrance {location}/{r}')
+        before, after = (old, new) if op > 0 else (new, old)
+        require(normal(image(columns, v) for v in before) == after,
+                f'warp transported frame {location}/{r}')
+        current[r] = new
+        history[r].append((location, len(old), len(new)))
+
+    def gate(g, location):
+        if g[0] == 'warp':
+            warp(*g[1:], location)
+        else:
+            require(g[0] in ('add', 'scale'), 'known scalar operation')
+            for r in touched(g):
+                climb(r, g[-1], location)
+
+    for i, g in enumerate(word['A']):
+        gate(g, f'A{i}')
+    levels = {int(t): normal(vs) for t, vs in word['target_levels'].items()}
+    require(all(current[112 + t] == levels.get(t, ()) for t in range(112)),
+            'all cut target entrances')
+    # The native central child pays the nested descent once; its other side
+    # retains the center's start chart for the B-side ascent representation.
+    for r, frame in zip(word['centers'], word['center_frames']):
+        previous = normal(frame)
+        require(current[r] == previous, 'central source entrance')
+        readers = {levels.get(g[1] - 112, ()) for g in word['cut'] if g[2] == r}
+        for target in sorted(readers, key=lambda x: (-len(x), x)):
+            require(contained(target, previous), 'nested central descent')
+            if len(previous) != len(target):
+                paid[len(previous) - len(target)] += 1
+            previous = target
+    warps = defaultdict(list)
+    for op, entry in enumerate(word['warps'], 1):
+        warps[entry[0]].append((op, entry))
+    for i in range(len(word['B']) + 1):
+        for op, (_, r, _, old, new) in warps[i]:
+            warp(r, op, old, new, f'warp{op}')
+        if i < len(word['B']):
+            gate(word['B'][i], f'B{i}')
+    for i, g in enumerate(word['restore']):
+        gate(g, f'restore{i}')
+    for r in sorted(current):
+        climb(r, finish[r], 'endpoint')
+    inventory = Counter(len(finish[r]) - len(start[r]) for r in current if r >= 224)
+    require(dict(paid) == {int(k): v for k, v in word['report']['local_profile'].items()},
+            'complete paid profile, including endpoint climbs')
+    require(dict(inventory) == {int(k): v for k, v in word['report']['width_inventory'].items()},
+            'helper endpoint width inventory')
+    return paid, history
+
+
+def reduced(left, right):
+    """Multiply free-group words, stored with the newest operation first."""
+    result = list(left)
+    for symbol in right:
+        if result and result[-1] == -symbol:
+            result.pop()
+        else:
+            result.append(symbol)
+    return tuple(result)
+
+
+def scalar_replay(word, dual):
+    live = set(range(704)) - set(word['removed'])
+    cold = set(map(int, word['helper_final']))
+    rows = {r: {(r, ()): Fraction(1)} for r in live}
+    rows.update({704 + r: {} for r in cold})
+
+    def add(target, source, coefficient, operator=()):
+        for (origin, old), value in list(rows[source].items()):
+            term = (origin, reduced(operator, old))
+            total = rows[target].get(term, Fraction(0)) + coefficient * value
+            if total:
+                rows[target][term] = total
+            else:
+                rows[target].pop(term, None)
+
+    def dual_symbol(symbol):
+        return (abs(symbol) + 1000) * (1 if symbol > 0 else -1)
+
+    def apply(g):
+        kind = g[0]
+        if kind == 'add':
+            target, source, numerator, denominator = g[1:5]
+            coefficient = Fraction(numerator, denominator)
+            require(target != source, 'distinct ADD registers')
+            if dual:
+                target, source, coefficient = source, target, -coefficient
+            add(target, source, coefficient)
+        elif kind == 'scale':
+            r, numerator, denominator = g[1:4]
+            coefficient = Fraction(numerator, denominator)
+            require(coefficient != 0, 'invertible scalar')
+            if dual:
+                coefficient = 1 / coefficient
+            rows[r] = {term: coefficient * value for term, value in rows[r].items()}
+        elif kind == 'warp':
+            r, symbol = g[1:3]
+            if not dual and 47 <= symbol <= 58:
+                require(rows[r] == {(r, ()): Fraction(1)}, 'recovered source lender')
+            if dual:
+                symbol = dual_symbol(symbol)
+            rows[r] = {(origin, reduced((symbol,), old)): value
+                       for (origin, old), value in rows[r].items()}
+        else:
+            raise ValueError(f'unknown scalar operation {kind}')
+
+    for correction in word['initial_corrections']:
+        target, source = correction['target'], correction['source']
+        coefficient = Fraction(correction['coefficient'])
+        operator = tuple(correction['operator_word'])
+        if dual:
+            target, source, coefficient = source, target, -coefficient
+            operator = tuple(-dual_symbol(x) for x in reversed(operator))
+        add(target, source, coefficient, operator)
+    for section in ('precondition', 'compensation', 'A', 'cut'):
+        for g in word[section]:
+            apply(g)
+    warps = defaultdict(list)
+    for op, entry in enumerate(word['warps'], 1):
+        warps[entry[0]].append(['warp', entry[1], op])
+    for i in range(len(word['B']) + 1):
+        for g in warps[i]:
+            apply(g)
+        if i < len(word['B']):
+            apply(word['B'][i])
+    for g in word['restore']:
+        apply(g)
+    if not dual:
+        for r in cold:
+            require(rows[r] == {(r, ()): Fraction(1)}, 'dirty helper restored before cleanup')
+        for t in range(112):
+            require(rows[112 + t] == {(112 + t, ()): Fraction(1), (t, ()): Fraction(1)},
+                    'forward target before cleanup')
+    for g in word['cleanup']:
+        apply(g)
+    for r in live:
+        expected = {(r, ()): Fraction(1)}
+        if dual and r < 112:
+            expected[(112 + r, ())] = Fraction(-1)
+        if not dual and 112 <= r < 224:
+            expected[(r - 112, ())] = Fraction(1)
+        require(rows[r] == expected, f'complete {"dual" if dual else "forward"} endpoint {r}')
+    require(all(not rows[704 + r] for r in cold), 'all cold outputs zero')
+
+
+def check_change(source, candidate):
+    require(source['B'][GATE] == ['add', 393, 515, 1, 1, OLD_FRAME], 'source refit gate')
+    require(candidate['B'][GATE] == ['add', 393, 515, 1, 1, NEW_FRAME], 'candidate refit gate')
+    expected = copy.deepcopy(source)
+    expected['B'][GATE][-1] = NEW_FRAME
+    expected['report']['local_profile'] = candidate['report']['local_profile']
+    require(expected == candidate, 'only the credited frame and paid profile change')
+
+
+def reject(callback, label):
+    try:
+        callback()
+    except ValueError:
+        return label
+    raise ValueError(f'negative control accepted: {label}')
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--source', type=Path, default=HERE / 'vendor/pr2751')
+    parser.add_argument('--candidate', type=Path, default=HERE)
+    args = parser.parse_args()
+    source = args.source.resolve()
+    candidate = args.candidate.resolve()
+    candidate_inputs = candidate / 'inputs' if (candidate / 'inputs').is_dir() else candidate
+    result = {'status': 'PASS_INDEPENDENT_CREDITED_FUSION', 'providers': {}}
+    local_delta = Counter({1: -2, 2: 1})
+    for tag in ('base', 'extra'):
+        old = read(source / f'inputs/WORD-{tag}.json.gz')
+        new = read(candidate_inputs / f'WORD-{tag}.json.gz')
+        check_change(old, new)
+        before, old_history = frame_replay(old)
+        after, new_history = frame_replay(new)
+        delta = Counter(after)
+        delta.subtract(before)
+        require({r: n for r, n in delta.items() if n} == dict(local_delta), 'exact local fusion charge')
+        paths = {}
+        for r, prior in ((393, 4), (515, 5)):
+            a = old_history[r]
+            b = new_history[r]
+            index = next(i for i, entry in enumerate(a) if entry[0] == f'B{GATE}')
+            require(a[index][1:] == (prior, 6) and a[index + 1][1:] == (6, 7), 'old local path')
+            require(b[index][1:] == (prior, 5) and b[index + 1][1:] == (5, 7), 'new local path')
+            paths[str(r)] = {'old': [prior, 6, 7], 'new': [prior, 5, 7]}
+        scalar_replay(new, False)
+        scalar_replay(new, True)
+        bad_frame = copy.deepcopy(new)
+        bad_frame['B'][GATE][-1] = [1]
+        omitted = copy.deepcopy(new)
+        omitted['report']['local_profile']['2'] -= 1
+        controls = [reject(lambda: frame_replay(bad_frame), 'invalid frame'),
+                    reject(lambda: check_change(old, old), 'unchanged identity candidate'),
+                    reject(lambda: frame_replay(omitted), 'omitted child charge')]
+        result['providers'][tag] = {'profile': dict(sorted(after.items())), 'paths': paths,
+                                    'forward': 'PASS', 'dual': 'PASS', 'controls': controls}
+    order = read(source / 'inputs/ORDER.json')
+    require(len(order) == len({tuple(x) for x in order}) == 666, '666 distinct provider invocations')
+    global_old = Counter({int(k): v for k, v in read(source / 'PROFILE.json').items()})
+    expected = Counter(global_old)
+    expected.update({r: 666 * n for r, n in local_delta.items()})
+    claimed = {int(k): v for k, v in read(candidate / 'PROFILE.json').items()}
+    require(dict(expected) == claimed, 'complete global profile includes fusion charge')
+    require(sum(r * n for r, n in expected.items()) == sum(r * n for r, n in global_old.items()),
+            'unchanged global rank mass')
+    result['global_delta'] = {r: 666 * n for r, n in local_delta.items()}
+    result['profile'] = claimed
+    print(json.dumps(result, sort_keys=True, separators=(',', ':')))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/complex-routing-leaf-fusion/inputs/WORD-base.json.gz b/research/complex-routing-leaf-fusion/inputs/WORD-base.json.gz
new file mode 100644
index 0000000000..9a49a90965
Binary files /dev/null and b/research/complex-routing-leaf-fusion/inputs/WORD-base.json.gz differ
diff --git a/research/complex-routing-leaf-fusion/inputs/WORD-extra.json.gz b/research/complex-routing-leaf-fusion/inputs/WORD-extra.json.gz
new file mode 100644
index 0000000000..a3fdc91b1b
Binary files /dev/null and b/research/complex-routing-leaf-fusion/inputs/WORD-extra.json.gz differ
diff --git a/research/complex-routing-leaf-fusion/packing_cap.py b/research/complex-routing-leaf-fusion/packing_cap.py
new file mode 100644
index 0000000000..f73d080920
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/packing_cap.py
@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Uses Douglas Colkitt's exact ceiling engine (Claude-assisted), pinned unchanged.
+# Adapter derived from Tekalign (@tekuuu), with substantial OpenAI Codex assistance.
+# Updated for the credited frame composition by David Arias, with Codex assistance.
+"""Fixed-word coverage-law ceiling; separate from physical and outer admission."""
+import argparse, hashlib, importlib.util, json, sys
+from fractions import Fraction as Q
+from decimal import Decimal, localcontext
+from pathlib import Path
+HERE = Path(__file__).resolve().parent
+sys.dont_write_bytecode = True
+ENGINE_SHA = "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc"
+IDLE = {1:17316,3:6594,5:5216,32:1,48:26558}
+CANDIDATE = {1:1591740,2:430902,3:204396,4:79920,5:22532,8:5328,32:1,48:26558}
+ENDPOINT = Q('0.001717256973467002308270')
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+def calculate(profile_path=None):
+    path = HERE / 'vendor/ceiling.py'
+    raw = path.read_bytes()
+    need(hashlib.sha256(raw).hexdigest() == ENGINE_SHA, 'ceiling source pin')
+    spec = importlib.util.spec_from_file_location('packing_ceiling', path)
+    engine = importlib.util.module_from_spec(spec)
+    exec(compile(raw, str(path), 'exec'), engine.__dict__)
+    h = {int(r): n for r,n in json.loads((profile_path or HERE/'PROFILE.json').read_text()).items()}
+    need(h == CANDIDATE and sum(r*n for r,n in h.items()) == 4816512,
+         'complete candidate histogram and rank mass')
+    local = {r: Q(h[r]-IDLE.get(r,0),666) for r in h if h[r] != IDLE.get(r,0)}
+    need(local == {1:2364,2:647,3:297,4:120,5:26,8:8}, 'complete local profile')
+    model = engine.model(local,73,896,9,64)
+    need(model['total_mass']*666 == 4816512 and model['local_mass'] == 5223, 'coverage identity')
+    lo,hi = engine.ceiling(local,73,896,9,64)
+    need(engine.relax(local,73,896,9,64,hi)[0] > 1, 'upper cap rejection')
+    c = Q(json.loads((HERE/'CLAIM.json').read_text())['complex_lower'])
+    need(c == ENDPOINT, 'certified candidate endpoint')
+    with localcontext() as ctx:
+        ctx.prec = 50
+        dec = lambda x: str(Decimal(x.numerator)/Decimal(x.denominator))
+        return dict(status='PASS_FIXED_WORD_PACKING_CEILING',source_sha256=ENGINE_SHA,
+                    local_per_call={str(r):str(n) for r,n in local.items()},
+                    dimension=73,families=896,stages=9,centre_rank_per_call=64,max_idle_rank=model['R'],
+                    complex_cap_bracket=[str(lo),str(hi)],complex_cap_upper_decimal=dec(hi),
+                    realized_fraction_lower=str(c/hi),realized_fraction_decimal=dec(c/hi),
+                    scope='Fixed joint-twelve local word and hosted nine-stage coverage law; all remaining mass is relaxed to fractional rank51 children. This generic coverage-law ceiling is weaker than a window-aware packing or lattice bound. It does not certify or import the predecessor advertised lattice ceiling. It bounds this complex model, not different words or coverage laws. Modern outer admission is separate; no historical a/(1+a) conversion is used.')
+
+def main():
+    ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--output',type=Path)
+    ap.add_argument('--profile',type=Path,default=HERE/'PROFILE.json');a=ap.parse_args()
+    result=calculate(a.profile)
+    if not a.output:
+        need(result == json.loads((HERE/'PACKING-CAP.json').read_text()), 'packing-cap receipt mismatch')
+    text=json.dumps(result,indent=2)+'\n'
+    if a.output:
+        a.output.parent.mkdir(parents=True,exist_ok=True);a.output.write_text(text)
+    print(text,end='')
+if __name__=='__main__': main()
diff --git a/research/complex-routing-leaf-fusion/references/pr2733/CLAIM.json b/research/complex-routing-leaf-fusion/references/pr2733/CLAIM.json
new file mode 100644
index 0000000000..4d848d5466
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/references/pr2733/CLAIM.json
@@ -0,0 +1,81 @@
+{
+  "status": "PASS_COMPLETE_CONDITIONAL_ONE_GATE_REFIT",
+  "kappa": "17162556782301801990819999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000",
+  "kappa_decimal": "0.0017162556782301801990819999999999999999999998999999999999999999999999",
+  "complex_lower": "858127839115090099541/500000000000000000000000",
+  "complex_upper": "1716255678230180199083/1000000000000000000000000",
+  "global_profile": {
+    "1": 1594404,
+    "2": 430902,
+    "3": 204396,
+    "4": 79920,
+    "5": 22532,
+    "7": 2664,
+    "8": 2664,
+    "32": 1,
+    "48": 26558
+  },
+  "local_profile": {
+    "1": 2368,
+    "2": 647,
+    "3": 297,
+    "4": 120,
+    "5": 26,
+    "7": 4,
+    "8": 4
+  },
+  "comparison": {
+    "pr": 2733,
+    "head": "2761b52b17590b8cf94f2e410004a8252d5592dc",
+    "kappa": "17161404259974415161889999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000"
+  },
+  "gain": "115252232738682893/1000000000000000000000000",
+  "gain_percent": "0.006715781004441807559271426243840475422143424914816497532787219587423584",
+  "helpers": 415,
+  "calls": 666,
+  "roles": 276390,
+  "private_zero_buffers": 72,
+  "live": 66304,
+  "physical": 66801,
+  "rank_mass": 4816512,
+  "full_receipt": "evidence/full/RESULT.json",
+  "full_receipt_sha256": "3960db1a20f225619994cc1207973e73333a67f5d3411679e5e6beeac50155f3",
+  "source2679_head": "2e2cf56521df8a2b816b2689144765ee00b69a24",
+  "source2679_manifest_sha256": "db498ed7998397ef00501e037f10678e89ee113d57af4667c5c6978fc42e83ba",
+  "source2696_head": "5a42add713e09a8798a84d0be7a8276626d9e785",
+  "candidate_manifest_sha256": "234cd08b5ae55b81f49c68549ec550c62a30a1e43f1c451d4836c12ed0464bd4",
+  "coverage": {
+    "current_stages": 18,
+    "retained_parent_stages": 18,
+    "strict_steps": 8,
+    "supplier_inequalities": 47,
+    "modern_inequalities": 63,
+    "modern_negative_controls": 17,
+    "evidence_replays": 19,
+    "admission_controls": 114,
+    "bit_controls": 12,
+    "current_controller_mutations": 25,
+    "independent_owner_controls": 8,
+    "geometry_controls": 6,
+    "prelife_mutations_per_provider": 78,
+    "alias_mutations_per_provider": 7,
+    "native_recipe_mutations_per_provider": 13,
+    "dirty_columns_each_orientation": 639,
+    "native_operator_count": 65,
+    "native_physical_classes": 166,
+    "native_columns_per_class": 512,
+    "ordinary_sufficient_stages": 37
+  },
+  "native_and_parent_receipt_reuse": false,
+  "inherited_parent_geometry_reuse": true,
+  "selected_main_changed": false,
+  "human_review": false,
+  "proof_assistant_verified": false,
+  "scope": "Finite conditional construction and exact outer inequalities; inherited all-size, machine, analytic and bit assumptions remain.",
+  "latest_comparison": {
+    "pr": 2745,
+    "head": "4f485de05544884fa0f2edf6063bb9259decad30",
+    "source_claim_sha256": "3dd22facffda276820de211ccbebcdb51296d0dc4544eaf824c0982a0ecce5e6",
+    "gain": "1152522327386828923986958405456550016704982851526653723338897453235077363137955563484477972014655144849901016224958370736452836874748324552514434252165193760012421558201475515892676178298844377486299355652132598928274405431550684387484094490504115233222418160769653597661174415592502648718377841476158643571134598900661279605763041147288209663739853590127428569334882278938889212770337810458546653024480764824925785522147407275424823833001377673320296666889062633592613879785770048368191481861636732094780186823400433902504245113278482732391124149769505091896493786837649208207668558651234481386694029719550345680934522957309797753657784460928481348591236710504214847910629330174919063157972846674431261560192401805114029748198590019913511051623811552806109170167892566593094174294084194603336817274759327823163922695977936791304886025696668084326690154451196659226458417144622840250124183055368787281008148076829847857564094201109768180780488096807777657169184484992021279602259409827300317883878667085017324762808192221751343057378456623173168825948172507145572284532651946722548662909466595834514472481514320163121897852933619130839360101152609296615510240176415606431571092302394993336965432419668385640052238267408068377690615866558262492318158178988042740245947148176887598870151226232990312997958870741987814513762632060994115232960297459855946600638352674389748474390357380216250942806878273315319080861622070278195001083214726086247355962049517627954677928426461007804566222925742890444925646278000097986723482842830059438431821613379271163950227521549145546610012841272427195397678003980739261847843242838651732112088808713219186384523614303490266301536079946639924174300183433182199128326791309663705250352572052472500320592963559976987565828718953357573936345029060042818347734470556409212902538468198613988536256030024137219735914362231743710581217320176469736039924885335628492652267723187030135732438954485875610869266686567122188440884114974487473429828031068433041203007826614929936141402577750775225940608644167330559212566993748279193328233708010650529289445193333389808571712849037050330033125103779500724923110107063540392910321332440414135582413001243323654896577862616563860835925935586083994714827027565777465019241962321348662814548124062774482527467964077250052105952955692535818463556789085955817556196520698820013289686825895123726521617061431152273697648294580922195333547716210315006486789799911669360718822392333124336078261788309378651120643305379599021565393198057587072784837906397694814384362561357343866759385548898153347483190182690964710964510152026539120933722502448956501934530691560295954628228745536285324141446345868001230240638408221068503976674258798165395942621264009756163768505813981941714313277481457363778096179652001048939892344420799481076606518833289055530698255335185088782882039318915993349797797758940369731095116215929321656051292221291980095202394838218079303112450163917616266815079526837270234785195021223149683812983948470647812041600000000000000000000001000000000000000000000001/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+  }
+}
diff --git a/research/complex-routing-leaf-fusion/references/pr2733/NOTICE b/research/complex-routing-leaf-fusion/references/pr2733/NOTICE
new file mode 100644
index 0000000000..6dacc7b2ce
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/references/pr2733/NOTICE
@@ -0,0 +1,30 @@
+One-gate frame refit of the concentrated source-partner/pre-life composition.
+Copyright 2026 Marius-Paul Dumitrean. Apache-2.0.
+Substantial OpenAI Codex assistance was used for research, implementation,
+orchestration and separately developed checks. No independent human review or
+proof-assistant verification is claimed.
+
+The predecessor concentrated-prelife-composition package and every imported
+source retain their original license, NOTICE and AI-assistance disclosures.
+This package imports that frozen package rather than duplicating its source.
+Mason Hale supplied PR2696 concentrated source partners and independent algebra;
+Philippe Van Velzen supplied PR2679 pre-life/refit and PR2559 evacuation;
+Jeremy Kothe supplied PR2588 comparison words and PR2673 order/allocation;
+zxv supplied PR2530 source-partner recovery/owner flows; themilkman216 PR2621
+priority scheduling; Tekalign PR2436 lifted-target compensation; Rohan Arun
+owner work. Douglas Colkitt's exact interval primitives retain their notices.
+The retained native, bit and outer source lineage remains authoritative.
+
+Frozen inherited patch metadata contains an early incorrect author label:
+PR2679 is Philippe Van Velzen's contribution, not Jeremy Kothe's. Source bytes
+are preserved, and SOURCE-HEADS.json and this notice correct the attribution.
+
+check_admission.py, combined_adapt.py and replay_engine.py are derived from the
+same author's prior PR2733 package. REPLAY-DERIVATION.patch records the scientific
+engine/adapter changes. The new gate/frame witness and complete-cost comparison
+are in PROOF.md.
+
+Jeremy Kothe's concurrent PR2745 independently composes the same words, gives
+an equally priced alternate fill and refines the exact endpoint grid. Its full
+claim is retained with exact source pins for comparison; its inputs do not add
+a further paid-profile improvement to the B1149 candidate.
diff --git a/research/complex-routing-leaf-fusion/references/pr2733/PROOF.md b/research/complex-routing-leaf-fusion/references/pr2733/PROOF.md
new file mode 100644
index 0000000000..452212aa89
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/references/pr2733/PROOF.md
@@ -0,0 +1,102 @@
+# One legal frame change and its exact paid gain
+
+The source is the complete frozen PR2733 composition, pinned by its original
+published head and artifact manifest in `SOURCE-HEADS.json`. Both orientation
+providers receive precisely the same change at B gate 1149:
+
+```
+['add',393,515,1,1,[259,132,66,36,16,9]]
+                 -> [259,148,66,36,9]
+```
+
+The first five gate fields stay fixed. Only the common frame changes from rank
+six to rank five. The complete scalar word, 112 source and 112 target roles,
+entrances, final frames, operator words, precondition/compensation, 36
+anticipatory corrections, all warps and inverse cleanup remain identical.
+`verify_refit.py` checks complete decoded-word equality after this declared edit
+and the corresponding report update, not merely matching rank histograms.
+
+## Legal frame witness
+
+For register 393 the preceding B gate is 1141, with frame
+`[407,66,36,9]` of rank four. Its following B gate is 1790, with rank-seven frame
+`[256,132,65,36,16,9,3]`. For register 515 the preceding B gate is 894, with frame
+`[259,148,66,36,9]` of rank five. Its following B gate is 1778, with rank-seven
+frame `[259,128,66,32,16,9,4]`. There is no intervening warp between each
+register's respective neighboring occurrences. Register 393's warp at 1130
+precedes gate 1141 and is unchanged.
+
+Over F2 the new frame contains both incoming subspaces and is contained in both
+outgoing subspaces. It is a proper subspace of the old common frame. Thus the
+unchanged elementary addition is legal, and all four adjacent climbs remain
+legal. Their old bill is `H2+3H1`; their new bill is `2H2+H1`. The exact local
+change is therefore `H2-2H1`.
+
+The independent checker computes the complete frame invoice, all arbitrary-input
+free-operator rows in the forward and dual orientations, and literal inverse
+cleanup. A zero frame and a changed coefficient sign are rejected separately
+for each provider. Native physical recipes and phases are additional obligations
+of the complete cold replay; they are not inferred from the free-operator check.
+
+## Complete cost and owner interface
+
+The resulting local profile is
+`{1:2368,2:647,3:297,4:120,5:26,7:4,8:4}`. Since every entry and exit is unchanged,
+so is every helper width. The original literal owner fill/order applies without
+any remapping, and every one of the 276,390 roles remains charged. There are 415
+helpers per call and 72 private FULL buffers. Physical stock remains
+`66304+415+8+72+2=66801`. Across 666 calls, the global profile changes only by
+`666*(H2-2H1)` to
+
+```
+{1:1594404,2:430902,3:204396,4:79920,5:22532,7:2664,8:2664,32:1,48:26558}.
+```
+
+Its rank mass is still 4,816,512. For native normalization
+`M(b)=sum_r H_r*(r/73)^(1-b)/66304`, the exact moment change is
+
+```
+Delta M(b) = 666*73^(b-1)/66304*(2^(1-b)-2) < 0,   0 < b < 1.
+```
+
+This proves native moment dominance throughout that interval. It does not, by
+itself, prove any unexamined conservative surcharge or whole outer exponent.
+Those are rederived in the fresh complete replay and bound to `CLAIM.json`.
+
+## Chained reconstruction and checker adaptation
+
+`generate.py` authenticates the complete frozen predecessor packages before and
+after reconstructing both words. It appends the new refit to the original
+B894 refit stage. The following alias653 patch replaces a complete B list, so
+that patch is regenerated as well; otherwise it would silently restore the old
+B1149 frame. Both final decoded words must match the committed expected words.
+Compressed regeneration is compared by complete decoded payload, while frozen
+source bytes retain exact hashes.
+
+`REPLAY-DERIVATION.patch` describes the changes from the previous composition
+engine and adapter. In addition to the three already declared candidate checker
+adaptations, `new/rebuild_borrow.py` now requires precisely the original B894
+refit and this B1149 refit. It checks the exact original and resulting B1149 gate,
+the original B894 gate and dimension drop, and equality of every other B gate.
+The resulting four modified derivative checker files are individually hash-bound;
+other frozen proof/checker Python remains unchanged. Eight deliberate extra or
+incorrect edits were independently rejected. Frozen upstream packages are never
+edited in place.
+
+## Scope of the endpoint ceiling and remaining obligations
+
+The exact rational dual/lattice ceiling applies only to this fixed local profile,
+415-helper width inventory, 666 calls and original bin multiset. It relaxes
+window/family constraints, so covers every packing order under those premises.
+A changed local word/profile, inventory, warp or bin geometry requires a new
+bound. The finite 914-closure screen is not an all-frame optimum.
+
+All-size machine/compiler and common-label realization, sequential physical
+borrowing/hosting/routing, uniform precision and fixed tape, exact recovery and
+analytic transfer, native recurrence corrections, the bit supplier and modern
+outer phase-cell/radix/prime-padding assumptions remain inherited. Finite receipt
+checks do not establish those uniform hypotheses or an unconditional integer
+multiplication theorem. The selected repository result is unchanged.
+
+Marius-Paul Dumitrean, with substantial OpenAI Codex assistance. Apache-2.0.
+Source attribution and source-specific notices are retained in `NOTICE`.
diff --git a/research/complex-routing-leaf-fusion/requirements.txt b/research/complex-routing-leaf-fusion/requirements.txt
new file mode 100644
index 0000000000..816d0c8e91
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/requirements.txt
@@ -0,0 +1,4 @@
+numpy==2.5.4
+sympy==1.14.0
+scipy==1.18.1
+mpmath==1.3.0
diff --git a/research/complex-routing-leaf-fusion/test_integrity.py b/research/complex-routing-leaf-fusion/test_integrity.py
new file mode 100644
index 0000000000..114f85953b
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/test_integrity.py
@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Git-free read-only replay and fail-closed public-entrypoint controls."""
+import gzip
+import hashlib
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+
+HERE = Path(__file__).resolve().parent
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def inventory(root):
+    return {str(p.relative_to(root)): hashlib.sha256(p.read_bytes()).hexdigest()
+            for p in root.rglob('*') if p.is_file()}
+
+
+def call(package, args, expected_code=0, reason=None):
+    env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PATH='')
+    env.pop('PYTHONOPTIMIZE', None)
+    process = subprocess.run([sys.executable, '-I', '-B', *args], cwd=package.parent,
+                             env=env, capture_output=True, text=True, timeout=220)
+    if expected_code == 0:
+        need(process.returncode == 0, 'public replay failed: ' + process.stderr[-2000:])
+    else:
+        need(process.returncode != 0, 'public entry accepted corruption')
+        need(reason in process.stderr + process.stdout, 'wrong failure reason: ' + process.stderr[-2000:])
+
+
+def main():
+    with tempfile.TemporaryDirectory(prefix='routing-leaf-export-') as directory:
+        target = Path(directory) / 'relocated-package'
+        shutil.copytree(HERE, target, ignore=shutil.ignore_patterns('__pycache__'))
+        baseline = inventory(target)
+        call(target, [str(target/'verify.py')])
+        need(inventory(target) == baseline, 'successful verification wrote package files')
+        # A valid source comment change is still an unauthenticated input change.
+        path = target/'vendor/pr2751/independent_local.py'
+        original = path.read_bytes()
+        path.write_bytes(original+b'\n# unauthenticated change\n')
+        call(target, [str(target/'verify.py')], 1, 'predecessor SHA256')
+        path.write_bytes(original)
+        # Keep the profitable claimed profile but remove the actual frame edit.
+        path = target/'inputs/WORD-base.json.gz'
+        original = path.read_bytes()
+        value = json.loads(gzip.decompress(original))
+        value['B'][1151][-1] = [259,132,66,36,16,9]
+        path.write_bytes(gzip.compress(json.dumps(value).encode(), mtime=0))
+        call(target, [str(target/'verify.py')], 1, 'complete generated word equality')
+        path.write_bytes(original)
+        # JSON numeric equality must not conflate an integer receipt with float.
+        path = target/'RESULT.json'
+        original = path.read_bytes()
+        value = json.loads(original)
+        value['calls'] = float(value['calls'])
+        path.write_text(json.dumps(value))
+        call(target, [str(target/'verify.py')], 1, 'complete typed RESULT.json equality')
+        path.write_bytes(original)
+        call(target, ['-O', str(target/'verify.py')], 1, 'run without -O')
+        out = Path(directory)/'existing-output'
+        out.mkdir()
+        (out/'sentinel').write_text('must survive')
+        call(target, [str(target/'generate.py'), '--source', str(target/'vendor/pr2751'),
+                      '--out', str(out)], 1, 'Output directory must be fresh')
+        need((out/'sentinel').read_text() == 'must survive', 'generator replaced output')
+        need(inventory(target) == baseline, 'failure controls changed restored package')
+    print('PASS_ROUTING_LEAF_INTEGRITY Git-free=1 source=1 omitted-frame=1 typed-receipt=1 optimized-refusal=1 output-preservation=1')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/complex-routing-leaf-fusion/vendor/ceiling.py b/research/complex-routing-leaf-fusion/vendor/ceiling.py
new file mode 100644
index 0000000000..6c0f54527d
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/vendor/ceiling.py
@@ -0,0 +1,152 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Packing-independent ceiling for a complex local word under the hosted nine-stage coverage law.
+
+Model (all inputs explicit):
+  * per replica the template has `families` live data families and `stages` invocations, so
+    w = families / stages live families per call; on the selected T37/T16 line all helpers are
+    hosted on data families, so w = 2 * pairs * V / stages is fixed by the port count V;
+  * coverage identity (PR1012, re-checked here on the selected profile): paid rank mass equals
+    (m - 1) * W + centre * N, i.e. every live family keeps exactly one unpaid coordinate and every
+    call pays its centre path (`unpaid` > 1 is a what-if for a changed coverage law only);
+  * the local word fixes its own paid child profile `local` (per call);
+  * every remaining unit of mass is an idle/remainder child of rank at most R, where the outer
+    recipe's halving guard m^2 > 2 R^2 bounds R (R = 51 for m = 73).
+
+Lemma. For a >= 0, a child of rank r costs (r/m)^(1-a) = r * c(r), with c(r) = r^(-a) m^(a-1)
+non-increasing in r. Hence, with idle mass M fixed and idle ranks <= R, every idle histogram has
+moment >= the relaxation that puts all of M into (possibly fractional) rank-R children:
+
+    relax(a) = [ sum_local n_r (r/m)^(1-a) + (M/R) (R/m)^(1-a) ] / w     (per call).
+
+The moment is increasing in a. So relax(a*) > 1 certifies that no hosting, owner packing or
+idle-remainder change of the given local word, template and outer recipe certifies a saving
+>= a*. Under the retained reduction kappa < a/(1+a) when the complex side binds, so
+a*/(1+a*) also bounds kappa. This is a bound for the stated model, not for other local words,
+templates, coverage laws or outer recipes.
+
+Exact rational intervals: ln k from atanh chains, exp by Taylor with Lagrange remainder,
+outward rounding to 2^-PREC. Standard library only. Douglas Colkitt, with Claude (Anthropic)
+assistance.
+"""
+from fractions import Fraction as Q
+from functools import lru_cache
+from math import isqrt
+
+PREC = 256
+
+
+def require(ok, why):
+    if not ok:
+        raise ValueError(why)
+
+
+def down(x):
+    return Q((x.numerator << PREC) // x.denominator, 1 << PREC)
+
+
+def up(x):
+    return -down(-x)
+
+
+@lru_cache(None)
+def atanh(t):
+    """Enclosure of atanh(t) for rational 0 < t <= 1/3."""
+    require(0 < t <= Q(1, 3), 'atanh range')
+    s, p, k = Q(0), t, 0
+    while True:
+        term = p / (2 * k + 1)
+        s += term
+        p *= t * t
+        k += 1
+        tail = p / ((2 * k + 1) * (1 - t * t))
+        if tail < Q(1, 1 << (PREC + 8)):
+            return down(s), up(s + tail)
+
+
+@lru_cache(None)
+def ln(k):
+    """Enclosure of ln k for an integer k >= 1: ln k = ln(k-1) + 2 atanh(1/(2k-1))."""
+    require(isinstance(k, int) and k >= 1, 'ln domain')
+    if k == 1:
+        return Q(0), Q(0)
+    lo, hi = ln(k - 1)
+    a, b = atanh(Q(1, 2 * k - 1))
+    return down(lo + 2 * a), up(hi + 2 * b)
+
+
+def exp(lo, hi):
+    """Enclosure of exp([lo, hi]) for 0 <= lo <= hi <= 1/2."""
+    require(0 <= lo <= hi <= Q(1, 2), 'exp range')
+    def series(y, upper):
+        s, t, k = Q(1), Q(1), 0
+        while True:
+            k += 1
+            t = t * y / k
+            s += t
+            if t * y < Q(1, 1 << (PREC + 8)):
+                return up(s + 2 * t * y / (k + 1)) if upper else down(s)
+    return series(lo, False), series(hi, True)
+
+
+def child_cost(r, m, a):
+    """Enclosure of (r/m)^(1-a) = (r/m) exp(a ln(m/r))."""
+    lm, um = ln(m)
+    lr, ur = ln(r)
+    e = exp(max(Q(0), a * (lm - ur)), a * (um - lr))
+    return down(Q(r, m) * e[0]), up(Q(r, m) * e[1])
+
+
+def max_idle_rank(m):
+    """Largest R with m^2 > 2 R^2 (outer halving guard)."""
+    R = isqrt((m * m - 1) // 2)
+    while 2 * (R + 1) ** 2 < m * m:
+        R += 1
+    while 2 * R * R >= m * m:
+        R -= 1
+    return R
+
+
+def model(local, m, families, stages, centre, R=None, unpaid=1):
+    """Per-call quantities. local: {rank: count per call (Fraction ok)}."""
+    R = max_idle_rank(m) if R is None else R
+    require(2 * R * R < m * m, 'idle rank cap violates the halving guard')
+    require(all(0 < r < m for r in local) and all(n >= 0 for n in local.values()), 'local profile')
+    w = Q(families, stages)
+    require(1 <= unpaid < m, 'unpaid coordinates per family')
+    total = (m - unpaid) * w + centre
+    local_mass = sum(r * Q(n) for r, n in local.items())
+    idle = total - local_mass
+    require(idle >= 0, 'local word pays more mass than the coverage law allows')
+    return dict(R=R, w=w, total_mass=total, local_mass=local_mass, idle_mass=idle, deficit=unpaid * w - centre)
+
+
+def relax(local, m, families, stages, centre, a, R=None, unpaid=1):
+    """Enclosure of the per-call relaxation moment at saving a."""
+    q = model(local, m, families, stages, centre, R, unpaid)
+    lo = hi = Q(0)
+    for r, n in local.items():
+        c = child_cost(r, m, a)
+        lo, hi = lo + Q(n) * c[0], hi + Q(n) * c[1]
+    c = child_cost(q['R'], m, a)
+    k = q['idle_mass'] / q['R']
+    lo, hi = lo + k * c[0], hi + k * c[1]
+    return down(lo / q['w']), up(hi / q['w'])
+
+
+def ceiling(local, m, families, stages, centre, grid=Q(1, 10 ** 15), R=None, unpaid=1):
+    """Grid bracket [a_lo, a_hi]: relax(a_lo) < 1 < relax(a_hi), certified. a_hi is the ceiling."""
+    lo, hi = Q(0), Q(1, 20)
+    require(relax(local, m, families, stages, centre, hi, R, unpaid)[0] > 1, 'search window too small')
+    require(relax(local, m, families, stages, centre, lo, R, unpaid)[1] < 1, 'relaxation has no positive saving')
+    while hi - lo > grid:
+        mid = Q(int((lo + hi) / 2 / grid)) * grid
+        if mid <= lo:
+            mid = lo + grid
+        v = relax(local, m, families, stages, centre, mid, R, unpaid)
+        if v[1] < 1:
+            lo = mid
+        elif v[0] > 1:
+            hi = mid
+        else:
+            raise ValueError('enclosure too wide to separate the grid point')
+    return lo, hi
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/CLAIM.json b/research/complex-routing-leaf-fusion/vendor/pr2751/CLAIM.json
new file mode 100644
index 0000000000..48ad23a430
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/vendor/pr2751/CLAIM.json
@@ -0,0 +1,24 @@
+{
+  "status": "PASS_CONDITIONAL_FINITE_CONSTRUCTION_COMPLETE_RELEASE",
+  "complex_lower": "0.001717141586348426338109",
+  "complex_upper": "0.001717141586348426338110",
+  "kappa": "17171415863484263381089999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000",
+  "profile": {
+    "1": 1593072,
+    "2": 430236,
+    "3": 204396,
+    "4": 79920,
+    "5": 22532,
+    "8": 5328,
+    "32": 1,
+    "48": 26558
+  },
+  "comparison_pr": 2733,
+  "comparison_head": "2761b52b17590b8cf94f2e410004a8252d5592dc",
+  "scope": "Conditional finite construction and complete strict supplier/modern outer release; inherited theorem assumptions remain.",
+  "latest_comparison": {
+    "pr": 2745,
+    "head": "4f485de05544884fa0f2edf6063bb9259decad30",
+    "exact_claim": "evidence/PR2745-CLAIM.json"
+  }
+}
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/LICENSE b/research/complex-routing-leaf-fusion/vendor/pr2751/LICENSE
new file mode 100644
index 0000000000..261eeb9e9f
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/vendor/pr2751/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/PROFILE.json b/research/complex-routing-leaf-fusion/vendor/pr2751/PROFILE.json
new file mode 100644
index 0000000000..080d9e165d
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/vendor/pr2751/PROFILE.json
@@ -0,0 +1,10 @@
+{
+  "1": 1593072,
+  "2": 430236,
+  "3": 204396,
+  "4": 79920,
+  "5": 22532,
+  "8": 5328,
+  "32": 1,
+  "48": 26558
+}
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/PROOF.md b/research/complex-routing-leaf-fusion/vendor/pr2751/PROOF.md
new file mode 100644
index 0000000000..d2b1a96ba8
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/vendor/pr2751/PROOF.md
@@ -0,0 +1,25 @@
+# Changed recovery contract and complete moment
+
+The exact object is the two finite T74 words reconstructed by `generate.py`. The experiment uses a single explicit assignment, not a search over all assignments. Starting before PR2462's lowfour transformation is essential: applying the old lowfour patch first is a positive control reproducing its complete original words.
+
+The new `(removed helper, recovered source, partner)` assignments are:
+
+```
+(696,33,49), (697,55,101), (698,74,83), (700,85,98),
+(680,49,33), (681,83,74), (682,98,85), (684,101,55),
+(688,68,4), (689,80,88), (690,88,80), (692,31,12).
+```
+
+The last eight are PR2696's assignment. For each of the pairs33/49,55/101,74/83,85/98, let `(x,y)` denote the values after their last original uses, in their shared frame. The two added gates are `x += y/2` followed by `y -= x`, hence the linear map is `(x+y/2, y/2-x)`. For the actual predecessor state these restore the two original source values. The proof of that word-specific premise is the full arbitrary-input exact symbolic replay, not a claim that this map is the identity on arbitrary `(x,y)`.
+
+These restorations precede the new alias handoffs. Original operator IDs remain stable; twelve new chart transformations are appended. Removed-helper echoes are deleted only where they are target additions. For each new source, the generator computes the complete symbolic residual, transports its negative through precondition/compensation, and emits explicit initial correction gates and inverse source warps. Every residual must consist of a single new operator applied to its recovered source. Independent forward/dual propagation checks the resulting arbitrary-input identity, including dirty registers, and separately checks inverse cleanup.
+
+All lifted targets have frame `[45]`; their offsets are14,21,37,41,43,47,52,78,99,104,106,110. None is a target read by any cut gate. Actual frame propagation therefore leaves all eight centre children rank8. This changes the old-four recovery/target paths fixed in PR2720; its obstruction is respected within its stated domain.
+
+Apply the six PR2679 pre-life substitutions to the actual resulting state, refit the unique `515 += 563` gate (now B904), then alias653 into563. The complete generator checks semantic equality of both resulting words. The source-bound original checks and negative controls are rerun. No helper saving is inferred solely from nominal register labels.
+
+The complete local profile is `{1:2366,2:646,3:297,4:120,5:26,8:8}`. Compared with the PR2733 composition it changes by `4*(H8-H7-H1)` per local word. The same415-helper inventory admits the explicit complete allocation; `independent_owners.py` checks276390 roles, strict temporal windows, every physical cell, family masks and all remainders. There are666 call equivalents, giving global delta `2664*(H8-H7-H1)` and rank mass4816512 unchanged.
+
+At exponent `0<p<1`, strict subadditivity gives `8^p < 7^p+1`; thus this delta strictly decreases the paid moment throughout that interval. This comparison alone is not a complete outer bound: the package independently brackets the new moment root with rational arithmetic, rebinds the actual native words and physical stock, and reruns strict supplier admission and the modern outer release.
+
+The rational endpoint bracket is `(0.001717141586348426338109,0.001717141586348426338110)`. The modern outer witness uses κ equal to the lower endpoint minus `10^-46+10^-70`. All required inherited checks must pass for the conditional bound; a smaller native moment alone would not suffice if another supplier bound became binding. The retained bit branch does not bind this witness. Universal realization and analytic obligations remain as listed in README and the pinned source review.
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/README.md b/research/complex-routing-leaf-fusion/vendor/pr2751/README.md
new file mode 100644
index 0000000000..77ab0d3121
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/vendor/pr2751/README.md
@@ -0,0 +1,70 @@
+# Joint twelve-source recovery: conditional κ ≈ 0.001717141586348426338109
+
+This changes the four older lifted-source assignments together with Mason Hale's eight assignments (PR2696), then composes Philippe Van Velzen's six pre-life hostings and refit (PR2679) with Jeremy Kothe's invocation order and allocation (PR2673). All eight central children remain rank eight. The complete native profile improves on Marius-Paul Dumitrean's PR2733 by `2664*(H8-H7-H1)`. The gain in conditional κ is approximately 0.05834%; it is incremental, not a measured runtime speedup or an unconditional multiplication theorem.
+
+Exact base: `c22e42de697334df85337e005864773cdc2bc98b`.
+The rational κ is in `CLAIM.json`: take `0.001717141586348426338109 - 10^-46 - 10^-70`. Larger κ is better in `O(n (log n)^(1-κ))`. No selected frontier is edited.
+
+## Reproduce
+
+From the repository root, with Python 3.12 and no third-party dependencies:
+
+```sh
+python3.12 -I -B research/t74-joint-twelve/verify.py
+```
+
+Expected: `PASS_JOINT_TWELVE_FINITE_REPLAY`, 276390 owner roles, six rejected algebra mutations and one rejected owner mutation. This checks complete arbitrary-input symbolic words, actual frame charges, cleanup, deterministic full owner placement and an exact rational adjacent root bracket. It does not stand in for native/supplier admission.
+
+The optional registered hook runs this plus the generic packing ceiling:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/t74-joint-twelve
+```
+
+For full release, install `requirements.txt` in a dedicated Python environment, then use a fresh external output directory:
+
+```sh
+python3 -B research/t74-joint-twelve/full_replay.py --work /tmp/FRESH-joint-twelve
+```
+
+The default authenticates 491 files from pinned PR2679, applies the changed-files-only overlay, generates fresh native providers and retained-parent admission, and runs the original complete supplier/outer verifier. It requires network access and substantially more time. `--source /path/to/pr2679/research/gmx-t74-borrow43-handoff` uses an exact local copy; every file is still authenticated. `--prepared-native-cache PATH` is explicit source-bound reuse and must match every published cache hash. Execution coverage and reuse are in `EVIDENCE.json`; do not infer that every option was run.
+
+To regenerate both complete words from source:
+
+```sh
+python3 -B research/t74-joint-twelve/generate.py --source /path/to/pr2679/research/gmx-t74-borrow43-handoff --out /tmp/FRESH-joint-words
+```
+
+Expected: `PASS_REGENERATED_JOINT_TWELVE_BOTH_WORDS`. This first positively reconstructs both original PR2462 words, then checks semantic equality of every field of both final words. Compression bytes are not used to judge regenerated mathematical equality.
+
+## Construction and cost
+
+See `PROOF.md` for the changed recovery contract. There are 415 helpers and 72 private buffers per call, live66304, physical66801 = 66304+415+8+72+2, dimension73. All source accesses, recoveries, initial corrections, frame changes, inverse cleanup, pre-life hosting, recursive children and idle remainders are included in the actual words and placement.
+
+Local profile: `{1:2366,2:646,3:297,4:120,5:26,8:8}`.
+Complete profile: `{1:1593072,2:430236,3:204396,4:79920,5:22532,8:5328,32:1,48:26558}`; rank mass4816512.
+The exact moment root lies strictly between `.001717141586348426338109` and `.001717141586348426338110`. The strict supplier and modern outer release both pass. The retained bit supplier remains nonbinding under the inherited assembly/outer assumptions.
+
+The generic coverage-law ceiling is about `.001750373331784`, realized fraction `.9810144814068302`, computed using the pinned `ceiling.ceiling()` implementation. This is not a sharp lattice bound or proof of optimality. The experiment constructed one deterministic assignment in both providers; no exhaustive search claim is made. Retained assignment seed2 is provenance, not a claim of an independent random search.
+
+## Verification and controls
+
+Both changed native providers passed native generation, ledgers, local replay, wrappers and phases freshly. The complete strict supplier and modern outer release passed with authenticated native/retained-parent reuse. Receipts are under `evidence/`; `REUSE-PINS.json` binds every reused file. The independent implementation propagates symbolic noncommuting operator words and separately checks geometry/cleanup. Reversing or deleting anticipatory corrections and reversing a source recovery are rejected for both providers. An out-of-bin owner mutation is rejected. The candidate endpoint rejects PR2733's inferior profile.
+
+`DERIVATIVE-CODE.patch` exposes checker changes for review. No rejection test is removed: the intermediate-centre-step mutant is generalized to an actual incomplete descent when there is no intermediate step. Lowfour mutants select actual corrected targets, source33 writes and recovery gates instead of stale hardcoded indices. Runtime target/profile/refit pins are updated to the changed word. Alias653 position metadata is regenerated from the actual warp; its checker is unchanged. The full release reruns these controls. Failed initial runs that exposed these stale assumptions are recorded in `EVIDENCE.json`.
+
+The overlay is about1.5MB, not a copied predecessor tree. Compressed certificates carry the complete witnesses; their generators and readable checker patch are included. `SOURCE-FILES.json`, `OVERLAY-PINS.json`, `INPUT-PINS.json` and `GENERATOR-PINS.json` authenticate their respective sources. `SOURCES.json` pins main-line provenance and external dependency heads.
+
+## Scope and inherited obligations
+
+Finite exact admission is conditional evidence, not formal proof of the complete multiplication theorem. All-size compiler/machine realization, common labels and source access, physical hosting/routing, precision/fixed-tape contracts, exact recovery and analytic transfer, recurrence, bit-supplier and modern outer obligations remain inherited. No new discharge of those universal obligations is claimed. The selected accepted result and this pending derivative are distinct.
+
+This deliberately changes the old-four recovery paths held fixed by PR2720. It does not contradict that scoped cut obstruction. PR2733 independently supplied the concentrated/pre-life composition; a previous local duplicate of it was not submitted. PR2745 subsequently refined that same profile's outer numerical precision by about6e-25; the present change improves the actual native profile. Latest live overlap coverage and limits are in `FRESHNESS.json`.
+
+## Open next questions
+
+- Can another changed source/consumer contract improve the actual word beyond this profile? First price all recoveries, frames, source accesses and buffers; the fixed-old-path obstruction cannot simply be ignored.
+- Can a sharp fixed-inventory packing certificate close the remaining gap to the generic coverage-law ceiling? First derive the new inventory's dual/lattice constraints. The reported generic ceiling does not establish a packing opportunity.
+- Can one inherited all-size realization or precision obligation be independently discharged? Select its exact hypotheses from the pinned review; finite replay is not that proof.
+
+Prepared by Tekalign (@tekuuu) with substantial OpenAI Codex assistance in construction, code, independent algorithms, checking and documentation. No independent human review claimed. See `SOURCE-NOTICE` for predecessor credits and retained notices. New work Apache-2.0.
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/SOURCE-NOTICE b/research/complex-routing-leaf-fusion/vendor/pr2751/SOURCE-NOTICE
new file mode 100644
index 0000000000..380e979f0e
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/vendor/pr2751/SOURCE-NOTICE
@@ -0,0 +1,14 @@
+Anticipatory dirty borrowing: PR2226 (Cinna Davis / 1337isnot1337, with substantial OpenAI Codex assistance) is credited first. Its alias rule, changed-reference K_G handoffs, initial compensation and exact free-operator replay (vendored under new/code/borrow/vendor, see new/code/borrow/NOTICE-PR2226.md) are applied here to the T74 pivot-566+554 words; the native lowering, window-exact owner fill and independent audit of the borrow words are new in this package. Bootstrap carried-cutoff repair: PR1956 (Josie Elliston); Lemma G label/adapter checks and X/Y/Z mutants: PR1964 (thakrarsagar), extended here with borrow warp/zero-buffer controls.
+
+New research prepared by Rohan Arun with substantial OpenAI Codex assistance. Apache-2.0. Parent words and build recipe method derive from Jeremy Kothe PR1274 and Rohan Arun PR1218, with lineage credited in README.md. All inherited mathematical qualifications are retained.
+Additional pivot555 and567 composition by Rohan Arun with substantial OpenAI Codex assistance.
+
+T74 exact-fill owner construction by Rohan Arun with substantial OpenAI Codex assistance.
+
+PR1377 grid refinement credited to Jeremy Kothe. Outer witness refinement by Rohan Arun with OpenAI Codex assistance; construction unchanged.
+
+Pivot-566 kernel, words, edits, rebuild.py and rebind.py: PR1625 (mdumitrean). Endpoint/outer-witness stacking, fine_cache.py and oracle stage by jeremykothe2 with oh-my-pi assistance.
+
+The preceding paragraphs are inherited source notices, not attribution of this derivative.
+This joint twelve-source construction, generator, independent replay, hosting composition and package: Tekalign (@tekuuu), with substantial OpenAI Codex assistance. No independent human review claimed.
+Credits: Cinna Davis/PR2226 anticipatory dirty borrowing; Tekalign/PR2436 four lifted targets; Jeremy Kothe/PR2462,2588,2673 source pipeline, source-label swap and order/fill; zxv/PR2530 eight aliases; Mason Hale/PR2696 concentrated source-partner assignment and independent local interpreter; Philippe Van Velzen/PR2559,2679 evacuation, six pre-life hosts and refit/alias; themilkman216/PR2621 priority order; Marius-Paul Dumitrean/PR2733 independent concentrated/pre-life composition; Vlado Vojdanovski/PR2322 generator utilities. PR2720's fixed-old-path cut obstruction motivates the changed premise. The retained owner/native/bit/modern outer lineage and their notices remain in the pinned source. New work Apache-2.0.
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/composition.py b/research/complex-routing-leaf-fusion/vendor/pr2751/composition.py
new file mode 100644
index 0000000000..bb455e907d
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/vendor/pr2751/composition.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Tekalign (@tekuuu), with substantial OpenAI Codex assistance.
+"""Deterministic PR2673 priority-fill / PR2679 pre-life-word composition.
+
+No solver and no native execution. Match helper indices in increasing order
+within each width queue, delete seven surplus width-4 roles per call, then
+compact each physical bin. Helper indices are width-registry positions, not
+register identities. Final whole-call geometry is checked separately by both
+literal implementations in verify.py; full_replay.py binds actual natives.
+
+Credit Jeremy Kothe's PR2673 fill and PR2621's priority scheduling idea,
+PR2679's pre-life/refit words, PR2588/PR2530 and retained supplier lineage.
+"""
+import argparse
+from collections import Counter, defaultdict
+import gzip
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+import sys
+sys.dont_write_bytecode = True
+
+
+def need(ok, why):
+    if not ok:
+        raise RuntimeError(why)
+
+
+def canonical(value):
+    return json.dumps(value, sort_keys=True, separators=(',', ':')).encode()
+
+
+def transform(old, new, fill, order, initial_dispatch, words):
+    """Reconstruct the full candidate and mapping from authenticated inputs."""
+    need(set(old) == set(new) == set(words) == {'gauge44', 'extra'}, 'provider identities')
+    need(len(order) == 666 and len(set(map(tuple, order))) == 666, 'composition call count')
+    need(len(fill['rows']) == 281052, 'source role count')
+    dispatch = dict(initial_dispatch)
+    for s, r, pid in fill['dispatch_overrides']:
+        need((s, r) in dispatch and pid in new, 'source dispatch override')
+        dispatch[s, r] = pid
+    need(set(dispatch) == set(map(tuple, order)), 'source dispatch coverage')
+    maps, dropped, bindings = {}, {}, {}
+    for pid in sorted(new):
+        oldq, newq = defaultdict(list), defaultdict(list)
+        for i, width in enumerate(old[pid]['widths']):
+            oldq[width].append(i)
+        for i, width in enumerate(new[pid]['widths']):
+            newq[width].append(i)
+        need(len(old[pid]['widths']) == 422 and len(new[pid]['widths']) == 415, 'old/new helper counts')
+        need(set(oldq) == set(newq) == {4, 5, 7, 8, 9}, 'width support')
+        need({w:len(oldq[w])-len(newq[w]) for w in oldq} == {4:7, 5:0, 7:0, 8:0, 9:0}, 'seven surplus width-4 roles')
+        maps[pid] = {i:j for w in sorted(newq) for i,j in zip(oldq[w], newq[w])}
+        dropped[pid] = sorted(set(range(422)) - set(maps[pid]))
+        need(len(maps[pid]) == 415 and set(maps[pid].values()) == set(range(415)), 'new helper bijection')
+        need(all(old[pid]['widths'][i] == new[pid]['widths'][j] for i,j in maps[pid].items()), 'width-preserving bijection')
+        need(len(dropped[pid]) == 7 and all(old[pid]['widths'][i] == 4 for i in dropped[pid]), 'deleted widths')
+        # This binds declared widths/report to the raw word, without claiming
+        # that reading its report proves the actual native program semantics.
+        word = words[pid]
+        remaining = [r for r in range(224, 704) if r not in set(word['removed'])]
+        final = {int(k):v for k,v in word['helper_final'].items()}
+        extra = {int(k):v for k,v in word['start_extra'].items()}
+        actual = [len(final.get(r, range(9))) - len(extra.get(r, [])) for r in remaining]
+        need(actual == new[pid]['widths'], 'raw-word ordered width binding')
+        need(word['report']['local_profile'] == new[pid]['actual_paid_profile'], 'raw-word reported profile binding')
+        bindings[pid] = dict(helpers=len(remaining),
+                            width_inventory=dict(sorted(Counter(actual).items())))
+    rows, removed, bins, oldbins, per_call = [], [], defaultdict(list), defaultdict(list), defaultdict(set)
+    for i, row in enumerate(fill['rows']):
+        need(len(row) == 6 and all(type(v) is int for v in row), 'source role shape')
+        t, h, owner, child, port, offset = row
+        need(0 <= t < 666 and 0 <= h < 422, 'source role bounds')
+        need(h not in per_call[t], 'source duplicate helper')
+        per_call[t].add(h)
+        pid = dispatch[tuple(order[t])]
+        oldbins[owner, child, port].append(old[pid]['widths'][h])
+        if h not in maps[pid]:
+            removed.append((owner, child, port))
+            continue
+        bins[owner, child, port].append(len(rows))
+        rows.append([t, maps[pid][h], owner, child, port, offset])
+    need(set(per_call) == set(range(666)) and all(x == set(range(422)) for x in per_call.values()), 'source helper coverage')
+    need(len(removed) == 4662 and len(set(removed)) == 4662, '4662 distinct affected bins')
+    need(all(sorted(oldbins[key]) == [4, 9, 9, 9] for key in removed), 'source deletion-bin patterns')
+    for indices in bins.values():
+        offset = 0
+        for i in sorted(indices, key=lambda j:rows[j][5]):
+            row = rows[i]
+            row[5] = offset
+            offset += new[dispatch[tuple(order[row[0]])]]['widths'][row[1]]
+    need(len(rows) == 276390, 'composed role count')
+    candidate = dict(fill, rows=rows)
+    mapping = dict(keep_maps=maps, dropped=dropped)
+    report = dict(status='PASS_DETERMINISTIC_WIDTH_QUEUE_COMPOSITION', removed_roles=4662,
+                  affected_bins=4662, source_bin_widths=[4, 9, 9, 9], remaining_bin_widths=[9, 9, 9],
+                  roles=len(rows), calls=666, helpers_per_call=415, width_bindings=bindings,
+                  fill_canonical_sha256=hashlib.sha256(canonical(candidate)).hexdigest())
+    return candidate, mapping, report
+
+
+def check(data):
+    obj = data['objects']
+    original_order = obj['source/pr2673/ORDER.json']
+    initial = {(s,r):p for s,r,p in obj['source/pr2673/DISPATCH.json.gz']}
+    need(initial == data['dispatch'], 'unchanged source dispatch')
+    candidate, mapping, report = transform(
+        obj['source/pr2673/PROVIDERS.json'], data['providers'],
+        obj['source/pr2673/FILL.json.gz'], original_order, initial,
+        {'gauge44':obj['source/pr2679/WORD-base.json.gz'], 'extra':obj['source/pr2679/WORD-extra.json.gz']})
+    need(data['candidate_order'] == original_order, 'unchanged priority order')
+    need(candidate == data['candidate_fill'], 'complete deterministic candidate equality')
+    need(json.loads(canonical(mapping)) == obj['candidate/MAPPING.json'], 'complete deterministic mapping equality')
+    report['mapping_canonical_sha256'] = hashlib.sha256(canonical(json.loads(canonical(mapping)))).hexdigest()
+    return report
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/exact_moment.py b/research/complex-routing-leaf-fusion/vendor/pr2751/exact_moment.py
new file mode 100644
index 0000000000..30dc8aa229
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/vendor/pr2751/exact_moment.py
@@ -0,0 +1,51 @@
+# SPDX-License-Identifier: Apache-2.0
+# Tekalign with substantial OpenAI Codex assistance.
+from fractions import Fraction as F
+DIMENSION=73
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def log_reduced(x):
+    """Forty atanh terms with their positive geometric tail."""
+    require(1 <= x <= 2, 'log reduction range')
+    t = (x - 1) / (x + 1)
+    lower = sum((2 * t ** (2 * j + 1) / (2 * j + 1)
+                 for j in range(40)), F(0))
+    tail = 2 * t ** 81 / (81 * (1 - t * t))
+    return lower, lower + tail
+
+
+def log_bounds(x):
+    require(x >= 1, 'positive logarithm range')
+    power = 0
+    while x >= 2:
+        x /= 2
+        power += 1
+    a, b = log_reduced(x)
+    c, d = log_reduced(F(2))
+    return a + power * c, b + power * d
+
+
+def exp_bounds(x):
+    """Taylor terms 0..15; later term ratios are bounded by x/17."""
+    require(0 <= x < F(1, 100), 'exponential argument range')
+    term, lower = F(1), F(1)
+    for n in range(1, 16):
+        term = term * x / n
+        lower += term
+    tail = term * x / 16 / (1 - x / 17)
+    return lower, lower + tail
+
+
+def moment_bounds(profile, exponent):
+    lower = upper = F(0)
+    for rank, count in sorted(profile.items()):
+        log_lo, log_hi = log_bounds(F(DIMENSION, rank))
+        exp_lo, _ = exp_bounds(exponent * log_lo)
+        _, exp_hi = exp_bounds(exponent * log_hi)
+        weight = F(count * rank, DIMENSION)
+        lower += weight * exp_lo
+        upper += weight * exp_hi
+    return lower, upper
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/independent_local.py b/research/complex-routing-leaf-fusion/vendor/pr2751/independent_local.py
new file mode 100644
index 0000000000..e0b556adc3
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/vendor/pr2751/independent_local.py
@@ -0,0 +1,161 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Mason Hale/Codex PR2696 literal replay, extended by Tekalign/Codex.
+Adds anticipatory corrections, checks six pre-life hosts and checks all twelve
+source-recovery assertions at operator IDs47 through58.
+"""
+import json,gzip,hashlib
+from collections import Counter,defaultdict
+from fractions import Fraction as F
+from functools import lru_cache
+from pathlib import Path
+@lru_cache(None)
+def span(vs):
+    s={0}
+    for v in vs:s|={x^v for x in tuple(s)}
+    return frozenset(s)
+def S(vs):return span(tuple(vs))
+def rank(vs):return len(S(vs)).bit_length()-1
+def dm(s):return len(s).bit_length()-1
+FULL=S([1<<i for i in range(9)])
+def im(cols,x):
+    a=0
+    for i,c in enumerate(cols):
+        if x>>i&1:a^=c
+    return a
+def regs(g):return g[1:3] if g[0]=='add' else g[1:2]
+def nt(r):return not 112<=r<224
+def load(p):return json.loads(gzip.decompress(p.read_bytes()))
+def chronological(w):
+    d=defaultdict(list)
+    for op,(p,r,*_) in enumerate(w['warps'],1):d[p].append(['warp',r,op])
+    b=[]
+    for i in range(len(w['B'])+1):
+        b+=d[i]
+        if i<len(w['B']):b.append(w['B'][i])
+    return b
+
+def check_frames(w):
+    live=set(range(704))-set(w['removed'])
+    cur={r:S([w['ports'][r]]) if r<112 else S(w['start_extra'].get(str(r),[])) for r in live}
+    ends={r:FULL for r in live}
+    for i,p in enumerate(w['ports']):ends[112+i]=frozenset(x for x in range(512) if (x&p).bit_count()%2==0)
+    for r,vs in w['helper_final'].items():ends[int(r)]=S(vs)
+    start=cur.copy();counts=Counter();bysection={};sections={}
+    def climb(r,vs):
+        s=S(vs);assert cur[r]<=s,(r,cur[r],s)
+        d=dm(s)-dm(cur[r]);cur[r]=s
+        if d:counts[d]+=1
+    def warp(r,op,old,new):
+        cols=w['warps'][abs(op)-1][2]
+        assert len(S(cols))==512
+        assert cur[r]==S(old)
+        # Check positive-direction map for either sign, without computing inverse.
+        a,b=(old,new) if op>0 else (new,old)
+        assert frozenset(im(cols,x) for x in S(a))==S(b)
+        cur[r]=S(new)
+    for g in w['A']:
+        if g[0]=='warp':warp(*g[1:])
+        else:
+            for r in regs(g):climb(r,g[-1])
+    bysection['A']=dict(counts);prev=counts.copy()
+    lev={int(k):S(v) for k,v in w['target_levels'].items()}
+    assert all(cur[112+t]==lev.get(t,S([])) for t in range(112))
+    paths=[]
+    for r,vs in zip(w['centers'],w['center_frames']):
+        s=S(vs);assert cur[r]==s
+        targets=[g[1]-112 for g in w['cut'] if g[2]==r]
+        frames=sorted({lev.get(t,S([])) for t in targets},key=lambda s:-len(s))
+        ds=[]
+        for f in frames:
+            assert f<=s
+            d=dm(s)-dm(f)
+            if d:counts[d]+=1;ds.append(d)
+            s=f
+        paths.append({'center':r,'start_rank':rank(vs),'target_offsets':targets,'reader_lines':[sorted(f-{0}) for f in frames],'paid_degrees':ds})
+    bysection['cut']=dict(counts-prev);prev=counts.copy()
+    ops=defaultdict(list)
+    for op,rec in enumerate(w['warps'],1):ops[rec[0]].append((op,rec))
+    for i in range(len(w['B'])+1):
+        for op,(_,r,cols,old,new) in ops[i]:warp(r,op,old,new)
+        if i<len(w['B']):
+            g=w['B'][i]
+            for r in regs(g):climb(r,g[-1])
+    bysection['B']=dict(counts-prev);prev=counts.copy()
+    for g in w['restore']:
+        for r in regs(g):climb(r,g[-1])
+    bysection['restore']=dict(counts-prev);prev=counts.copy()
+    for r in live:climb(r,ends[r])
+    bysection['ends']=dict(counts-prev)
+    inventory=Counter(dm(ends[r])-dm(start[r]) for r in live if r>=224)
+    assert counts==Counter({int(k):v for k,v in w['report']['local_profile'].items()})
+    assert inventory==Counter({int(k):v for k,v in w['report']['width_inventory'].items()})
+    return {'profile':dict(sorted(counts.items())),'section_profiles':bysection,'inventory':dict(sorted(inventory.items())),'center_paths':paths},start,ends
+
+def check_cleanup(w):
+    restored=set(map(int,w['helper_final']))
+    cold=lambda r:r+704 if r in restored else r
+    forward=w['A'][w['prelude_events']:]+chronological(w)+w['restore']
+    expected=[]
+    for g in reversed(forward):
+        if g[0]=='warp':expected.append(['warp',cold(g[1]),-g[2]])
+        elif nt(g[1]):
+            if g[0]=='add':expected.append(['add',cold(g[1]),cold(g[2]),-g[3],g[4]])
+            else:expected.append(['scale',cold(g[1]),g[3],g[2]])
+    assert expected==[g[:-1] for g in w['cleanup']]
+    assert all(S(g[-1])==FULL for g in w['cleanup'])
+    return len(expected)
+
+def algebra(w):
+    # A monomial records its operations oldest-first; appending an inverse
+    # cancels the newest symbol. No native/generator/audit modules imported.
+    live=set(range(704))-set(w['removed']);cold=set(map(int,w['helper_final']))
+    assert all(112<=x['target']<224 and x['source'] in {273,275,289,291,305,321} for x in w['initial_corrections'])
+    program=[['correction',x] for x in w['initial_corrections']]+w['precondition']+w['compensation']+w['A']+w['cut']+chronological(w)+w['restore']
+    result={}
+    for dual in [False,True]:
+        rows={r:{(r,()):F(1)} for r in live}
+        rows.update({704+r:{} for r in cold})
+        def apply(g):
+            op=g[0]
+            if op=='correction':
+                x=g[1];t,s=x['target'],x['source'];q=F(x['coefficient'])
+                ops=list(reversed(x['operator_word']))
+                if dual:
+                    t,s,q=s,t,-q
+                    ops=[-(abs(v)+1000)*(1 if v>0 else -1) for v in x['operator_word']]
+                for (r,word),c in list(rows[s].items()):
+                    for v in ops:word=word[:-1] if word and word[-1]==-v else word+(v,)
+                    key=(r,word);value=rows[t].get(key,F(0))+q*c
+                    if value:rows[t][key]=value
+                    else:rows[t].pop(key,None)
+            elif op=='add':
+                t,s=g[1:3];q=F(g[3],g[4]);assert t!=s
+                if dual:t,s,q=s,t,-q
+                for term,c in list(rows[s].items()):
+                    v=rows[t].get(term,F(0))+q*c
+                    if v:rows[t][term]=v
+                    else:rows[t].pop(term,None)
+            elif op=='scale':
+                q=F(g[2],g[3]);q=1/q if dual else q
+                rows[g[1]]={term:q*c for term,c in rows[g[1]].items()}
+            elif op=='warp':
+                d=g[2]
+                if not dual and 46<d<=58:
+                    assert rows[g[1]]=={(g[1],()):F(1)},('new lender not restored',g,rows[g[1]])
+                if dual:d=(abs(d)+1000)*(1 if d>0 else -1)
+                rows[g[1]]={(r,word[:-1] if word and word[-1]==-d else word+(d,)):c for (r,word),c in rows[g[1]].items()}
+            else:raise AssertionError(op)
+        for g in program:apply(g)
+        if not dual:
+            assert all(rows[112+t]=={(112+t,()):F(1),(t,()):F(1)} for t in range(112))
+            assert all(rows[r]=={(r,()):F(1)} for r in cold)
+            assert all(not any(var in cold-{r} for (var,word) in rows[r]) for r in live)
+        for g in w['cleanup']:apply(g)
+        for r in live:
+            exp={(r,()):F(1)}
+            if dual and r<112:exp[(112+r,())]=F(-1)
+            if not dual and 112<=r<224:exp[(r-112,())]=F(1)
+            assert rows[r]==exp,(dual,r,rows[r])
+        assert all(not rows[704+r] for r in cold)
+        result['dual' if dual else 'forward']='PASS'
+    return result
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/independent_owners.py b/research/complex-routing-leaf-fusion/vendor/pr2751/independent_owners.py
new file mode 100644
index 0000000000..93270b725a
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/vendor/pr2751/independent_owners.py
@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Tekalign (@tekuuu), with substantial OpenAI Codex assistance.
+"""Independent integer-time chronology and bit-mask whole-fill verification.
+
+No retained window code, donor generator, solver or native checker is imported.
+Credit PR2679's pre-life/refit words, PR2673/PR2621 priority scheduling,
+PR2588's swapped words, PR2559's evacuation, PR2530's source-partner
+fill and the PR2462/PR2322/PR2436 lineage;
+Hao Yan and the retained controller authors supply the underlying schedule.
+This checks a finite hosting witness, not native circuitry or an exponent.
+"""
+import argparse
+import sys
+sys.dont_write_bytecode=True
+import gzip
+import hashlib
+import json
+from collections import Counter
+from pathlib import Path
+
+
+def need(ok, why):
+    if not ok:
+        raise RuntimeError(why)
+
+
+def windows(template, order):
+    ranks={c['child']:c['rank'] for c in template['idle_children']}
+    pairs={e['stage']:e['pair'] for e in template['recipe'] if e['kind']=='local'}
+    blocks={};stage=None
+    for event in template['execution_schedule']:
+        if event['kind'] in ('bank_padding_cover_sweep','translate_every_live_family'):
+            continue
+        if event['kind']=='local_cover_sweep':
+            stage=event['stage'];blocks[stage]=[]
+        need(stage is not None,'event before first call')
+        blocks[stage].append(event)
+    progression=[0]*74;last={};result={}
+    for t,(stage,replica) in enumerate(order):
+        need(0<=replica<74 and stage==progression[replica],'order chronology')
+        progression[replica]+=1
+        for j,event in enumerate(blocks[stage]):
+            kind=event['kind']
+            if kind=='local_cover_sweep':
+                need(j==0,'local call position')
+                last[replica,pairs[stage]]=t
+            elif kind=='bridge':
+                last[replica,event['src']]=last[replica,event['dst']]=t
+            elif kind=='idle_cover_sweep':
+                need(j>0,'idle position')
+                start=last.get((replica,event['pair']),-1)
+                for child in event['child_indices']:
+                    if child in ranks:
+                        result[replica,child]=(ranks[child],start,t)
+    need(progression==[9]*74,'complete replica progression')
+    return result
+
+
+def check(plan, template, order, fill, providers, initial_dispatch, expected_profile):
+    need(len(order)==666 and len(set(map(tuple,order)))==666,'call coverage')
+    win=windows(template,order)
+    dispatch=dict(initial_dispatch)
+    for s,r,pid in fill['dispatch_overrides']:
+        need((s,r) in dispatch and pid in providers,'dispatch override')
+        dispatch[s,r]=pid
+    need(set(dispatch)==set(map(tuple,order)),'dispatch coverage')
+    need(fill['columns']==['time','helper','owner_replica','child','port','offset'],'role columns')
+    need(len(fill['rows'])==666*415,'role count')
+    need(all(len(p['widths'])==415 for p in providers.values()),'helper widths')
+    helper_bits=[0]*666;family_bits=[0]*666;occupied={}
+    for row in fill['rows']:
+        need(len(row)==6 and all(type(v) is int for v in row),'role shape')
+        t,h,o,c,port,offset=row
+        need(0<=t<666 and 0<=h<415 and 0<=port<112,'role bounds')
+        cap,start,stop=win[o,c]
+        need(start<t<=stop,'literal call window')
+        hbit=1<<h
+        need(not helper_bits[t]&hbit,'duplicate helper')
+        helper_bits[t]|=hbit
+        fam=o*896+(2*plan['pairs'][str(c)]+plan['sides'][str(c)])*112+port
+        fbit=1<<fam
+        need(not family_bits[t]&fbit,'same-call family collision')
+        family_bits[t]|=fbit
+        width=providers[dispatch[tuple(order[t])]]['widths'][h]
+        need(0<=offset and offset+width<=cap,'bin capacity')
+        mask=((1<<width)-1)<<offset;key=(o,c,port)
+        need(not occupied.get(key,0)&mask,'overlapping bin cells')
+        occupied[key]=occupied.get(key,0)|mask
+    need(helper_bits==[(1<<415)-1]*666,'complete helper inventory')
+    idle=Counter()
+    for (owner,child),(cap,_,_) in win.items():
+        for port in range(112):
+            mask=occupied.get((owner,child,port),0);used=mask.bit_count()
+            need(mask==(1<<used)-1,'compact bin prefix')
+            if used<cap:
+                idle[cap-used]+=1
+    profile=Counter(idle)
+    for call in order:
+        profile.update({int(r):n for r,n in providers[dispatch[tuple(call)]]['actual_paid_profile'].items()})
+    need(profile==expected_profile,'full profile mismatch')
+    mass=sum(r*n for r,n in profile.items())
+    need(mass==73*plan['live']*2-plan['deficit']*2==4816512,'rank mass')
+    serial={f'{o},{c}':[cap,list(range(lo+1,hi+1))] for (o,c),(cap,lo,hi) in win.items()}
+    digest=hashlib.sha256(json.dumps(serial,sort_keys=True,separators=(',',':')).encode()).hexdigest()
+    return dict(status='PASS_INDEPENDENT_INTEGER_CHRONOLOGY_AND_MASK_FILL',roles=276390,
+                calls=666,helpers_per_call=415,windows=len(win),window_sha256=digest,
+                idle=dict(sorted(idle.items())),profile=dict(sorted(profile.items())),rank_mass=mass)
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/DISPATCH.json.gz b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/DISPATCH.json.gz
new file mode 100644
index 0000000000..4f4c2138d6
Binary files /dev/null and b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/DISPATCH.json.gz differ
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/FILL.json.gz b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/FILL.json.gz
new file mode 100644
index 0000000000..17129e917b
Binary files /dev/null and b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/FILL.json.gz differ
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/GLOBAL-TEMPLATE.json.gz b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/GLOBAL-TEMPLATE.json.gz
new file mode 100644
index 0000000000..114808c32b
Binary files /dev/null and b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/GLOBAL-TEMPLATE.json.gz differ
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/ORDER.json b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/ORDER.json
new file mode 100644
index 0000000000..c202d6ec22
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/ORDER.json
@@ -0,0 +1 @@
+[[0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8],[1,0],[0,9],[1,1],[0,10],[1,2],[2,0],[0,11],[1,3],[2,1],[0,12],[1,4],[2,2],[0,13],[3,0],[1,5],[2,3],[0,14],[3,1],[1,6],[2,4],[0,15],[3,2],[1,7],[2,5],[0,16],[3,3],[1,8],[2,6],[0,17],[3,4],[1,9],[2,7],[0,18],[3,5],[1,10],[2,8],[0,19],[3,6],[1,11],[2,9],[0,20],[3,7],[1,12],[2,10],[0,21],[3,8],[1,13],[2,11],[4,0],[0,22],[3,9],[1,14],[2,12],[4,1],[0,23],[3,10],[1,15],[2,13],[4,2],[0,24],[3,11],[1,16],[2,14],[4,3],[0,25],[3,12],[5,0],[1,17],[2,15],[4,4],[0,26],[3,13],[5,1],[1,18],[2,16],[4,5],[0,27],[3,14],[5,2],[1,19],[2,17],[4,6],[0,28],[3,15],[5,3],[1,20],[2,18],[4,7],[0,29],[3,16],[5,4],[6,0],[1,21],[2,19],[4,8],[0,30],[3,17],[5,5],[6,1],[1,22],[2,20],[4,9],[0,31],[3,18],[5,6],[6,2],[1,23],[2,21],[4,10],[0,32],[3,19],[5,7],[6,3],[1,24],[2,22],[4,11],[0,33],[3,20],[5,8],[6,4],[7,0],[1,25],[2,23],[4,12],[0,34],[3,21],[5,9],[6,5],[7,1],[1,26],[2,24],[4,13],[0,35],[3,22],[5,10],[6,6],[7,2],[1,27],[2,25],[4,14],[0,36],[3,23],[5,11],[6,7],[7,3],[1,28],[2,26],[4,15],[0,37],[3,24],[5,12],[6,8],[7,4],[8,0],[1,29],[2,27],[4,16],[0,38],[3,25],[5,13],[6,9],[7,5],[8,1],[1,30],[2,28],[4,17],[0,39],[3,26],[5,14],[6,10],[7,6],[8,2],[1,31],[2,29],[4,18],[0,40],[3,27],[5,15],[6,11],[7,7],[8,3],[1,32],[2,30],[4,19],[0,41],[3,28],[5,16],[6,12],[7,8],[8,4],[1,33],[2,31],[4,20],[0,42],[3,29],[5,17],[6,13],[7,9],[8,5],[1,34],[2,32],[4,21],[0,43],[3,30],[5,18],[6,14],[7,10],[8,6],[1,35],[2,33],[4,22],[0,44],[3,31],[5,19],[6,15],[7,11],[8,7],[1,36],[2,34],[4,23],[0,45],[3,32],[5,20],[6,16],[7,12],[8,8],[1,37],[2,35],[4,24],[0,46],[3,33],[5,21],[6,17],[7,13],[8,9],[1,38],[2,36],[4,25],[0,47],[3,34],[5,22],[6,18],[7,14],[8,10],[1,39],[2,37],[4,26],[0,48],[3,35],[5,23],[6,19],[7,15],[8,11],[1,40],[2,38],[4,27],[0,49],[3,36],[5,24],[6,20],[7,16],[8,12],[1,41],[2,39],[4,28],[0,50],[3,37],[5,25],[6,21],[7,17],[8,13],[1,42],[2,40],[4,29],[0,51],[3,38],[5,26],[6,22],[7,18],[8,14],[1,43],[2,41],[4,30],[0,52],[3,39],[5,27],[6,23],[7,19],[8,15],[1,44],[2,42],[4,31],[0,53],[3,40],[5,28],[6,24],[7,20],[8,16],[1,45],[2,43],[4,32],[0,54],[3,41],[5,29],[6,25],[7,21],[8,17],[1,46],[2,44],[4,33],[0,55],[3,42],[5,30],[6,26],[7,22],[8,18],[1,47],[2,45],[4,34],[0,56],[3,43],[5,31],[6,27],[7,23],[8,19],[1,48],[2,46],[4,35],[0,57],[3,44],[5,32],[6,28],[7,24],[8,20],[1,49],[2,47],[4,36],[0,58],[3,45],[5,33],[6,29],[7,25],[8,21],[1,50],[2,48],[4,37],[0,59],[3,46],[5,34],[6,30],[7,26],[8,22],[1,51],[2,49],[4,38],[0,60],[3,47],[5,35],[6,31],[7,27],[8,23],[1,52],[2,50],[4,39],[0,61],[3,48],[5,36],[6,32],[7,28],[8,24],[1,53],[2,51],[4,40],[0,62],[3,49],[5,37],[6,33],[7,29],[8,25],[1,54],[2,52],[4,41],[0,63],[3,50],[5,38],[6,34],[7,30],[8,26],[1,55],[2,53],[4,42],[0,64],[3,51],[5,39],[6,35],[7,31],[8,27],[1,56],[2,54],[4,43],[0,65],[3,52],[5,40],[6,36],[7,32],[8,28],[1,57],[2,55],[4,44],[0,66],[3,53],[5,41],[6,37],[7,33],[8,29],[1,58],[2,56],[4,45],[0,67],[3,54],[5,42],[6,38],[7,34],[8,30],[1,59],[2,57],[4,46],[0,68],[3,55],[5,43],[6,39],[7,35],[8,31],[1,60],[2,58],[4,47],[0,69],[3,56],[5,44],[6,40],[7,36],[8,32],[1,61],[2,59],[4,48],[0,70],[3,57],[5,45],[6,41],[7,37],[8,33],[1,62],[2,60],[4,49],[0,71],[3,58],[5,46],[6,42],[7,38],[8,34],[1,63],[2,61],[4,50],[0,72],[3,59],[5,47],[6,43],[7,39],[8,35],[1,64],[2,62],[4,51],[0,73],[3,60],[5,48],[6,44],[7,40],[8,36],[1,65],[2,63],[4,52],[3,61],[5,49],[6,45],[7,41],[8,37],[1,66],[2,64],[4,53],[3,62],[5,50],[6,46],[7,42],[8,38],[1,67],[2,65],[4,54],[3,63],[5,51],[6,47],[7,43],[8,39],[1,68],[2,66],[4,55],[3,64],[5,52],[6,48],[7,44],[8,40],[1,69],[2,67],[4,56],[3,65],[5,53],[6,49],[7,45],[8,41],[1,70],[2,68],[4,57],[3,66],[5,54],[6,50],[7,46],[8,42],[1,71],[2,69],[4,58],[3,67],[5,55],[6,51],[7,47],[8,43],[1,72],[2,70],[4,59],[3,68],[5,56],[6,52],[7,48],[8,44],[1,73],[2,71],[4,60],[3,69],[5,57],[6,53],[7,49],[8,45],[2,72],[4,61],[3,70],[5,58],[6,54],[7,50],[8,46],[2,73],[4,62],[3,71],[5,59],[6,55],[7,51],[8,47],[4,63],[3,72],[5,60],[6,56],[7,52],[8,48],[4,64],[3,73],[5,61],[6,57],[7,53],[8,49],[4,65],[5,62],[6,58],[7,54],[8,50],[4,66],[5,63],[6,59],[7,55],[8,51],[4,67],[5,64],[6,60],[7,56],[8,52],[4,68],[5,65],[6,61],[7,57],[8,53],[4,69],[5,66],[6,62],[7,58],[8,54],[4,70],[5,67],[6,63],[7,59],[8,55],[4,71],[5,68],[6,64],[7,60],[8,56],[4,72],[5,69],[6,65],[7,61],[8,57],[4,73],[5,70],[6,66],[7,62],[8,58],[5,71],[6,67],[7,63],[8,59],[5,72],[6,68],[7,64],[8,60],[5,73],[6,69],[7,65],[8,61],[6,70],[7,66],[8,62],[6,71],[7,67],[8,63],[6,72],[7,68],[8,64],[6,73],[7,69],[8,65],[7,70],[8,66],[7,71],[8,67],[7,72],[8,68],[7,73],[8,69],[8,70],[8,71],[8,72],[8,73]]
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/PLAN.json.gz b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/PLAN.json.gz
new file mode 100644
index 0000000000..973f576bcc
Binary files /dev/null and b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/PLAN.json.gz differ
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/PROVIDERS.json b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/PROVIDERS.json
new file mode 100644
index 0000000000..26be26b6d2
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/PROVIDERS.json
@@ -0,0 +1 @@
+{"extra":{"actual_paid_profile":{"1":2366,"2":646,"3":297,"4":120,"5":26,"8":8},"widths":[9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,7,7,7,7,7,7,7,7,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,8,8,7,7,7,7,9,9,9,9,7,7,7,7,7,7,9,9,9,9,8,8,8,9,8,8,9,9,9,9,8,7,7,8,9,8,8,9,9,9,9,8,8,8,7,7,7,7,7,7,7,7,9,7,7,7,7,7,7,7,7,7,7,7,9,7,8,8,9,9,9,9,8,8,8,8,7,7,7,7,9,8,9,8,8,8,8,8,7,7,9,8,9,8,7,7,7,7,8,8,8,8,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,5,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,5,8,5,5,5,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,5,8,5,5,5,8,8,8,8]},"gauge44":{"actual_paid_profile":{"1":2366,"2":646,"3":297,"4":120,"5":26,"8":8},"widths":[9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,9,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,7,7,7,7,7,7,7,7,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,8,8,7,7,7,7,9,9,9,9,7,7,7,7,7,7,9,9,9,9,8,8,8,9,8,8,9,9,9,9,8,7,7,8,9,8,8,9,9,9,9,8,8,8,7,7,7,7,7,7,7,7,9,7,7,7,7,7,7,7,7,7,7,7,9,7,8,8,9,9,9,9,8,8,8,8,7,7,7,7,9,8,9,8,8,8,8,8,7,7,9,8,9,8,7,7,7,7,8,8,8,8,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,5,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,5,8,5,5,5,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,5,8,5,5,5,8,8,8,8]}}
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/SOURCE-FILL.json.gz b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/SOURCE-FILL.json.gz
new file mode 100644
index 0000000000..4a0d605902
Binary files /dev/null and b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/SOURCE-FILL.json.gz differ
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/SOURCE-ORDER.json b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/SOURCE-ORDER.json
new file mode 100644
index 0000000000..7141bd58cc
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/SOURCE-ORDER.json
@@ -0,0 +1 @@
+[[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6], [0, 7], [0, 8], [1, 0], [0, 9], [1, 1], [0, 10], [1, 2], [2, 0], [0, 11], [1, 3], [2, 1], [0, 12], [1, 4], [2, 2], [0, 13], [3, 0], [1, 5], [2, 3], [0, 14], [3, 1], [1, 6], [2, 4], [0, 15], [3, 2], [1, 7], [2, 5], [0, 16], [3, 3], [1, 8], [2, 6], [0, 17], [3, 4], [1, 9], [2, 7], [0, 18], [3, 5], [1, 10], [2, 8], [0, 19], [3, 6], [1, 11], [2, 9], [0, 20], [3, 7], [1, 12], [2, 10], [0, 21], [3, 8], [1, 13], [2, 11], [4, 0], [0, 22], [3, 9], [1, 14], [2, 12], [4, 1], [0, 23], [3, 10], [1, 15], [2, 13], [4, 2], [0, 24], [3, 11], [1, 16], [2, 14], [4, 3], [0, 25], [3, 12], [5, 0], [1, 17], [2, 15], [4, 4], [0, 26], [3, 13], [5, 1], [1, 18], [2, 16], [4, 5], [0, 27], [3, 14], [5, 2], [1, 19], [2, 17], [4, 6], [0, 28], [3, 15], [5, 3], [1, 20], [2, 18], [4, 7], [0, 29], [3, 16], [5, 4], [6, 0], [1, 21], [2, 19], [4, 8], [0, 30], [3, 17], [5, 5], [6, 1], [1, 22], [2, 20], [4, 9], [0, 31], [3, 18], [5, 6], [6, 2], [1, 23], [2, 21], [4, 10], [0, 32], [3, 19], [5, 7], [6, 3], [1, 24], [2, 22], [4, 11], [0, 33], [3, 20], [5, 8], [6, 4], [7, 0], [1, 25], [2, 23], [4, 12], [0, 34], [3, 21], [5, 9], [6, 5], [7, 1], [1, 26], [2, 24], [4, 13], [0, 35], [3, 22], [5, 10], [6, 6], [7, 2], [1, 27], [2, 25], [4, 14], [0, 36], [3, 23], [5, 11], [6, 7], [7, 3], [1, 28], [2, 26], [4, 15], [0, 37], [3, 24], [5, 12], [6, 8], [7, 4], [8, 0], [1, 29], [2, 27], [4, 16], [0, 38], [3, 25], [5, 13], [6, 9], [7, 5], [8, 1], [1, 30], [2, 28], [4, 17], [0, 39], [3, 26], [5, 14], [6, 10], [7, 6], [8, 2], [1, 31], [2, 29], [4, 18], [0, 40], [3, 27], [5, 15], [6, 11], [7, 7], [8, 3], [1, 32], [2, 30], [4, 19], [0, 41], [3, 28], [5, 16], [6, 12], [7, 8], [8, 4], [1, 33], [2, 31], [4, 20], [0, 42], [3, 29], [5, 17], [6, 13], [7, 9], [8, 5], [1, 34], [2, 32], [4, 21], [0, 43], [3, 30], [5, 18], [6, 14], [7, 10], [8, 6], [1, 35], [2, 33], [4, 22], [0, 44], [3, 31], [5, 19], [6, 15], [7, 11], [8, 7], [1, 36], [2, 34], [4, 23], [0, 45], [3, 32], [5, 20], [6, 16], [7, 12], [8, 8], [1, 37], [2, 35], [4, 24], [0, 46], [3, 33], [5, 21], [6, 17], [7, 13], [8, 9], [1, 38], [2, 36], [4, 25], [0, 47], [3, 34], [5, 22], [6, 18], [7, 14], [8, 10], [1, 39], [2, 37], [4, 26], [0, 48], [3, 35], [5, 23], [6, 19], [7, 15], [8, 11], [1, 40], [2, 38], [4, 27], [0, 49], [3, 36], [5, 24], [6, 20], [7, 16], [8, 12], [1, 41], [2, 39], [4, 28], [0, 50], [3, 37], [5, 25], [6, 21], [7, 17], [8, 13], [1, 42], [2, 40], [4, 29], [0, 51], [3, 38], [5, 26], [6, 22], [7, 18], [8, 14], [1, 43], [2, 41], [4, 30], [0, 52], [3, 39], [5, 27], [6, 23], [7, 19], [8, 15], [1, 44], [2, 42], [4, 31], [0, 53], [3, 40], [5, 28], [6, 24], [7, 20], [8, 16], [1, 45], [2, 43], [4, 32], [0, 54], [3, 41], [5, 29], [6, 25], [7, 21], [8, 17], [1, 46], [2, 44], [4, 33], [0, 55], [3, 42], [5, 30], [6, 26], [7, 22], [8, 18], [1, 47], [2, 45], [4, 34], [0, 56], [3, 43], [5, 31], [6, 27], [7, 23], [8, 19], [1, 48], [2, 46], [4, 35], [0, 57], [3, 44], [5, 32], [6, 28], [7, 24], [8, 20], [1, 49], [2, 47], [4, 36], [0, 58], [3, 45], [5, 33], [6, 29], [7, 25], [8, 21], [1, 50], [2, 48], [4, 37], [0, 59], [3, 46], [5, 34], [6, 30], [7, 26], [8, 22], [1, 51], [2, 49], [4, 38], [0, 60], [3, 47], [5, 35], [6, 31], [7, 27], [8, 23], [1, 52], [2, 50], [4, 39], [0, 61], [3, 48], [5, 36], [6, 32], [7, 28], [8, 24], [1, 53], [2, 51], [4, 40], [0, 62], [3, 49], [5, 37], [6, 33], [7, 29], [8, 25], [1, 54], [2, 52], [4, 41], [0, 63], [3, 50], [5, 38], [6, 34], [7, 30], [8, 26], [1, 55], [2, 53], [4, 42], [0, 64], [3, 51], [5, 39], [6, 35], [7, 31], [8, 27], [1, 56], [2, 54], [4, 43], [0, 65], [3, 52], [5, 40], [6, 36], [7, 32], [8, 28], [1, 57], [2, 55], [4, 44], [0, 66], [3, 53], [5, 41], [6, 37], [7, 33], [8, 29], [1, 58], [2, 56], [4, 45], [0, 67], [3, 54], [5, 42], [6, 38], [7, 34], [8, 30], [1, 59], [2, 57], [4, 46], [0, 68], [3, 55], [5, 43], [6, 39], [7, 35], [8, 31], [1, 60], [2, 58], [4, 47], [0, 69], [3, 56], [5, 44], [6, 40], [7, 36], [8, 32], [1, 61], [2, 59], [4, 48], [0, 70], [3, 57], [5, 45], [6, 41], [7, 37], [8, 33], [1, 62], [2, 60], [4, 49], [0, 71], [3, 58], [5, 46], [6, 42], [7, 38], [8, 34], [1, 63], [2, 61], [4, 50], [0, 72], [3, 59], [5, 47], [6, 43], [7, 39], [8, 35], [1, 64], [2, 62], [4, 51], [0, 73], [3, 60], [5, 48], [6, 44], [7, 40], [8, 36], [1, 65], [2, 63], [4, 52], [3, 61], [5, 49], [6, 45], [7, 41], [8, 37], [1, 66], [2, 64], [4, 53], [3, 62], [5, 50], [6, 46], [7, 42], [8, 38], [1, 67], [2, 65], [4, 54], [3, 63], [5, 51], [6, 47], [7, 43], [8, 39], [1, 68], [2, 66], [4, 55], [3, 64], [5, 52], [6, 48], [7, 44], [8, 40], [1, 69], [2, 67], [4, 56], [3, 65], [5, 53], [6, 49], [7, 45], [8, 41], [1, 70], [2, 68], [4, 57], [3, 66], [5, 54], [6, 50], [7, 46], [8, 42], [1, 71], [2, 69], [4, 58], [3, 67], [5, 55], [6, 51], [7, 47], [8, 43], [1, 72], [2, 70], [4, 59], [3, 68], [5, 56], [6, 52], [7, 48], [8, 44], [1, 73], [2, 71], [4, 60], [3, 69], [5, 57], [6, 53], [7, 49], [8, 45], [2, 72], [4, 61], [3, 70], [5, 58], [6, 54], [7, 50], [8, 46], [2, 73], [4, 62], [3, 71], [5, 59], [6, 55], [7, 51], [8, 47], [4, 63], [3, 72], [5, 60], [6, 56], [7, 52], [8, 48], [4, 64], [3, 73], [5, 61], [6, 57], [7, 53], [8, 49], [4, 65], [5, 62], [6, 58], [7, 54], [8, 50], [4, 66], [5, 63], [6, 59], [7, 55], [8, 51], [4, 67], [5, 64], [6, 60], [7, 56], [8, 52], [4, 68], [5, 65], [6, 61], [7, 57], [8, 53], [4, 69], [5, 66], [6, 62], [7, 58], [8, 54], [4, 70], [5, 67], [6, 63], [7, 59], [8, 55], [4, 71], [5, 68], [6, 64], [7, 60], [8, 56], [4, 72], [5, 69], [6, 65], [7, 61], [8, 57], [4, 73], [5, 70], [6, 66], [7, 62], [8, 58], [5, 71], [6, 67], [7, 63], [8, 59], [5, 72], [6, 68], [7, 64], [8, 60], [5, 73], [6, 69], [7, 65], [8, 61], [6, 70], [7, 66], [8, 62], [6, 71], [7, 67], [8, 63], [6, 72], [7, 68], [8, 64], [6, 73], [7, 69], [8, 65], [7, 70], [8, 66], [7, 71], [8, 67], [7, 72], [8, 68], [7, 73], [8, 69], [8, 70], [8, 71], [8, 72], [8, 73]]
\ No newline at end of file
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/SOURCE-PROVIDERS.json b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/SOURCE-PROVIDERS.json
new file mode 100644
index 0000000000..d49a003505
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/SOURCE-PROVIDERS.json
@@ -0,0 +1 @@
+{"gauge44":{"widths":[9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,7,7,7,7,7,7,7,7,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,8,8,7,7,7,7,9,9,9,9,9,9,7,7,7,7,7,7,9,9,9,9,9,9,8,8,8,9,8,8,9,9,9,9,8,9,7,7,8,9,8,8,9,9,9,9,8,9,8,8,7,7,7,7,7,7,7,7,9,7,7,7,7,7,7,7,7,7,7,7,9,7,8,8,9,9,9,9,8,8,8,8,7,7,7,7,9,8,9,8,8,8,8,8,7,7,9,8,9,8,7,7,7,7,8,8,8,8,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,5,8,8,8,8,8,8,8,8,8,8,8,8,8,5,8,5,5,5,8,8,8,8,4,8,8,8,5,8,5,5,5,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8],"actual_paid_profile":{"1":2367,"2":632,"3":318,"4":120,"5":26,"7":8}},"extra":{"widths":[9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,8,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,4,9,4,9,4,9,9,9,9,4,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,7,7,7,7,7,7,7,7,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,8,8,7,7,7,7,9,9,9,9,9,9,7,7,7,7,7,7,9,9,9,9,9,9,8,8,8,9,8,8,9,9,9,9,8,9,7,7,8,9,8,8,9,9,9,9,8,9,8,8,7,7,7,7,7,7,7,7,9,7,7,7,7,7,7,7,7,7,7,7,9,7,8,8,9,9,9,9,8,8,8,8,7,7,7,7,9,8,9,8,8,8,8,8,7,7,9,8,9,8,7,7,7,7,8,8,8,8,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,5,8,8,8,8,8,8,8,8,8,8,8,8,8,5,8,5,5,5,8,8,8,8,4,8,8,8,5,8,5,5,5,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8],"actual_paid_profile":{"1":2367,"2":632,"3":318,"4":120,"5":26,"7":8}}}
\ No newline at end of file
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/WORD-base.json.gz b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/WORD-base.json.gz
new file mode 100644
index 0000000000..f1fc67a6ea
Binary files /dev/null and b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/WORD-base.json.gz differ
diff --git a/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/WORD-extra.json.gz b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/WORD-extra.json.gz
new file mode 100644
index 0000000000..f06e80c4dd
Binary files /dev/null and b/research/complex-routing-leaf-fusion/vendor/pr2751/inputs/WORD-extra.json.gz differ
diff --git a/research/complex-routing-leaf-fusion/verify.py b/research/complex-routing-leaf-fusion/verify.py
new file mode 100644
index 0000000000..2cc11d37f9
--- /dev/null
+++ b/research/complex-routing-leaf-fusion/verify.py
@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Read-only complete-word/hosting replay for the credited frame composition.
+
+Predecessor algorithms retain their notices in vendor/pr2751. The new generator
+changes one frame in each complete word. Native/outer admission is separate.
+Prepared for David Arias with substantial OpenAI Codex assistance.
+"""
+import copy
+from fractions import Fraction
+import gzip
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+import sys
+
+sys.dont_write_bytecode = True
+HERE = Path(__file__).resolve().parent
+SOURCE = HERE / 'vendor/pr2751'
+
+
+def need(ok, reason):
+    if not ok:
+        raise ValueError(reason)
+
+
+def read(path):
+    raw = path.read_bytes()
+    return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw)
+
+
+def module(name, path):
+    # Compile the authenticated bytes, never a possibly stale bytecode cache.
+    spec = importlib.util.spec_from_file_location(name, path)
+    result = importlib.util.module_from_spec(spec)
+    exec(compile(path.read_bytes(), str(path), 'exec'), result.__dict__)
+    return result
+
+
+def authenticate():
+    pins = read(HERE / 'PREDECESSOR.json')
+    need(pins['head'] == '4cfbb0cc8314d7fb4e8e754545a49a42eb590a69', 'predecessor head')
+    need(pins['root'] == 'vendor/pr2751', 'predecessor root')
+    for name, entry in pins['files'].items():
+        path = SOURCE / name
+        need(path.is_file() and not path.is_symlink(), 'predecessor file ' + name)
+        raw = path.read_bytes()
+        need(hashlib.sha256(raw).hexdigest() == entry['sha256'], 'predecessor SHA256 ' + name)
+        blob = hashlib.sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest()
+        need(blob == entry['git_blob'], 'predecessor Git blob ' + name)
+    return len(pins['files'])
+
+
+def rejects(fn, label):
+    try:
+        fn()
+    except (AssertionError, ValueError, RuntimeError):
+        return
+    raise ValueError('accepted negative control: ' + label)
+
+
+def run():
+    need(__debug__, 'run without -O: retained symbolic checker uses assertions')
+    authenticated = authenticate()
+    G = module('frame_composition_generator', HERE / 'generate.py')
+    L = module('pr2751_literal', SOURCE / 'independent_local.py')
+    I = module('pr2751_owners', SOURCE / 'independent_owners.py')
+    C = module('pr2751_composition', SOURCE / 'composition.py')
+    M = module('pr2751_moment', SOURCE / 'exact_moment.py')
+    words, reports = {}, {}
+    controls = []
+    for tag, provider in (('base', 'gauge44'), ('extra', 'extra')):
+        old = read(SOURCE / f'inputs/WORD-{tag}.json.gz')
+        word = read(HERE / f'inputs/WORD-{tag}.json.gz')
+        need(word == G.patch(old), 'complete generated word equality: ' + tag)
+        old_frames, old_start, old_end = L.check_frames(old)
+        frames, start, end = L.check_frames(word)
+        need(start == old_start and end == old_end, 'unchanged complete boundary frames')
+        need(frames['inventory'] == old_frames['inventory'], 'unchanged helper stock')
+        need(L.check_cleanup(word) == L.check_cleanup(old), 'unchanged cleanup length')
+        need(word['cleanup'] == old['cleanup'], 'byte-semantic unchanged cleanup')
+        L.algebra(word)
+        words[provider] = word
+        reports[provider] = frames
+        # Retain the predecessor's actual arbitrary-dirty-input failure controls.
+        for label in ('drop_anticipatory', 'reverse_anticipatory', 'reverse_recovery'):
+            bad = copy.deepcopy(word)
+            if label == 'drop_anticipatory':
+                bad['initial_corrections'].pop()
+            elif label == 'reverse_anticipatory':
+                bad['initial_corrections'][0]['coefficient'] = str(-Fraction(bad['initial_corrections'][0]['coefficient']))
+            else:
+                index = next(i for i, gate in enumerate(bad['B']) if gate[:5] == ['add', 49, 33, -1, 1])
+                bad['B'][index][3] = 1
+            rejects(lambda: L.algebra(bad), tag + ':' + label)
+            controls.append(tag + ':' + label)
+        # Pricing an unchanged source word as if it contained the refit is false.
+        bad = copy.deepcopy(old)
+        bad['report']['local_profile'] = copy.deepcopy(word['report']['local_profile'])
+        rejects(lambda: L.check_frames(bad), tag + ':omitted_refit')
+        controls.append(tag + ':omitted_refit')
+
+    def inp(name):
+        return read(SOURCE / 'inputs' / name)
+
+    providers = inp('PROVIDERS.json')
+    for provider, word in words.items():
+        providers[provider]['actual_paid_profile'] = word['report']['local_profile']
+    order, fill = inp('ORDER.json'), inp('FILL.json.gz')
+    dispatch = {(s, r): p for s, r, p in inp('DISPATCH.json.gz')}
+    need(order == inp('SOURCE-ORDER.json'), 'unchanged entire call order')
+    reconstructed, _, _ = C.transform(inp('SOURCE-PROVIDERS.json'), providers,
+                                      inp('SOURCE-FILL.json.gz'), order, dispatch, words)
+    need(reconstructed == fill, 'unchanged complete physical allocation')
+    profile = {int(k): v for k, v in read(HERE / 'PROFILE.json').items()}
+    old_profile = {int(k): v for k, v in read(SOURCE / 'PROFILE.json').items()}
+    expected = dict(old_profile)
+    expected[1] -= 1332
+    expected[2] += 666
+    need(profile == expected, 'complete global delta 666*(H2-2H1)')
+    owner = I.check(inp('PLAN.json.gz'), inp('GLOBAL-TEMPLATE.json.gz'), order,
+                    fill, providers, dispatch, profile)
+    bad_fill = copy.deepcopy(fill)
+    bad_fill['rows'][0][5] = 999
+    rejects(lambda: I.check(inp('PLAN.json.gz'), inp('GLOBAL-TEMPLATE.json.gz'),
+                            order, bad_fill, providers, dispatch, profile), 'out_of_bin')
+    controls.append('out_of_bin')
+    rejects(lambda: I.check(inp('PLAN.json.gz'), inp('GLOBAL-TEMPLATE.json.gz'),
+                            order, fill, providers, dispatch, old_profile), 'old_profile')
+    controls.append('old_profile')
+    claim = read(HERE / 'CLAIM.json')
+    low, high = Fraction(claim['complex_lower']), Fraction(claim['complex_upper'])
+    need(low == Fraction('0.001717256973467002308270') and high-low == Fraction(1, 10**24),
+         'claim exact adjacent endpoint binding')
+    need({int(k): v for k, v in claim['profile'].items()} == profile, 'claim complete profile binding')
+    need(Fraction(claim['kappa']) == low-Fraction(1, 10**46)-Fraction(1, 10**70),
+         'claim modern outer target binding')
+    need(Fraction(claim['kappa']) > Fraction(read(SOURCE/'CLAIM.json')['kappa']),
+         'strict improvement over source target')
+    _, lower_hi = M.moment_bounds(profile, low)
+    upper_lo, _ = M.moment_bounds(profile, high)
+    source_lo, _ = M.moment_bounds(old_profile, low)
+    need(lower_hi < 66304 < upper_lo and source_lo > 66304,
+         'retained independent interval engine root and strict source comparison')
+    return dict(status='PASS_COMPLETE_FRAME_COMPOSITION', authenticated_files=authenticated,
+                providers=reports, roles=owner['roles'], calls=len(order),
+                profile={str(k): v for k, v in sorted(profile.items())},
+                rank_mass=sum(k*v for k, v in profile.items()), controls=controls,
+                complex_lower=str(low), complex_upper=str(high), kappa=claim['kappa'],
+                scope='Complete finite words and allocation; fresh native and outer release are separate.')
+
+
+if __name__ == '__main__':
+    actual = run()
+    expected = read(HERE / 'RESULT.json')
+    canonical = lambda value: json.dumps(value, sort_keys=True, separators=(',', ':'))
+    need(canonical(actual) == canonical(expected), 'complete typed RESULT.json equality')
+    print(json.dumps(actual, sort_keys=True, indent=2))