diff --git a/research/coupled-tail-support-floor/.gitattributes b/research/coupled-tail-support-floor/.gitattributes
new file mode 100644
index 0000000000..fa1385d99a
--- /dev/null
+++ b/research/coupled-tail-support-floor/.gitattributes
@@ -0,0 +1 @@
+* -text
diff --git a/research/coupled-tail-support-floor/.gitignore b/research/coupled-tail-support-floor/.gitignore
new file mode 100644
index 0000000000..43ae0e2a6c
--- /dev/null
+++ b/research/coupled-tail-support-floor/.gitignore
@@ -0,0 +1,2 @@
+__pycache__/
+*.py[cod]
diff --git a/research/coupled-tail-support-floor/BINDINGS.json b/research/coupled-tail-support-floor/BINDINGS.json
new file mode 100644
index 0000000000..a4d8412d17
--- /dev/null
+++ b/research/coupled-tail-support-floor/BINDINGS.json
@@ -0,0 +1,1027 @@
+{
+  "compressed_inputs": {
+    "source/coupled-tail-escape/LOCAL-BLOCK.json": {
+      "logical_bytes": 178927,
+      "logical_sha256": "aad2ee156a1f1e028b4e0329b4af1c38285f0be90c27da720d4bb71885c29294",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/LOCAL-BLOCK.json",
+      "storage_path": "source/coupled-tail-escape/LOCAL-BLOCK.json.gz",
+      "transport_bytes": 6561,
+      "transport_sha256": "e72ff85b051ebfe909e24cc95b6e79225edc3cd5b80916a5e09c842b5271a8e3"
+    },
+    "source/coupled-tail-escape/Q3-LOCAL-BLOCK.json": {
+      "logical_bytes": 275744,
+      "logical_sha256": "3ad4d1bb498cd67588af0c0558c32b441b35dac56b9f3bb7001ae317fadc28fa",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/Q3-LOCAL-BLOCK.json",
+      "storage_path": "source/coupled-tail-escape/Q3-LOCAL-BLOCK.json.gz",
+      "transport_bytes": 7429,
+      "transport_sha256": "a33c81c3d083aebd05c0bdbc8d6ce50a027f3af5a237b1aa002c3786435a0913"
+    },
+    "source/early-cut58-planning/CUT58.json": {
+      "logical_bytes": 237184,
+      "logical_sha256": "7553ec4f63272cd4b8efb16b2ec01183240be248e36a5dc45df32f9ebd24de58",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/CUT58.json",
+      "storage_path": "source/early-cut58-planning/CUT58.json.gz",
+      "transport_bytes": 6902,
+      "transport_sha256": "52011fdf490b90332a1651e66aa62741fe11da88a76a433fddc8ca413c68c800"
+    },
+    "source/folded-fusion/SIMPLIFIED-FUSIONS.json": {
+      "logical_bytes": 3658155,
+      "logical_sha256": "4491cfe2a1f3e48510b33403b9b50c704865c3b1dc6d659ef5157840654e8fc3",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/folded-fusion/SIMPLIFIED-FUSIONS.json",
+      "storage_path": "source/folded-fusion/SIMPLIFIED-FUSIONS.json.gz",
+      "transport_bytes": 75233,
+      "transport_sha256": "7780976645e1aa1e4858b4c109b440faed0327a76cfa51fe58d049f6e5a07276"
+    },
+    "source/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json": {
+      "logical_bytes": 2438797,
+      "logical_sha256": "30d3f569d91304856118796f0c586176d0ad961eff70b09c78fce7532392101f",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json",
+      "storage_path": "source/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json.gz",
+      "transport_bytes": 49046,
+      "transport_sha256": "ee1b8e64355381f4347c28b6a741e25b00bec83182357896cd803eb3a525aaf0"
+    }
+  },
+  "cut58_raw_sources": [
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/stabilizer-escape/full_stabilizer_bound.py",
+      "relative": "source/vendor/full_stabilizer_bound.py",
+      "sha256": "f073a00ad4831616e873eb110fd33ad7226010a7c2f6cfa6a6b63167bf58ef75"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/free_ops.py",
+      "relative": "source/caller/free_ops.py",
+      "sha256": "5806fe91b9fda162d5986b12e085b14eb3df9a4703f749f61c1f10363138ca77"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_family.py",
+      "relative": "source/caller/nested_family.py",
+      "sha256": "88f425d12baf8a4f849cccd24605f21680eb8ce8d199054db4b4e7734eca72b6"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_prefix.py",
+      "relative": "source/caller/nested_prefix.py",
+      "sha256": "9ec10cb0243c0c829475ad7290f4953cdff27cb0f90f70b687c4bbee98af676b"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/pivot_plane_probe.py",
+      "relative": "source/caller/pivot_plane_probe.py",
+      "sha256": "fcd0a4a0a301c4fddfb8b132894e8b5b751b08cacdb0e5ed41e80b0d4903d499"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py",
+      "relative": "source/native-frames/conjugated_reflection.py",
+      "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/even_parity_source.py",
+      "relative": "source/native-frames/even_parity_source.py",
+      "sha256": "961f136e4bc1b5da930bdd4ba9bbb594892b9e27f7ab44749d747d4fe16b4cb3"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/lifted_algebra.py",
+      "relative": "source/native-frames/lifted_algebra.py",
+      "sha256": "3b9a58a2048a762ab520ac7fdbb28cbfeb7b30345aaeb777d8dabdd9fb1034d9"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py",
+      "relative": "original/native-frames/native_model.py",
+      "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/orthogonal_source_normalizer.py",
+      "relative": "source/native-frames/orthogonal_source_normalizer.py",
+      "sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-chronology/quadratic_charts.py",
+      "relative": "source/root-chronology/quadratic_charts.py",
+      "sha256": "de2a36f6a6b567360c90477b58da44e2f1b618fd006d058ab1ea04e983952c3f"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/caller-joint/joint_algebra.py",
+      "relative": "original/caller-joint/joint_algebra.py",
+      "sha256": "5782033e347c9b10ad47c01ed12a0a52ea07e901fa9e8f7aa9d3a2a928327232"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/completed-gates-review/MANIFEST.json",
+      "relative": "original/dependencies/ef3697eece91ee6d52ae3f5e88b95028091829d6961118052dff1e25df212ba3-MANIFEST.json",
+      "sha256": "ef3697eece91ee6d52ae3f5e88b95028091829d6961118052dff1e25df212ba3"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/completed-gates-review/audit_gates.py",
+      "relative": "source/completed-gates-review/audit_gates.py",
+      "sha256": "051ba51e02e9f143b8a8bea0b91d69e7e1e32edf0f98d2d40db290f02043d460"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/ALL-Q-TAIL-LEMMA.md",
+      "relative": "source/coupled-tail-escape/ALL-Q-TAIL-LEMMA.md",
+      "sha256": "f3b8c42c0fe7d5c5a542e38fe0b3d14601c170959e18a45b60f26128703560b2"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/HANDOFF.md",
+      "relative": "source/coupled-tail-escape/HANDOFF.md",
+      "sha256": "25aa7a2e7408cca9402e34ba809bb8a487c79a4d012d5b8c4700dc81502741aa"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/LOCAL-BLOCK.json",
+      "relative": "source/coupled-tail-escape/LOCAL-BLOCK.json",
+      "sha256": "aad2ee156a1f1e028b4e0329b4af1c38285f0be90c27da720d4bb71885c29294"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/MANIFEST.json",
+      "relative": "source/coupled-tail-escape/MANIFEST.json",
+      "sha256": "f3c5b9829e61866988b0843e5bcb637fb0ae37434e2f8e6ef74bdeef079e126e"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/PROOF.md",
+      "relative": "source/coupled-tail-escape/PROOF.md",
+      "sha256": "5b4300fb15364dbdb17974d6d0bb7d387a189ff814fd0293057ea2a47ac58587"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/Q3-LOCAL-BLOCK.json",
+      "relative": "source/coupled-tail-escape/Q3-LOCAL-BLOCK.json",
+      "sha256": "3ad4d1bb498cd67588af0c0558c32b441b35dac56b9f3bb7001ae317fadc28fa"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/VALIDATION.json",
+      "relative": "source/coupled-tail-escape/VALIDATION.json",
+      "sha256": "e1b6ccf248fa65973645d41b34a7119f07df5d70e73dcfb36cf335ff2ec45e31"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/local_block.py",
+      "relative": "original/coupled-tail-escape/local_block.py",
+      "sha256": "ac8abc744c616e60a221e8fadf1b590f2248f953bafcb2f61675d1c2541f7fe1"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/q3_tail.py",
+      "relative": "source/coupled-tail-escape/q3_tail.py",
+      "sha256": "8fac76761684d17231ae4d766b7d9464a4ff5675e99038dfbd839bb8cf0d1082"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-independent-review/MANIFEST.json",
+      "relative": "source/coupled-tail-independent-review/MANIFEST.json",
+      "sha256": "db91e3ac03e43cb848b7ca6fb6ca314755573142227e330f2f0293011501f8dd"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-independent-review/SOURCE-PINS.json",
+      "relative": "source/coupled-tail-independent-review/SOURCE-PINS.json",
+      "sha256": "e86465b4fb10b3597cc6ec59ce8f24e828301683a5e7f8e1b51d646ae83dabc8"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-independent-review/audit_tail.py",
+      "relative": "source/coupled-tail-independent-review/audit_tail.py",
+      "sha256": "18f72f8e4e69595484304e1bacdb3d8f8bfc3f9bfad71aa1038adfb1808f955d"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/CUT58.json",
+      "relative": "source/early-cut58-planning/CUT58.json",
+      "sha256": "7553ec4f63272cd4b8efb16b2ec01183240be248e36a5dc45df32f9ebd24de58"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/HANDOFF.md",
+      "relative": "source/early-cut58-planning/HANDOFF.md",
+      "sha256": "31da85394448775676ded8fabbf6ce2c894da9eb0d0e799129e42710ca91d29c"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/MANIFEST.json",
+      "relative": "source/early-cut58-planning/MANIFEST.json",
+      "sha256": "2b5df5dc85e4799116177fac51ffc801357c243189b80563891cb534d1ce6a12"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/PROOF.md",
+      "relative": "source/early-cut58-planning/PROOF.md",
+      "sha256": "96372d990703d9775eda33d6b9d47c915f8c5b94b7c3d5c4fd82278fd0ecf2f3"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/VALIDATION.md",
+      "relative": "source/early-cut58-planning/VALIDATION.md",
+      "sha256": "2d33306afb4fcac0d7af57e492f89ccf33fea74d022d1788970cd116130080aa"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/cut58.py",
+      "relative": "source/early-cut58-planning/cut58.py",
+      "sha256": "0df94525632944ef6b4441159d481317fa7f4bcaf9c8b121d73ae06c545b0b02"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/fusion-audit/audit_fusions.py",
+      "relative": "source/fusion-audit/audit_fusions.py",
+      "sha256": "26c35f6d61ad6568da1c650a343b82caea174330ff8054c4cdab1fe183ad2173"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-native/joint_coefficient_gate.py",
+      "relative": "original/joint-native/joint_coefficient_gate.py",
+      "sha256": "43bc5229a10e7ed6af3d5bff057c61cfd6d37a222cc0a2eb2e88cbe0ac410d07"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-native/literal_inverse_binding.py",
+      "relative": "source/joint-native/literal_inverse_binding.py",
+      "sha256": "74bdbc9c35db4153e00ed15c8d9df27b63e1c50cd76fcd33f987f3f97d412d96"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-threshold-screen/MANIFEST.json",
+      "relative": "original/dependencies/e90d8163c1e5c9797534dd3ed7d6279d1095ff001d84b20dd5c33f8d70d68c6c-MANIFEST.json",
+      "sha256": "e90d8163c1e5c9797534dd3ed7d6279d1095ff001d84b20dd5c33f8d70d68c6c"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-threshold-screen/PROOF.md",
+      "relative": "original/dependencies/0eb564effb343e2a20af79445b6a319b719621965b2dc82a303bc6541e34d232-PROOF.md",
+      "sha256": "0eb564effb343e2a20af79445b6a319b719621965b2dc82a303bc6541e34d232"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json",
+      "relative": "source/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json",
+      "sha256": "30d3f569d91304856118796f0c586176d0ad961eff70b09c78fce7532392101f"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/MANIFEST.json",
+      "relative": "source/two-site-continuation/MANIFEST.json",
+      "sha256": "44f1e264b3087ab8fdb08b4cd6e27befefbba380852b0119321724b7bc41b5da"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-independent-audit/AUDIT.json",
+      "relative": "original/dependencies/e3333eb9c0166a2b66bec2599e8c837a5fd6459e560abcb190c792653bca2ed7-AUDIT.json",
+      "sha256": "e3333eb9c0166a2b66bec2599e8c837a5fd6459e560abcb190c792653bca2ed7"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-independent-audit/MANIFEST.json",
+      "relative": "original/dependencies/4e52d2469b648d73c2af67615116c994b434fdcca2cd0aa573debe98db87324e-MANIFEST.json",
+      "sha256": "4e52d2469b648d73c2af67615116c994b434fdcca2cd0aa573debe98db87324e"
+    },
+    {
+      "original": "/Users/ross/git/math/integer-mult-bounds/research/kernel92-frame-composition/vendor/pr531/vendor/clifford/clifford_exact.py",
+      "relative": "source/vendor/clifford_exact.py",
+      "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962"
+    }
+  ],
+  "executed_modules": {
+    "audit_cut58": "source/early-cut58-independent-review/audit_cut58.py",
+    "audit_fusions": "source/fusion-audit/audit_fusions.py",
+    "audit_tail": "source/coupled-tail-independent-review/audit_tail.py",
+    "audit_two_sites": "source/two-site-independent-audit/audit_two_sites.py",
+    "clifford_exact": "source/vendor/clifford_exact.py",
+    "conjugated_reflection": "source/native-frames/conjugated_reflection.py",
+    "cut58": "source/early-cut58-planning/cut58.py",
+    "even_parity_source": "source/native-frames/even_parity_source.py",
+    "free_ops": "source/caller/free_ops.py",
+    "full_stabilizer_bound": "source/vendor/full_stabilizer_bound.py",
+    "joint_algebra": "source/caller-joint/joint_algebra.py",
+    "joint_coefficient_gate": "source/joint-native/joint_coefficient_gate.py",
+    "joint_prefix": "source/caller-joint/joint_prefix.py",
+    "lifted_algebra": "source/native-frames/lifted_algebra.py",
+    "literal_inverse_binding": "source/joint-native/literal_inverse_binding.py",
+    "local_block": "source/portable/local_block.py",
+    "native_model": "source/native-frames/native_model.py",
+    "nested_family": "source/caller/nested_family.py",
+    "nested_prefix": "source/caller/nested_prefix.py",
+    "orthogonal_source_normalizer": "source/native-frames/orthogonal_source_normalizer.py",
+    "pivot_plane_probe": "source/caller/pivot_plane_probe.py",
+    "q3_tail": "source/coupled-tail-escape/q3_tail.py",
+    "quadratic_charts": "source/root-chronology/quadratic_charts.py",
+    "validate_recipe_links": "source/caller-joint/validate_recipe_links.py"
+  },
+  "files": [
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/original/caller-joint/joint_algebra.py",
+      "path": "original/caller-joint/joint_algebra.py",
+      "sha256": "5782033e347c9b10ad47c01ed12a0a52ea07e901fa9e8f7aa9d3a2a928327232"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/original/caller-joint/validate_recipe_links.py",
+      "path": "original/caller-joint/validate_recipe_links.py",
+      "sha256": "7457b3672d5a73c584d2073b5d3312e6429fd3f433151f15f8f07da33aa4c59a"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/local_block.py",
+      "path": "original/coupled-tail-escape/local_block.py",
+      "sha256": "ac8abc744c616e60a221e8fadf1b590f2248f953bafcb2f61675d1c2541f7fe1"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-threshold-screen/PROOF.md",
+      "path": "original/dependencies/0eb564effb343e2a20af79445b6a319b719621965b2dc82a303bc6541e34d232-PROOF.md",
+      "sha256": "0eb564effb343e2a20af79445b6a319b719621965b2dc82a303bc6541e34d232"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-independent-audit/MANIFEST.json",
+      "path": "original/dependencies/4e52d2469b648d73c2af67615116c994b434fdcca2cd0aa573debe98db87324e-MANIFEST.json",
+      "sha256": "4e52d2469b648d73c2af67615116c994b434fdcca2cd0aa573debe98db87324e"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-independent-audit/AUDIT.json",
+      "path": "original/dependencies/e3333eb9c0166a2b66bec2599e8c837a5fd6459e560abcb190c792653bca2ed7-AUDIT.json",
+      "sha256": "e3333eb9c0166a2b66bec2599e8c837a5fd6459e560abcb190c792653bca2ed7"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-threshold-screen/MANIFEST.json",
+      "path": "original/dependencies/e90d8163c1e5c9797534dd3ed7d6279d1095ff001d84b20dd5c33f8d70d68c6c-MANIFEST.json",
+      "sha256": "e90d8163c1e5c9797534dd3ed7d6279d1095ff001d84b20dd5c33f8d70d68c6c"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/completed-gates-review/MANIFEST.json",
+      "path": "original/dependencies/ef3697eece91ee6d52ae3f5e88b95028091829d6961118052dff1e25df212ba3-MANIFEST.json",
+      "sha256": "ef3697eece91ee6d52ae3f5e88b95028091829d6961118052dff1e25df212ba3"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/original/joint-native/joint_coefficient_gate.py",
+      "path": "original/joint-native/joint_coefficient_gate.py",
+      "sha256": "43bc5229a10e7ed6af3d5bff057c61cfd6d37a222cc0a2eb2e88cbe0ac410d07"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/original/native-frames/native_model.py",
+      "path": "original/native-frames/native_model.py",
+      "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/caller-joint/joint_algebra.py",
+      "path": "source/caller-joint/joint_algebra.py",
+      "sha256": "6fe4de627845a36e2e08723e705daa86959846fe4ea577e94fca233829d7d5c9"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/caller-joint/joint_prefix.py",
+      "path": "source/caller-joint/joint_prefix.py",
+      "sha256": "a4dcaa1ad05ef8dbba60ddd47b3ad44a3095ebb5fd31f6adfb935a7b1c46a2c7"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/caller-joint/validate_recipe_links.py",
+      "path": "source/caller-joint/validate_recipe_links.py",
+      "sha256": "30b9ad84008ff6df9597bb95964174745a6cd978b9bfde968e18b8db396416b8"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/caller/free_ops.py",
+      "path": "source/caller/free_ops.py",
+      "sha256": "5806fe91b9fda162d5986b12e085b14eb3df9a4703f749f61c1f10363138ca77"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/caller/nested_family.py",
+      "path": "source/caller/nested_family.py",
+      "sha256": "88f425d12baf8a4f849cccd24605f21680eb8ce8d199054db4b4e7734eca72b6"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/caller/nested_prefix.py",
+      "path": "source/caller/nested_prefix.py",
+      "sha256": "9ec10cb0243c0c829475ad7290f4953cdff27cb0f90f70b687c4bbee98af676b"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/caller/pivot_plane_probe.py",
+      "path": "source/caller/pivot_plane_probe.py",
+      "sha256": "fcd0a4a0a301c4fddfb8b132894e8b5b751b08cacdb0e5ed41e80b0d4903d499"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/completed-gates-review/audit_gates.py",
+      "path": "source/completed-gates-review/audit_gates.py",
+      "sha256": "051ba51e02e9f143b8a8bea0b91d69e7e1e32edf0f98d2d40db290f02043d460"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/ALL-Q-TAIL-LEMMA.md",
+      "path": "source/coupled-tail-escape/ALL-Q-TAIL-LEMMA.md",
+      "sha256": "f3b8c42c0fe7d5c5a542e38fe0b3d14601c170959e18a45b60f26128703560b2"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/HANDOFF.md",
+      "path": "source/coupled-tail-escape/HANDOFF.md",
+      "sha256": "25aa7a2e7408cca9402e34ba809bb8a487c79a4d012d5b8c4700dc81502741aa"
+    },
+    {
+      "kind": "deterministic lossless JSON transport",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/LOCAL-BLOCK.json",
+      "path": "source/coupled-tail-escape/LOCAL-BLOCK.json.gz",
+      "sha256": "e72ff85b051ebfe909e24cc95b6e79225edc3cd5b80916a5e09c842b5271a8e3"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/MANIFEST.json",
+      "path": "source/coupled-tail-escape/MANIFEST.json",
+      "sha256": "f3c5b9829e61866988b0843e5bcb637fb0ae37434e2f8e6ef74bdeef079e126e"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/PROOF.md",
+      "path": "source/coupled-tail-escape/PROOF.md",
+      "sha256": "5b4300fb15364dbdb17974d6d0bb7d387a189ff814fd0293057ea2a47ac58587"
+    },
+    {
+      "kind": "deterministic lossless JSON transport",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/Q3-LOCAL-BLOCK.json",
+      "path": "source/coupled-tail-escape/Q3-LOCAL-BLOCK.json.gz",
+      "sha256": "a33c81c3d083aebd05c0bdbc8d6ce50a027f3af5a237b1aa002c3786435a0913"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/VALIDATION.json",
+      "path": "source/coupled-tail-escape/VALIDATION.json",
+      "sha256": "e1b6ccf248fa65973645d41b34a7119f07df5d70e73dcfb36cf335ff2ec45e31"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/local_block.py",
+      "path": "source/coupled-tail-escape/local_block.py",
+      "sha256": "ac8abc744c616e60a221e8fadf1b590f2248f953bafcb2f61675d1c2541f7fe1"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/q3_tail.py",
+      "path": "source/coupled-tail-escape/q3_tail.py",
+      "sha256": "8fac76761684d17231ae4d766b7d9464a4ff5675e99038dfbd839bb8cf0d1082"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-independent-review/AUDIT.json",
+      "path": "source/coupled-tail-independent-review/AUDIT.json",
+      "sha256": "c1b850bfdab5328a1ecaabf36400b4d49830131cb8eb6e0ed5c74ff5d975efe0"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-independent-review/HANDOFF.md",
+      "path": "source/coupled-tail-independent-review/HANDOFF.md",
+      "sha256": "fec073544043700346cd4601d646e2b68a07eeac6ee7d053f416e0a69527b9ba"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-independent-review/MANIFEST.json",
+      "path": "source/coupled-tail-independent-review/MANIFEST.json",
+      "sha256": "db91e3ac03e43cb848b7ca6fb6ca314755573142227e330f2f0293011501f8dd"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-independent-review/REVIEW.md",
+      "path": "source/coupled-tail-independent-review/REVIEW.md",
+      "sha256": "dc3d42299d482d71bb06cb0d668ae6bfbc7bf3c6ba1068f840e706858b67123a"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-independent-review/SOURCE-PINS.json",
+      "path": "source/coupled-tail-independent-review/SOURCE-PINS.json",
+      "sha256": "e86465b4fb10b3597cc6ec59ce8f24e828301683a5e7f8e1b51d646ae83dabc8"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-independent-review/VALIDATION.json",
+      "path": "source/coupled-tail-independent-review/VALIDATION.json",
+      "sha256": "3b56a7d435fb88054ef73c4a1f26701cda45f7129e25d745323cceb35480467b"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-independent-review/audit_tail.py",
+      "path": "source/coupled-tail-independent-review/audit_tail.py",
+      "sha256": "18f72f8e4e69595484304e1bacdb3d8f8bfc3f9bfad71aa1038adfb1808f955d"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-independent-review/validate_review.py",
+      "path": "source/coupled-tail-independent-review/validate_review.py",
+      "sha256": "51c079b41571d73af9548fb23502117112d1ac3ac8f64a7149c6d997c1e6033f"
+    },
+    {
+      "kind": "unchanged frozen planning appendix",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-independent-review/AUDIT.json",
+      "path": "source/early-cut58-independent-review/AUDIT.json",
+      "sha256": "8167d024e84d6b3b3763a20fd8a2730ea572f6c331ad71b8c3cfeb4acc6984b5"
+    },
+    {
+      "kind": "unchanged frozen planning appendix",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-independent-review/HANDOFF.md",
+      "path": "source/early-cut58-independent-review/HANDOFF.md",
+      "sha256": "ca6ad58a72f80d86705e6f18ad57a5c7e1aa8e66c761bfbe4a78b367b7ea570a"
+    },
+    {
+      "kind": "unchanged frozen planning appendix",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-independent-review/MANIFEST.json",
+      "path": "source/early-cut58-independent-review/MANIFEST.json",
+      "sha256": "5b2033b3223e4a3b5c580aac854ae9654d392dc86edfe8743f2f76fb26487e18"
+    },
+    {
+      "kind": "unchanged frozen planning appendix",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-independent-review/REVIEW.md",
+      "path": "source/early-cut58-independent-review/REVIEW.md",
+      "sha256": "2890cbaa950c9bed28dfb7f375e9fe3d0c300a81eb337be43bb5488f3d822b55"
+    },
+    {
+      "kind": "unchanged frozen planning appendix",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-independent-review/SOURCE-PINS.json",
+      "path": "source/early-cut58-independent-review/SOURCE-PINS.json",
+      "sha256": "d5187158f6d6016e39b338b5ac4df616275bbf264672d5611f9b0ced76d670d3"
+    },
+    {
+      "kind": "unchanged frozen planning appendix",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-independent-review/VALIDATION.json",
+      "path": "source/early-cut58-independent-review/VALIDATION.json",
+      "sha256": "68730984544922ed03b17377219f355a7f4fb3361ab649c64ec07542996d86d5"
+    },
+    {
+      "kind": "unchanged frozen planning appendix",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-independent-review/audit_cut58.py",
+      "path": "source/early-cut58-independent-review/audit_cut58.py",
+      "sha256": "dded71129aa71f5133e3410df76c088ff478312d903b1baa817aad79541b32b6"
+    },
+    {
+      "kind": "unchanged frozen planning appendix",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-independent-review/validate_review.py",
+      "path": "source/early-cut58-independent-review/validate_review.py",
+      "sha256": "36dbef6426fc9a60eb9f22eb9367feb6fdbf38cd463aef04079c4877026d121e"
+    },
+    {
+      "kind": "unchanged frozen planning appendix",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/CUT58.json",
+      "path": "source/early-cut58-planning/CUT58.json.gz",
+      "sha256": "52011fdf490b90332a1651e66aa62741fe11da88a76a433fddc8ca413c68c800"
+    },
+    {
+      "kind": "unchanged frozen planning appendix",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/HANDOFF.md",
+      "path": "source/early-cut58-planning/HANDOFF.md",
+      "sha256": "31da85394448775676ded8fabbf6ce2c894da9eb0d0e799129e42710ca91d29c"
+    },
+    {
+      "kind": "unchanged frozen planning appendix",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/MANIFEST.json",
+      "path": "source/early-cut58-planning/MANIFEST.json",
+      "sha256": "2b5df5dc85e4799116177fac51ffc801357c243189b80563891cb534d1ce6a12"
+    },
+    {
+      "kind": "unchanged frozen planning appendix",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/PROOF.md",
+      "path": "source/early-cut58-planning/PROOF.md",
+      "sha256": "96372d990703d9775eda33d6b9d47c915f8c5b94b7c3d5c4fd82278fd0ecf2f3"
+    },
+    {
+      "kind": "unchanged frozen planning appendix",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/VALIDATION.md",
+      "path": "source/early-cut58-planning/VALIDATION.md",
+      "sha256": "2d33306afb4fcac0d7af57e492f89ccf33fea74d022d1788970cd116130080aa"
+    },
+    {
+      "kind": "unchanged frozen planning appendix",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/cut58.py",
+      "path": "source/early-cut58-planning/cut58.py",
+      "sha256": "0df94525632944ef6b4441159d481317fa7f4bcaf9c8b121d73ae06c545b0b02"
+    },
+    {
+      "kind": "deterministic lossless JSON transport",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/folded-fusion/SIMPLIFIED-FUSIONS.json",
+      "path": "source/folded-fusion/SIMPLIFIED-FUSIONS.json.gz",
+      "sha256": "7780976645e1aa1e4858b4c109b440faed0327a76cfa51fe58d049f6e5a07276"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/fusion-audit/audit_fusions.py",
+      "path": "source/fusion-audit/audit_fusions.py",
+      "sha256": "26c35f6d61ad6568da1c650a343b82caea174330ff8054c4cdab1fe183ad2173"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/joint-native/joint_coefficient_gate.py",
+      "path": "source/joint-native/joint_coefficient_gate.py",
+      "sha256": "e6ff6f323edd360efa3776a381a97cb7202b79aa198e804c9165310e03e83f45"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/joint-native/literal_inverse_binding.py",
+      "path": "source/joint-native/literal_inverse_binding.py",
+      "sha256": "74bdbc9c35db4153e00ed15c8d9df27b63e1c50cd76fcd33f987f3f97d412d96"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/native-frames/EVEN-PARITY-SOURCE.json",
+      "path": "source/native-frames/EVEN-PARITY-SOURCE.json",
+      "sha256": "dbeea9cb1abe6fff72cc98e98d9f70eed578d5094cf5f310ed7c500e26af3f3c"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/native-frames/conjugated_reflection.py",
+      "path": "source/native-frames/conjugated_reflection.py",
+      "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/native-frames/even_parity_source.py",
+      "path": "source/native-frames/even_parity_source.py",
+      "sha256": "961f136e4bc1b5da930bdd4ba9bbb594892b9e27f7ab44749d747d4fe16b4cb3"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/native-frames/lifted_algebra.py",
+      "path": "source/native-frames/lifted_algebra.py",
+      "sha256": "3b9a58a2048a762ab520ac7fdbb28cbfeb7b30345aaeb777d8dabdd9fb1034d9"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/native-frames/native_model.py",
+      "path": "source/native-frames/native_model.py",
+      "sha256": "b4291b2868f91f6e77058e58e936b2efe965a9d9ae58095745fa2dad8c1d5c68"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/native-frames/orthogonal_source_normalizer.py",
+      "path": "source/native-frames/orthogonal_source_normalizer.py",
+      "sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa"
+    },
+    {
+      "kind": "only two source hash guards adapted",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/local_block.py",
+      "path": "source/portable/local_block.py",
+      "sha256": "1dbbe94d0652e46cc29ccec1e106468f9fbb5b739f4689bb073a1e35c0fabf1c"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/root-chronology/quadratic_charts.py",
+      "path": "source/root-chronology/quadratic_charts.py",
+      "sha256": "de2a36f6a6b567360c90477b58da44e2f1b618fd006d058ab1ea04e983952c3f"
+    },
+    {
+      "kind": "deterministic lossless JSON transport",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json",
+      "path": "source/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json.gz",
+      "sha256": "ee1b8e64355381f4347c28b6a741e25b00bec83182357896cd803eb3a525aaf0"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/MANIFEST.json",
+      "path": "source/two-site-continuation/MANIFEST.json",
+      "sha256": "44f1e264b3087ab8fdb08b4cd6e27befefbba380852b0119321724b7bc41b5da"
+    },
+    {
+      "kind": "unchanged frozen source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/two-site-independent-audit/audit_two_sites.py",
+      "path": "source/two-site-independent-audit/audit_two_sites.py",
+      "sha256": "a20cb5bf3577e508e112abe76bf9177a1c3ec7dc397ab74eef37c05de23eb9c9"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/vendor/clifford_exact.py",
+      "path": "source/vendor/clifford_exact.py",
+      "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/vendor/credits/NOTICE.md",
+      "path": "source/vendor/credits/NOTICE.md",
+      "sha256": "538e7634331d7e24791be08dedd737bf458f35a3b46ce651e6aacd905f3dee6e"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/vendor/credits/PR533-NOTICE.md",
+      "path": "source/vendor/credits/PR533-NOTICE.md",
+      "sha256": "2c1961a07b0976e29e8e6f4da14a9aaeb2f961a3a78d842488065aa433fa2f98"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/vendor/credits/vendor/pr531/NOTICE.md",
+      "path": "source/vendor/credits/vendor/pr531/NOTICE.md",
+      "sha256": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/vendor/credits/vendor/pr531/SOURCES.json",
+      "path": "source/vendor/credits/vendor/pr531/SOURCES.json",
+      "sha256": "9e8182e6e659f4671fe0873e324b622cc871df7344157093df40476c8687be5f"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/vendor/credits/vendor/pr531/inputs/PR523-ANCESTRY.json",
+      "path": "source/vendor/credits/vendor/pr531/inputs/PR523-ANCESTRY.json",
+      "sha256": "0bfce40d86c849f18e8872ee9e8462b0a69a34ed04e01e942a6614645f686f4b"
+    },
+    {
+      "kind": "unchanged source",
+      "origin": "/Users/ross/git/math/worktrees/caller-publication-two-site-20261019T1133Z/research/two-site-caller-fusion/source/vendor/full_stabilizer_bound.py",
+      "path": "source/vendor/full_stabilizer_bound.py",
+      "sha256": "f073a00ad4831616e873eb110fd33ad7226010a7c2f6cfa6a6b63167bf58ef75"
+    }
+  ],
+  "freezes": [
+    {
+      "complete": true,
+      "file_map": {
+        "ALL-Q-TAIL-LEMMA.md": "source/coupled-tail-escape/ALL-Q-TAIL-LEMMA.md",
+        "HANDOFF.md": "source/coupled-tail-escape/HANDOFF.md",
+        "LOCAL-BLOCK.json": "source/coupled-tail-escape/LOCAL-BLOCK.json",
+        "PROOF.md": "source/coupled-tail-escape/PROOF.md",
+        "Q3-LOCAL-BLOCK.json": "source/coupled-tail-escape/Q3-LOCAL-BLOCK.json",
+        "VALIDATION.json": "source/coupled-tail-escape/VALIDATION.json",
+        "local_block.py": "original/coupled-tail-escape/local_block.py",
+        "q3_tail.py": "source/coupled-tail-escape/q3_tail.py"
+      },
+      "manifest": "source/coupled-tail-escape/MANIFEST.json",
+      "sha256": "f3c5b9829e61866988b0843e5bcb637fb0ae37434e2f8e6ef74bdeef079e126e"
+    },
+    {
+      "complete": true,
+      "file_map": {
+        "AUDIT.json": "source/coupled-tail-independent-review/AUDIT.json",
+        "HANDOFF.md": "source/coupled-tail-independent-review/HANDOFF.md",
+        "REVIEW.md": "source/coupled-tail-independent-review/REVIEW.md",
+        "SOURCE-PINS.json": "source/coupled-tail-independent-review/SOURCE-PINS.json",
+        "VALIDATION.json": "source/coupled-tail-independent-review/VALIDATION.json",
+        "audit_tail.py": "source/coupled-tail-independent-review/audit_tail.py",
+        "validate_review.py": "source/coupled-tail-independent-review/validate_review.py"
+      },
+      "manifest": "source/coupled-tail-independent-review/MANIFEST.json",
+      "sha256": "db91e3ac03e43cb848b7ca6fb6ca314755573142227e330f2f0293011501f8dd"
+    },
+    {
+      "complete": true,
+      "file_map": {
+        "CUT58.json": "source/early-cut58-planning/CUT58.json",
+        "HANDOFF.md": "source/early-cut58-planning/HANDOFF.md",
+        "PROOF.md": "source/early-cut58-planning/PROOF.md",
+        "VALIDATION.md": "source/early-cut58-planning/VALIDATION.md",
+        "cut58.py": "source/early-cut58-planning/cut58.py"
+      },
+      "manifest": "source/early-cut58-planning/MANIFEST.json",
+      "sha256": "2b5df5dc85e4799116177fac51ffc801357c243189b80563891cb534d1ce6a12"
+    },
+    {
+      "complete": true,
+      "file_map": {
+        "AUDIT.json": "source/early-cut58-independent-review/AUDIT.json",
+        "HANDOFF.md": "source/early-cut58-independent-review/HANDOFF.md",
+        "REVIEW.md": "source/early-cut58-independent-review/REVIEW.md",
+        "SOURCE-PINS.json": "source/early-cut58-independent-review/SOURCE-PINS.json",
+        "VALIDATION.json": "source/early-cut58-independent-review/VALIDATION.json",
+        "audit_cut58.py": "source/early-cut58-independent-review/audit_cut58.py",
+        "validate_review.py": "source/early-cut58-independent-review/validate_review.py"
+      },
+      "manifest": "source/early-cut58-independent-review/MANIFEST.json",
+      "sha256": "5b2033b3223e4a3b5c580aac854ae9654d392dc86edfe8743f2f76fb26487e18"
+    }
+  ],
+  "independent_external_sources": [
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/stabilizer-escape/full_stabilizer_bound.py",
+      "relative": "source/vendor/full_stabilizer_bound.py",
+      "sha256": "f073a00ad4831616e873eb110fd33ad7226010a7c2f6cfa6a6b63167bf58ef75"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/free_ops.py",
+      "relative": "source/caller/free_ops.py",
+      "sha256": "5806fe91b9fda162d5986b12e085b14eb3df9a4703f749f61c1f10363138ca77"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_family.py",
+      "relative": "source/caller/nested_family.py",
+      "sha256": "88f425d12baf8a4f849cccd24605f21680eb8ce8d199054db4b4e7734eca72b6"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_prefix.py",
+      "relative": "source/caller/nested_prefix.py",
+      "sha256": "9ec10cb0243c0c829475ad7290f4953cdff27cb0f90f70b687c4bbee98af676b"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/pivot_plane_probe.py",
+      "relative": "source/caller/pivot_plane_probe.py",
+      "sha256": "fcd0a4a0a301c4fddfb8b132894e8b5b751b08cacdb0e5ed41e80b0d4903d499"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py",
+      "relative": "source/native-frames/conjugated_reflection.py",
+      "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/even_parity_source.py",
+      "relative": "source/native-frames/even_parity_source.py",
+      "sha256": "961f136e4bc1b5da930bdd4ba9bbb594892b9e27f7ab44749d747d4fe16b4cb3"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/lifted_algebra.py",
+      "relative": "source/native-frames/lifted_algebra.py",
+      "sha256": "3b9a58a2048a762ab520ac7fdbb28cbfeb7b30345aaeb777d8dabdd9fb1034d9"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py",
+      "relative": "original/native-frames/native_model.py",
+      "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/orthogonal_source_normalizer.py",
+      "relative": "source/native-frames/orthogonal_source_normalizer.py",
+      "sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-chronology/quadratic_charts.py",
+      "relative": "source/root-chronology/quadratic_charts.py",
+      "sha256": "de2a36f6a6b567360c90477b58da44e2f1b618fd006d058ab1ea04e983952c3f"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/caller-joint/joint_algebra.py",
+      "relative": "original/caller-joint/joint_algebra.py",
+      "sha256": "5782033e347c9b10ad47c01ed12a0a52ea07e901fa9e8f7aa9d3a2a928327232"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/completed-gates-review/MANIFEST.json",
+      "relative": "original/dependencies/ef3697eece91ee6d52ae3f5e88b95028091829d6961118052dff1e25df212ba3-MANIFEST.json",
+      "sha256": "ef3697eece91ee6d52ae3f5e88b95028091829d6961118052dff1e25df212ba3"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/completed-gates-review/audit_gates.py",
+      "relative": "source/completed-gates-review/audit_gates.py",
+      "sha256": "051ba51e02e9f143b8a8bea0b91d69e7e1e32edf0f98d2d40db290f02043d460"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/ALL-Q-TAIL-LEMMA.md",
+      "relative": "source/coupled-tail-escape/ALL-Q-TAIL-LEMMA.md",
+      "sha256": "f3b8c42c0fe7d5c5a542e38fe0b3d14601c170959e18a45b60f26128703560b2"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/HANDOFF.md",
+      "relative": "source/coupled-tail-escape/HANDOFF.md",
+      "sha256": "25aa7a2e7408cca9402e34ba809bb8a487c79a4d012d5b8c4700dc81502741aa"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/LOCAL-BLOCK.json",
+      "relative": "source/coupled-tail-escape/LOCAL-BLOCK.json",
+      "sha256": "aad2ee156a1f1e028b4e0329b4af1c38285f0be90c27da720d4bb71885c29294"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/MANIFEST.json",
+      "relative": "source/coupled-tail-escape/MANIFEST.json",
+      "sha256": "f3c5b9829e61866988b0843e5bcb637fb0ae37434e2f8e6ef74bdeef079e126e"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/PROOF.md",
+      "relative": "source/coupled-tail-escape/PROOF.md",
+      "sha256": "5b4300fb15364dbdb17974d6d0bb7d387a189ff814fd0293057ea2a47ac58587"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/Q3-LOCAL-BLOCK.json",
+      "relative": "source/coupled-tail-escape/Q3-LOCAL-BLOCK.json",
+      "sha256": "3ad4d1bb498cd67588af0c0558c32b441b35dac56b9f3bb7001ae317fadc28fa"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/VALIDATION.json",
+      "relative": "source/coupled-tail-escape/VALIDATION.json",
+      "sha256": "e1b6ccf248fa65973645d41b34a7119f07df5d70e73dcfb36cf335ff2ec45e31"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/local_block.py",
+      "relative": "original/coupled-tail-escape/local_block.py",
+      "sha256": "ac8abc744c616e60a221e8fadf1b590f2248f953bafcb2f61675d1c2541f7fe1"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/q3_tail.py",
+      "relative": "source/coupled-tail-escape/q3_tail.py",
+      "sha256": "8fac76761684d17231ae4d766b7d9464a4ff5675e99038dfbd839bb8cf0d1082"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/fusion-audit/audit_fusions.py",
+      "relative": "source/fusion-audit/audit_fusions.py",
+      "sha256": "26c35f6d61ad6568da1c650a343b82caea174330ff8054c4cdab1fe183ad2173"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-native/joint_coefficient_gate.py",
+      "relative": "original/joint-native/joint_coefficient_gate.py",
+      "sha256": "43bc5229a10e7ed6af3d5bff057c61cfd6d37a222cc0a2eb2e88cbe0ac410d07"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-native/literal_inverse_binding.py",
+      "relative": "source/joint-native/literal_inverse_binding.py",
+      "sha256": "74bdbc9c35db4153e00ed15c8d9df27b63e1c50cd76fcd33f987f3f97d412d96"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-threshold-screen/MANIFEST.json",
+      "relative": "original/dependencies/e90d8163c1e5c9797534dd3ed7d6279d1095ff001d84b20dd5c33f8d70d68c6c-MANIFEST.json",
+      "sha256": "e90d8163c1e5c9797534dd3ed7d6279d1095ff001d84b20dd5c33f8d70d68c6c"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-threshold-screen/PROOF.md",
+      "relative": "original/dependencies/0eb564effb343e2a20af79445b6a319b719621965b2dc82a303bc6541e34d232-PROOF.md",
+      "sha256": "0eb564effb343e2a20af79445b6a319b719621965b2dc82a303bc6541e34d232"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json",
+      "relative": "source/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json",
+      "sha256": "30d3f569d91304856118796f0c586176d0ad961eff70b09c78fce7532392101f"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/MANIFEST.json",
+      "relative": "source/two-site-continuation/MANIFEST.json",
+      "sha256": "44f1e264b3087ab8fdb08b4cd6e27befefbba380852b0119321724b7bc41b5da"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-independent-audit/AUDIT.json",
+      "relative": "original/dependencies/e3333eb9c0166a2b66bec2599e8c837a5fd6459e560abcb190c792653bca2ed7-AUDIT.json",
+      "sha256": "e3333eb9c0166a2b66bec2599e8c837a5fd6459e560abcb190c792653bca2ed7"
+    },
+    {
+      "original": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-independent-audit/MANIFEST.json",
+      "relative": "original/dependencies/4e52d2469b648d73c2af67615116c994b434fdcca2cd0aa573debe98db87324e-MANIFEST.json",
+      "sha256": "4e52d2469b648d73c2af67615116c994b434fdcca2cd0aa573debe98db87324e"
+    },
+    {
+      "original": "/Users/ross/git/math/integer-mult-bounds/research/kernel92-frame-composition/vendor/pr531/vendor/clifford/clifford_exact.py",
+      "relative": "source/vendor/clifford_exact.py",
+      "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962"
+    }
+  ],
+  "original_read_aliases": {},
+  "path_adaptations": [
+    {
+      "adapted_sha256": "6fe4de627845a36e2e08723e705daa86959846fe4ea577e94fca233829d7d5c9",
+      "change": "Only OLD source location and the native_model source hash are rebound to the retained path-adapted implementation; original versions and hashes remain retained. No arithmetic, assertion or coverage change.",
+      "function_source_sha256": {
+        "Word": "088ab7fad576e0516a1134852fd01e9ad7dcd0892b33d43e0b9c62157fea1af1",
+        "add": "fe99892249dc4ee8f13415f9ac728c9c048aa18bd2ad52a8c7a3e2ada7a3b2b7",
+        "adjoint": "b3fc9172cdeeaa3e02435336c3a2ea1aab0ba5580a5e72535338a76f4dc35af2",
+        "cproduct": "e7d0bab6c2890b1674dc5de2ea474127fea0ca487b912db1bae6343a667d6455",
+        "eye": "1dae1553144b119de3f4a3e862c0efb44ff8cd89c6bfbe34d94b3dde6b67e64f",
+        "j_operator": "90a8dd0450958deac8b6fabe8955bc0d7da6a3703cc7d445fa225e4357ec65f7",
+        "mm": "784b432f24287a6a04beb0fa7a6a238fa52fc392f8383979ef1658d19cf33a38",
+        "mono": "206074eb3dd1909175018ea7ca228fc6b285762353784c5d604e07bebb036456",
+        "n_pair": "a658d0dc010cc429e69e557c0a7158701570730688ad5dd5deca2eb10a653c0b",
+        "need": "8dafe5ffff3250938d1e92c5d908bb777702c8e47f59a9926fe5eb00dc669e9c",
+        "normalize": "4db8cfdb57236c7dc09c50880500ab83941082ce2007e4e78dc57c3e4bc94453",
+        "plane_swap": "9fbaaddb41b5665b83d986b94e13277b32239a750660770b47927af0ef32c4c1",
+        "prefix": "988e8a42f0807f8eb3be00fb6fdaba1f3a185b6a84f07e68e10b7e27d5f37b39",
+        "product": "ab4ff88a16f59815a2dde841bd2aa3d0b2cd71dc374b3f68250d8ac2dade5d41",
+        "rotate": "caee022608323985f3d2bc4c2fa349f70f27620000ce8123cc3a6945501253a6",
+        "scale": "a17e0daf2ef4b5bce136caba504a73c58553c76fadbd1a3f2f5710b189d26adc",
+        "serial": "790d482bfd00220fdbb5d1de34eb56f4158dc85c5105580edb927c0901e9e767",
+        "sm": "a618cb533f67ffb93468a7064d002be6ff0590af7b7ba8c55bdf4d6feccb83bf",
+        "summ": "4de74a52410a77b72d6495d6706b176442ec04128fcc14c52afa5e2b2980383a"
+      },
+      "original": "original/caller-joint/joint_algebra.py",
+      "original_sha256": "5782033e347c9b10ad47c01ed12a0a52ea07e901fa9e8f7aa9d3a2a928327232",
+      "path": "source/caller-joint/joint_algebra.py",
+      "via": "PR4080 exact7b4594222a4b3b97404f9ef1d0b03b71ae2c6768"
+    },
+    {
+      "adapted_sha256": "b4291b2868f91f6e77058e58e936b2efe965a9d9ae58095745fa2dad8c1d5c68",
+      "change": "Three source locations only: package-local BASE and immutable CE/BOUND locations. No arithmetic, assertions, constants or coverage changed.",
+      "function_source_sha256": {
+        "Model": "1d54ef2a157e5b5e0d1f2f0880af56b2d85881b8f6c4e2e9d0231635bab4c8a4",
+        "conjugated_pauli": "0d19561c7bc2ad3c519b672a361ff31239083d90fe4dc2fd6475fb48e4eb044a",
+        "load": "2a90d5aa0e6b19126e7693d24c353a16243b8671ac11936eadf7b18aa73e0af1",
+        "mul": "960c407e8509704669cfe33eb41f8dadbd00edd92d975e199ec5d3118476114b",
+        "need": "a8ebc8f5f3a23b40b0c85a9adaa7e6f5bb29fcb122a2f824dc2f25deed384a8a",
+        "pauli": "b0f355041fcaa099b7a9f3925edb18d095316dc55ac46b02bfba34244c3c6886",
+        "phase": "1409aec46cb93fcc1da21c9ad35f3c2bc7cd187ba0217ac091f426a3def3109e",
+        "same": "c19e00a4fe81b356adbaf964f41f2b9ba7afdcb3a61d3f88487564ff68ff113f",
+        "symplectic_defect_rank": "cdfaafd5c881fbaeb71531959e7fe41a6a7db7390f3134185b6ae8966356be14"
+      },
+      "original": "original/native-frames/native_model.py",
+      "original_sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3",
+      "path": "source/native-frames/native_model.py",
+      "via": "PR4080 exact7b4594222a4b3b97404f9ef1d0b03b71ae2c6768"
+    },
+    {
+      "adapted_sha256": "30b9ad84008ff6df9597bb95964174745a6cd978b9bfde968e18b8db396416b8",
+      "change": "Exactly four consumed compile/embedding functions copied verbatim. Only unrelated imports and unused cold-producer functions are omitted.",
+      "function_source_sha256": {
+        "compile_literal": "45e28e5ab777566a7c6625860726aa6c14bab725f0494da5545625bb1ac87609",
+        "compile_monomial": "9d90ab6cd3555ce7ea816a18adc40f7dac8c31298866c0b7d0cf804ad3c5f0fa",
+        "compile_recipe": "5ba8984cc42680054a8cb5f4175fb314d2fc097a88665fe4073c32398f11fb7f",
+        "embedding_circuit": "17c7fa61c90b82413045040760b425c2c18662ff75b825a22c4a52e7ef5cda03"
+      },
+      "original": "original/caller-joint/validate_recipe_links.py",
+      "original_sha256": "7457b3672d5a73c584d2073b5d3312e6429fd3f433151f15f8f07da33aa4c59a",
+      "path": "source/caller-joint/validate_recipe_links.py",
+      "via": "PR4080 exact7b4594222a4b3b97404f9ef1d0b03b71ae2c6768"
+    },
+    {
+      "change": "Only joint_algebra and pure validate_recipe_links source digest guards updated to exact executed portable bytes; no function, domain or assertion change.",
+      "function_source_sha256": {
+        "extra": "0a581e6484b48e7beed23dc43dad9c275863b80e5256dd72136156cfdb3dfa06",
+        "main": "847c0c0199a560800e15a5034ce581a60fd5b4d84cf87fd93a922aea4a68b4c3",
+        "produce": "76eabc3903c72d5ed75bc7f28199be3391976adcdf1c12fd204ed95cd1cdd065"
+      },
+      "original": "original/coupled-tail-escape/local_block.py",
+      "path": "source/portable/local_block.py"
+    },
+    {
+      "adapted_sha256": "e6ff6f323edd360efa3776a381a97cb7202b79aa198e804c9165310e03e83f45",
+      "change": "Only source-directory resolution and expected hashes of the already documented path-adapted sources change. Original mathematical source and original hashes remain retained.",
+      "function_source_sha256": {
+        "all_f_phase": "1d1630afc91645fdc0de46cb68d92801342872fa099f1d2f7c8bd03664de7172",
+        "expected_gamma": "ed04d9fa72b60b844f0e9a1c569518a3786ff9a28325c5350af8de1c8131b0e8",
+        "formal_core": "8fd8fbad1ce8875985ae07b95914135db1caa1175b4837b0ba750da22110ebfd",
+        "left_gamma": "db12cd2faf9e5ed3140c70df6db5853c37141ad2affc9913d40244f8794e22b3",
+        "operators": "8a80f5fcaf0dac85bd95a63a82b9ef9de3f3c38a4203ea01edda7a8de771977b",
+        "run": "3cef3955f3dcdb4c9d1c3c2f894207d0687e645a4e7a927ce2a25c99fd784b6d"
+      },
+      "original": "original/joint-native/joint_coefficient_gate.py",
+      "original_sha256": "43bc5229a10e7ed6af3d5bff057c61cfd6d37a222cc0a2eb2e88cbe0ac410d07",
+      "path": "source/joint-native/joint_coefficient_gate.py",
+      "via": "PR4080 exact7b4594222a4b3b97404f9ef1d0b03b71ae2c6768"
+    }
+  ],
+  "schema_version": 1,
+  "scope": "Exact arbitrary-current-input q2/q3 fixed late-tail support floors and independently reviewed conditional all-q tail lemma. No new caller or kappa. Conditional actual full-scan budget and equal-volume proper-child limiting moment corollary; no numerical planning claim. A separately reviewed exact q2 cut58 next-interface appendix, prefix54/local22 and rank-neutral rewrite22, targetlocal16 OPEN; no native saving or new selected schema."
+}
diff --git a/research/coupled-tail-support-floor/FULL-SCAN-COROLLARY.md b/research/coupled-tail-support-floor/FULL-SCAN-COROLLARY.md
new file mode 100644
index 0000000000..67ecd42a59
--- /dev/null
+++ b/research/coupled-tail-support-floor/FULL-SCAN-COROLLARY.md
@@ -0,0 +1,16 @@
+# Conditional full-scan and native-moment corollary
+
+The finite-f support statement is R_f+S_f≥nf, n=6/8. It is not a pointwise native-only floor. If S_f=o(f), it implies liminf R_f/f≥n. The unchanged prefix then prevents a fixed asymptotic native mass deficit below stock at this exact entrance.
+
+Assume every counted elementary binary ADD/COPY accumulation costs actual work at least c V_f for fixed c>0 at the source's whole-bank volume, and the complete available overhead is o(V_f f). Then T_scan≥c V_f S_f forces S_f=o(f). Conversely, a fixed native shortfall R_f≤(n−δ)f forces S_f≥δf and T_scan=Ω(V_f f). It cannot fit O(V_f f^λ P(f)) with λ<1 and P(f)=o(f^(1−λ)). An unrestricted precision/field/controller multiplier cannot be discarded. A formal full-field ADD list does not price a different partial-volume or fused-scan implementation.
+
+Under the additional equal-volume full-bank child normalization, put p=1−b∈(0,1), parent arity m f with m=2n, and include every native child. Subadditivity gives Σx_i^p≥(Σx_i)^p, so the limiting cleanup moment is at least (n/m)^p=(1/2)^p. The freshly recounted fixed prefixes have33 rank2f queries for q2 and60 for q3. Their limiting complete native moments satisfy
+
+    q2: 33(1/6)^p+(1/2)^p > 33/6+1/2 = 6,
+    q3: 60(1/8)^p+(1/2)^p > 60/8+1/2 = 8.
+
+Every displayed fraction lies in(0,1), so the strict inequalities follow for every0<p<1. This excludes a favorable native component moment at these fixed late cuts under the scan budget and normalization, before any additional paid work. Positive children must be proper admitted recursive children; unequal physical volumes need their actual weighted bridge. Neither the source/precision relation nor a complete multiplication recurrence is supplied by this corollary.
+
+This is the independently reviewed section4 bridge of the threshold note, retained as exact raw provenance at `original/dependencies/0eb564effb343e2a20af79445b6a319b719621965b2dc82a303bc6541e34d232-PROOF.md` (SHA256 `0eb564effb343e2a20af79445b6a319b719621965b2dc82a303bc6541e34d232`). The [independent review](source/coupled-tail-independent-review/REVIEW.md#full-scan-bridge) explicitly verifies this conditional argument. The threshold note's candidate, outer-source and numerical planning claims are not adopted or freshly replayed here. Its whole original bytes are authenticated solely to preserve the exact source section.
+
+Changing the earlier source cut, entrance/output gauges, target, native alphabet, bank volumes or scan primitive changes a premise. Arbitrary restored dirty fields within this exact local matrix remain allowed. No global caller lower bound, local optimum, physical controller, BIT or new κ is claimed.
diff --git a/research/coupled-tail-support-floor/LICENSE b/research/coupled-tail-support-floor/LICENSE
new file mode 100644
index 0000000000..261eeb9e9f
--- /dev/null
+++ b/research/coupled-tail-support-floor/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/coupled-tail-support-floor/README.md b/research/coupled-tail-support-floor/README.md
new file mode 100644
index 0000000000..b151bb966d
--- /dev/null
+++ b/research/coupled-tail-support-floor/README.md
@@ -0,0 +1,42 @@
+# Coupled late-tail cleanup support floor
+
+At the saved final-independent-a entrance, a new cleanup with arbitrary scalar/monomial coupling and any number of restored arbitrary dirty banks must satisfy **R_f+S_f≥6f** for q2 and **R_f+S_f≥8f** for q3. R_f sums full-bank native macroarities; S_f counts every binary ADD/accumulation scan. This broadens the local replacement class beyond the fixed ADD graphs and isolated existing-site edits of PR4080, while fixing the exact physical entrance/exit matrix.
+
+With S_f=o(f), including a count bounded independently of f, the unchanged prefixes66f/120f force asymptotic whole native mass at least stock72f/128f. The finite-f conclusion is R_f≥6f−S_f or8f−S_f. It is not a pointwise native-only floor when ADDs are present, a proof that the local optimum is6/8/10/12, or a bound for arbitrary earlier caller changes. No new κ is claimed.
+
+## Exact result and assumptions
+
+The complete admitted q2/q3 words have mass76/132. Their final-a cuts are event69/119, prefix mass66/120 and local mass10/12. All six/eight current incoming banks are arbitrary independent arrays because the preserved prefix is reversible. There are no clean, zero or correlated public-input promises. The suffix changes every required output, including bank2's isolation; it cannot drop that bank from the contract.
+
+A complete local matrix entry, incoming bank3 to outgoing bank1, is C=W R. W is the actual dual Q recovery, and R is the chronological reverse-current ADDRESS/native/sign product. Its actual B ranks are6f/8f. Exact literal circuits, tensor phase residues, selected suffix recipe IDs/embeddings, full local matrices and both serialized inverse orders are retained and checked. The rank6/8 lowering only witnesses this entry's uniform row support; it is not a completed replacement or a new supplier invoice. [PROOF.md](source/coupled-tail-escape/PROOF.md) displays the q2 six-by-six matrix, explicit arbitrary-input inverse and support proof.
+
+Initially every original or dirty-coordinate coefficient row has support1. A monomial adapter, SCALE or bank routing preserves maximum row support. A native query of rank r increases it by at most2^r; a binary ADD/accumulation by at most2. Thus every replacement output row has support at most2^(R_f+S_f). The fixed old-input coefficient C has2^(6f)/2^(8f) entries per row, giving the claimed bound. Dirty restoration cannot remove this required old-input block. New scalar coupling topology, overlapping intermediate coefficient sums and arbitrary restored dirt are permitted within this linear whole-bank model; COPY has no uncounted fan-in.
+
+Every query macro and elementary ADD refers to the same full bank volume. Partial-volume, striped or fused-scan controllers need a separate weighted proof and do not automatically inherit this unweighted bill. A runtime corollary also needs each ADD scan to cost a fixed positive multiple of the whole bank volume. Growing O(f) ADD counts are a conditional escape from the sublinear-scan native conclusion. The [conditional full-scan corollary](FULL-SCAN-COROLLARY.md) shows that a complete o(V_f f) overhead budget together with actual scan work≥c V_f S_f forces S_f=o(f). With equal-volume proper-child normalization, the limiting native moments are at least33(1/6)^(1−b)+(1/2)^(1−b)>6 and60(1/8)^(1−b)+(1/2)^(1−b)>8 for0<b<1. Unrestricted precision multipliers, partial-volume primitives and changed fused scans are outside these explicit premises.
+
+The [conditional repeating-tail lemma](source/coupled-tail-escape/ALL-Q-TAIL-LEMMA.md) gives entry rank nf for n=2q+2 when the same reverse odd-plane pattern, Q recovery, exact current coefficient and stock+4 total profile are supplied. It then gives R_f+S_f≥nf and the corresponding bounded-scan stock floor. Complete physical suffix bindings here are q2/q3. This does not construct an all-q caller/prefix/native compiler or assert the all-q stock+4 profile without its premises. Changing earlier source/fresh cuts, J support, physical input/output gauges or the target changes the local problem.
+
+## Reproduction and evidence
+
+```sh
+python3.12 -B scripts/research_package.py --package research/coupled-tail-support-floor
+python3.12 -B scripts/check_research_commit.py --package research/coupled-tail-support-floor --check-source-history
+```
+
+The registered command runs normal/-O. Direct `python3.12 -I -B verify.py` and `python3.12 -I -O -B verify.py` also run on a read-only Git-free export with empty PATH. The verifier uses only the standard library, authenticates original and executed sources/complete JSON, ignores bytecode caches, keeps historical assertions active and writes no package files. [REPLAY-MAP.md](REPLAY-MAP.md) maps complete fresh checks and exact source adaptations. Logical gzip payloads are decompressed/authenticated in memory; no executable deserialization or network is used. Compression changes transport size, not mathematical review scope.
+
+The complete source producers run through their read-only produce functions, including two small deterministic support-witness lowerings and exact recompilation. All current arbitrary incoming columns, both serialized inverse orders, used suffix native definitions/pointers, embeddings, Gaussian phases, fixed-prefix/local histograms and the specific unavoidable coefficient are recomputed and compared to frozen receipts. Dropping the incoming bank3 entry or reverse-current native query changes the full matrix and rejects. The complete frozen independent audit freshly replays both actual local matrices/inverses, every used native recipe/all-f phase, the explicit q2 inverse formulas and both omitted-query/f2-phase controls, plus q2..10 conditional rank corroboration. Its full receipt is compared without mathematical projection. These finite checks are distinct from the written arbitrary-replacement support proof.
+
+## Earlier cut58 next-interface appendix — target open
+
+The reviewed successor target moves the q2 entrance earlier, to the literal query5 source-J event58. All36 current-input matrix entries, both inverse orders and actual source native phases/recipes are checked. The fixed prefix is54f and source suffix22f, still total76f versus stock72f. An exact identity RP=−T jointly simplifies source ADDRESS and reverse-current wiring, preserving arbitrary dirty inputs and every Gaussian sign. The resulting scalar/address rewrite remains native mass22f and is verified as an operator word; it is not a newly admitted selected-native serialization.
+
+[The complete matrix and neutral factorization](source/early-cut58-planning/PROOF.md) are an explicit next construction interface. A hypothetical suffix of16f would give whole mass70f, but **no such factorization or native saving is supplied**. All ADD/SCALE/SWAP scans remain paid. This finite q2 all-f planning appendix does not enlarge the late-cut lower bound to the earlier entrance, prove16 optimal/necessary over arbitrary new alphabets, or discharge owners, precision, physical controller, BIT or recurrence gates. It was separately frozen and independently reviewed before the research cutoff; fresh full source/audit receipts are compared without a new search.
+
+## Open next questions
+
+[TASK.json](TASK.json) records the changed card, concrete next steps and blockers. A useful next construction must change an earlier physical entrance or fully price a growing-ADD controller on the exact current-input contract before comparing whole work or moments. No compatible BIT, owner allocation, precision/storage/tape controller, favorable supplier or outer transfer is supplied. This is a local gate, not a global caller/kernel optimum or a formal-kernel certificate.
+
+Scientific base20ecf2891d80b5acf18d980b2164fb44ea7faa90 and priority6 remain pinned. Canonical main bb4bccbf42844d2801487450727c2f63e10d1d0f changes only an unrelated sparse-baseline helper/test; guidance/selected record were unchanged at refresh. The explicit donor assignment changes the broad original joint-query-controller card's scope. [PR4080](https://github.com/CrocSwap/integer-mult-bounds/pull/4080), exact7b4594222a4b3b97404f9ef1d0b03b71ae2c6768, supplies the admitted words; [PR4074](https://github.com/CrocSwap/integer-mult-bounds/pull/4074) supplies the repaired folded source and PR4069 fixed-core ancestry. [PR4081](https://github.com/CrocSwap/integer-mult-bounds/pull/4081)'s response tariff has separately charged-site premises; the present support-count gate permits new local ADD topology but keeps its entrance/exit fixed.
+
+Ross Richardson with substantial OpenAI Codex assistance in proof, construction, independent audit and packaging; Apache-2.0. Separate AI reviews are not human/formal acceptance. Preserve icekylinx/PR531, Rohan Arun/kernel92, Chris R/Clear1nsight3987 and ToikY4002 phase/lift credit, Clear1nsight3989/4045 interface/volume work and complete retained source notices/credit map. Earlier3630/3632/3645/3649/3655 and BIT4021/4023 remain distinct. No selected-frontier change or new κ.
diff --git a/research/coupled-tail-support-floor/RELATED-WORK.json b/research/coupled-tail-support-floor/RELATED-WORK.json
new file mode 100644
index 0000000000..da00fd783c
--- /dev/null
+++ b/research/coupled-tail-support-floor/RELATED-WORK.json
@@ -0,0 +1,109 @@
+{
+  "scientific_base": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "priority_revision": 6,
+  "coverage": "Exact named PR head/body reads plus parent recent80-open-PR and partial live Discussion delta; not exhaustive code/closed/unpublished overlap.",
+  "pull_requests": [
+    {
+      "number": 3987,
+      "title": "Audit staged544 native phases and expose the binary-inverse lift defect",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3987",
+      "head": "fc536202fdaa924158789a5ef59ac079bbe21922",
+      "author": "Clear1nsight",
+      "scope": "Related phase/interface result; not rerun or claimed here."
+    },
+    {
+      "number": 4002,
+      "title": "Derive explicit native-lift phase tags and signed-word certificates",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4002",
+      "head": "d593941ea0a4926021cba9d01fe60500579e464f",
+      "author": "ToikY",
+      "scope": "Related phase/interface result; not rerun or claimed here."
+    },
+    {
+      "number": 3989,
+      "title": "Construct selected rank-two Pauli fusion and bound its uniform transfer bill",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3989",
+      "head": "7b6dda7ab6ed10d608ecba357ac2f6924166d38b",
+      "author": "Clear1nsight",
+      "scope": "Related phase/interface result; not rerun or claimed here."
+    },
+    {
+      "number": 4045,
+      "title": "research: bind joint-child batching to the staged544 native rank interface",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4045",
+      "head": "91afbb643f7f4ccf6f34b685ecd959eb790a0f94",
+      "author": "Clear1nsight",
+      "scope": "Related phase/interface result; not rerun or claimed here."
+    },
+    {
+      "number": 4021,
+      "title": "Verify five rank-four BIT terminals and their fixed-controller cost bound",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4021",
+      "head": "c01f97ecfc7fa64847f6abd8f7b231e1df8c7b70",
+      "author": "RossRichardson",
+      "scope": "Already published separate BIT/prior lineage; excluded from this new contribution."
+    },
+    {
+      "number": 4023,
+      "title": "Prove sharp fixed-support unary-query bounds with restored dirty banks",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4023",
+      "head": "9124007ea9029a9a3b88898bb4c350ddb27ffa58",
+      "author": "RossRichardson",
+      "scope": "Already published separate BIT/prior lineage; excluded from this new contribution."
+    },
+    {
+      "number": 3630,
+      "title": "Bound staged-supplier packing for every replica count",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3630",
+      "head": "bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608",
+      "author": "RossRichardson",
+      "scope": "Already published separate BIT/prior lineage; excluded from this new contribution."
+    },
+    {
+      "number": 3632,
+      "title": "Correct the selected P112 scatter covariance and dirty restoration",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3632",
+      "head": "7e7a889cbf6da2c4461af806fe52a888c621a7e7",
+      "author": "RossRichardson",
+      "scope": "Already published separate BIT/prior lineage; excluded from this new contribution."
+    },
+    {
+      "number": 3645,
+      "title": "Reduce R438 to 429 helpers with three source snapshots",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3645",
+      "head": "99b901c9b5ac70cf441b3d7e585cc7b8744b5359",
+      "author": "RossRichardson",
+      "scope": "Already published separate BIT/prior lineage; excluded from this new contribution."
+    },
+    {
+      "number": 3649,
+      "title": "Classify sharp noncubic ranks of the H6 odd-Gram family",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3649",
+      "head": "f8768756d8ac4abb263295170a436ba54562fdcd",
+      "author": "RossRichardson",
+      "scope": "Already published separate BIT/prior lineage; excluded from this new contribution."
+    },
+    {
+      "number": 3655,
+      "title": "Classify H6 dyadic Smith factors and sharp physical-row repair",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3655",
+      "head": "7bf23e128e58a33c019268f57129629f603547f7",
+      "author": "RossRichardson",
+      "scope": "Already published separate BIT/prior lineage; excluded from this new contribution."
+    },
+    {
+      "number": 4069,
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4069",
+      "head": "efb1b5a56a52967a4e94223bcdd03b209f4f09f5",
+      "author": "RossRichardson",
+      "scope": "Source-bound fixed-core J theorem, exact whole caller and shared frozen mathematical implementations; current changed interfaces are separate."
+    }
+  ],
+  "direct_predecessor": {
+    "number": 4074,
+    "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4074",
+    "head": "5758f0f3042b740ce872b5b0ae974917bd07016d",
+    "author": "RossRichardson",
+    "relationship": "Exact repaired source caller and eight-unit cross-cut construction; new general physical-monomial two-site rewrite saves four more native units. Shared implementations retain exact originals and source notices."
+  }
+}
diff --git a/research/coupled-tail-support-floor/REPLAY-MAP.md b/research/coupled-tail-support-floor/REPLAY-MAP.md
new file mode 100644
index 0000000000..8effddbd0f
--- /dev/null
+++ b/research/coupled-tail-support-floor/REPLAY-MAP.md
@@ -0,0 +1,24 @@
+# Local tail source-to-check map
+
+BINDINGS.json authenticates the full8-file author freeze, original admitted source and repaired physical source, every inherited exact library, original recipe utility and executed portable adapter. The complete frozen independent source review and all its declared raw inputs are also authenticated. Normal/-O and source-export tests are separate from the mathematical proofs and hosted CI.
+
+| Obligation | Fresh computation |
+|---|---|
+| q2 arbitrary-current-input matrix | local_block.produce replays the actual event69 suffix and full serialized inverse on all6 incoming fields; compares the displayed6×6 matrix, both inverse orders and actual A/W/R definitions including reverse-current order and sign. |
+| q3 arbitrary-current-input matrix | q3_tail.produce replays event119 suffix and inverse on all8 fields, recomputes the full WR coefficient and all source recipe bindings. |
+| Used native circuits | Every forward/inverse suffix unary is reconstructed from its original event ordinal/adjoin flag; exact signed operator, Gaussian tensor phase, current selected recipe ID, embedding and phase tags are compared. No unused source recipe is promoted into a native invoice. |
+| Support witnesses | The actual coefficient circuits are composed chronologically, native ranks6/8 recomputed, deterministic exact Bruhat/Fourier lowerings rederived and independently recompiled including Gaussian phase. These witnesses certify uniform row support, not executable complete cleanup. |
+| Complete bills | Full source prefixes66/120, suffixes10/12 and stocks72/128, every local original column and both inverse orders. |
+| Failures and scope | Omitted incoming bank3, omitted reverse-current query (spuriously6→4), source/transport/logical mutation and undeclared external source access reject; identical source/payloads and full exact local inverse are positive controls. Historical assertions stay active under optimized parents. |
+
+The original producer functions are unchanged. Only two local_block source guards follow the exact executed portable joint_algebra and verbatim pure recipe utility. Complete raw originals are retained; the verifier checks precisely those substitutions. Four pure compile/embedding functions from the original recipe utility remain byte-identical by AST source-segment SHA; unrelated cold-producer imports are omitted. Other inherited library adapters retain their original source/NOTICE and exact change maps from reviewed PR4080.
+
+Every complete logical JSON payload is SHA/length checked after deterministic gzip decoding. The actual executed modules compile from authenticated source bytes with optimize=0; no unchecked bytecode cache can replace them. Unmapped external workspace reads or dynamic loads reject. The official export is additionally tested normal/-O with empty PATH, no Git and unchanged exported bytes/modes/inodes.
+
+The source author normal/optimized receipts are historical execution evidence, including its recorded optimized-q3 read-before-file-existed sequencing failure and the successful corrected order. Fresh source production and independent audit are recorded separately; the finite receipts do not prove the arbitrary-circuit support lemma or a complete all-q source realization. Full-bank equal-volume macroarities, counted binary scans and fixed exact current-input matrix are mandatory cost premises. Partial/fused scans, growing ADD words, changed early entrances or target gauges need a new paid argument.
+
+Independent audit_tail.run reconstructs the complete6/8-bank matrices in its separate literal circuit algebra, both inverse orders, strict admitted-source slices, used-only recipe pools, Gaussian phase, prefix/local counts, explicit q2 inverse formula, omitted reverse-query and f2-phase controls. Its full result equals the retained independent receipt. q2..10 checks corroborate the separate conditional all-q tail formula; no all-q full caller is inferred.
+
+FULL-SCAN-COROLLARY.md uses only independently reviewed section4 of the retained threshold note, whose complete raw source is SHA-bound in independent_external_sources. The fresh verifier additionally recounts the exact fixed-prefix histograms H2=33/60 required by its limiting moment. Numerical planning/upstream candidate claims are not rerun or adopted. The all-b strict inequality is written algebra, not a finite numeric screen.
+
+The exact earlier-interface appendix executes unchanged cut58.produce and independent audit_cut58.run. Full6×6 current-input matrices/inverses, strict actual admitted slices, all source recipe/phase bindings, RP=-T sign, neutral rewrite and H2=9,H4=1 local bill22 are freshly verified. Actual b-accumulator omission and lost RP sign reject. The target16 remains explicitly unachieved; operator equality is not selected-native schema admission. No new lower bound, optimizer or saving is inferred.
diff --git a/research/coupled-tail-support-floor/SOURCES.json b/research/coupled-tail-support-floor/SOURCES.json
new file mode 100644
index 0000000000..68bddcb9b4
--- /dev/null
+++ b/research/coupled-tail-support-floor/SOURCES.json
@@ -0,0 +1,60 @@
+{
+  "schema_version": 1,
+  "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81",
+      "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5",
+      "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0"
+    },
+    {
+      "path": "research/kernel92-frame-composition/vendor/pr531/vendor/clifford/clifford_exact.py",
+      "usage": "provenance",
+      "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2",
+      "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962"
+    },
+    {
+      "path": "research/kernel92-frame-composition/NOTICE.md",
+      "usage": "provenance",
+      "git_blob": "8d3c3349e13774de4f992591c3a0b9e74029f761",
+      "sha256": "538e7634331d7e24791be08dedd737bf458f35a3b46ce651e6aacd905f3dee6e"
+    },
+    {
+      "path": "research/kernel92-frame-composition/PR533-NOTICE.md",
+      "usage": "provenance",
+      "git_blob": "6e6d0042d1cf618308e7e57df3e7e8b6958991d0",
+      "sha256": "2c1961a07b0976e29e8e6f4da14a9aaeb2f961a3a78d842488065aa433fa2f98"
+    },
+    {
+      "path": "research/kernel92-frame-composition/vendor/pr531/NOTICE.md",
+      "usage": "provenance",
+      "git_blob": "f7a8f861be860edd5a78114c5225dec90effa029",
+      "sha256": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1"
+    },
+    {
+      "path": "research/kernel92-frame-composition/vendor/pr531/SOURCES.json",
+      "usage": "provenance",
+      "git_blob": "78244052aae4866ae9e8e2d2e4c10180870a0fc4",
+      "sha256": "9e8182e6e659f4671fe0873e324b622cc871df7344157093df40476c8687be5f"
+    },
+    {
+      "path": "research/kernel92-frame-composition/vendor/pr531/inputs/PR523-ANCESTRY.json",
+      "usage": "provenance",
+      "git_blob": "385a202fbc485ceaed1b604d6c21eb3486caa600",
+      "sha256": "0bfce40d86c849f18e8872ee9e8462b0a69a34ed04e01e942a6614645f686f4b"
+    },
+    {
+      "path": "LICENSE",
+      "usage": "provenance",
+      "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64",
+      "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    }
+  ]
+}
diff --git a/research/coupled-tail-support-floor/TASK.json b/research/coupled-tail-support-floor/TASK.json
new file mode 100644
index 0000000000..c45b79e3ed
--- /dev/null
+++ b/research/coupled-tail-support-floor/TASK.json
@@ -0,0 +1,79 @@
+{
+  "schema_version": 1,
+  "task_id": "joint-query-controller",
+  "priority_revision": 6,
+  "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "original_card": {
+    "id": "joint-query-controller",
+    "question": "Can a literal QQ16 producer meet the proposed completed-output error budgets with dirty helpers and an affordable physical consumer?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "research/joint-query/README.md",
+      "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md",
+      "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md",
+      "docs/research/community-efficient1000-review.md",
+      "research/qq16-producer-defect-transfer/README.md"
+    ],
+    "methods": [
+      "Derive one literal producer's completed-output defects and intermediate dirty-helper bounds, with its physical bill.",
+      "Design or audit one consumer, retention or hosting boundary and its complete cost for the pinned producer/decoder."
+    ],
+    "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read the revision-6 family record and #2965 producer-defect transfer after the local QQ16 decoder contract. Its author-checked output-error estimate does not implement producer interiors, bound dirty helpers, or pay for the consumer; independently check the implication used.",
+      "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission."
+    },
+    "first_experiment": "Pin one literal F0/B1 producer and its native-child contracts; derive the actual intermediate magnitude ledger and completed-output defects, including dirty helpers and correlations. Compare with #2965 budgets and price storage, movement, cleanup and F17 consumption. Stop with a precise missing bound if no producer contract supplies it; do not optimize another decoder precision constant in isolation.",
+    "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.",
+    "allowed_variations": [
+      "One paid query, one changed first pair, or one precisely specified affine helper state.",
+      "A counterexample or lower bound for that exact proposed repair.",
+      "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain."
+    ],
+    "scope_change_triggers": [
+      "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.",
+      "Treating cover-map counts as zero-cost physical address operations.",
+      "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.",
+      "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate."
+    ],
+    "overlap_terms": [
+      "QQ16",
+      "joint-query",
+      "changing-chart controller",
+      "selected observation",
+      "1969",
+      "2540",
+      "early record",
+      "output-bank retention",
+      "complete native decoder",
+      "2965",
+      "producer defect",
+      "dirty-helper range",
+      "F17 consumer"
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Fixed late-cut coupled cleanup support floor permitting new scalar/monomial topology and extra restored arbitrary dirt; exact q2/q3 physical source blocks and conditional all-q tail pattern. Conditional actual full-scan o(V_f f) bridge and limiting equal-volume proper-child moment corollary, separately from finite-f support inequality. Independently reviewed exact earlier cut58 planning appendix; prefix54/local22, neutral rewrite22 and hypothetical target16 remains open.",
+  "scope_change_reason": "Explicit donor-assigned bounded continuation of PR4080 after exact single-entry support gate; broad original catalogue card remains open.",
+  "bottleneck_link": "Original-input inverse support versus actual paid prefix and continuation cuts, with explicit equal-volume/full-scan normalization and retained outer-transfer source binding.",
+  "budget_minutes": 240,
+  "stop_rule": "No pointwise finite-f native-only floor, global caller optimum, partial-volume/fused-scan transfer, positive supplier or new kappa.",
+  "outcome": "negative-result",
+  "evidence": "README.md, frozen local block/inverses, all-f source recipe checks and independent audit.",
+  "author": "Ross Richardson",
+  "ai_assistance": "Substantial OpenAI Codex assistance across the original construction, separate mathematical checking contexts, and publication packaging. AI review is not independent human or formal-kernel acceptance.",
+  "open_questions": [
+    {
+      "question": "Can an earlier changed source/coupled cut or a fully priced growing-ADD controller beat stock?",
+      "why_it_matters": "The fixed late entrance has an unavoidable large-support coefficient; growing ADD count or another entrance changes the cost question.",
+      "first_step": "Start with the complete reviewed q2 event58 current-input matrix (prefix54/local22). A hypothetical local16 gives total70; supply a full coupled factorization, selected recipe/phase schema and scan/owner/volume invoice without losing any of36 entries or either pivot.",
+      "blocked_by": "No complete favorable implementation, compatible BIT or physical recursive transfer."
+    }
+  ]
+}
diff --git a/research/coupled-tail-support-floor/VERIFY.json b/research/coupled-tail-support-floor/VERIFY.json
new file mode 100644
index 0000000000..dcd0924f43
--- /dev/null
+++ b/research/coupled-tail-support-floor/VERIFY.json
@@ -0,0 +1,28 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 600,
+      "checks": "Exact arbitrary-input local matrices, both serialized inverse orders, all suffix source/native pointer/embedding/Gaussian phase bindings, single-entry support witness, full prefix/local bills, source and omitted-input/reverse-query controls; independent current-pin audit. Complete independent exact cases and conditional rank grid; fresh fixed-prefix histograms for written fullscan/moment corollary. Full unchanged cut58 source producer and independent all36-entry/inverse/native/phase rank-neutral planning audit; target16 explicitly OPEN."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 600,
+      "checks": "Exact arbitrary-input local matrices, both serialized inverse orders, all suffix source/native pointer/embedding/Gaussian phase bindings, single-entry support witness, full prefix/local bills, source and omitted-input/reverse-query controls; independent current-pin audit. Complete independent exact cases and conditional rank grid; fresh fixed-prefix histograms for written fullscan/moment corollary. Full unchanged cut58 source producer and independent all36-entry/inverse/native/phase rank-neutral planning audit; target16 explicitly OPEN."
+    }
+  ]
+}
diff --git a/research/coupled-tail-support-floor/original/caller-joint/joint_algebra.py b/research/coupled-tail-support-floor/original/caller-joint/joint_algebra.py
new file mode 100644
index 0000000000..e8f539eff8
--- /dev/null
+++ b/research/coupled-tail-support-floor/original/caller-joint/joint_algebra.py
@@ -0,0 +1,113 @@
+"""Pinned exact all-f Gaussian X-character operator algebra.
+Apache-2.0; substantial OpenAI Codex assistance.
+"""
+from pathlib import Path
+from fractions import Fraction as F
+import hashlib,importlib.util,sys
+sys.dont_write_bytecode=True
+OLD=Path('/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z')
+PINS={
+ 'root-chronology/quadratic_charts.py':'de2a36f6a6b567360c90477b58da44e2f1b618fd006d058ab1ea04e983952c3f',
+ 'native-frames/native_model.py':'6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3',
+ 'native-frames/even_parity_source.py':'961f136e4bc1b5da930bdd4ba9bbb594892b9e27f7ab44749d747d4fe16b4cb3',
+ 'caller/nested_prefix.py':'9ec10cb0243c0c829475ad7290f4953cdff27cb0f90f70b687c4bbee98af676b',
+ 'caller/nested_family.py':'88f425d12baf8a4f849cccd24605f21680eb8ce8d199054db4b4e7734eca72b6',
+}
+def need(c,m):
+ if not c:raise ValueError(m)
+for p,h in PINS.items():need(hashlib.sha256((OLD/p).read_bytes()).hexdigest()==h,'frozen source pin '+p)
+spec=importlib.util.spec_from_file_location('joint_pinned_quadratic',OLD/'root-chronology/quadratic_charts.py')
+qc=importlib.util.module_from_spec(spec);sys.modules[spec.name]=qc;spec.loader.exec_module(qc)
+sys.path.insert(0,str(OLD/'caller'));sys.path.insert(0,str(OLD/'native-frames'))
+from nested_prefix import skeleton
+from nested_family import retraction
+from native_model import Model,ce,mul,same
+from even_parity_source import kernels
+
+ZERO=(F(0),)*8;ONE=(F(1),F(0))*4
+def rotate(v,c,g):
+ out=[]
+ for r in range(4):
+  a,b=v[2*r:2*r+2];out.extend(((a,b),(-b,a),(-a,-b),(b,-a))[(c*r+g)%4])
+ return tuple(out)
+def cproduct(a,b):
+ return tuple(z for r in range(4)for z in(a[2*r]*b[2*r]-a[2*r+1]*b[2*r+1],a[2*r]*b[2*r+1]+a[2*r+1]*b[2*r]))
+def normalize(g,v):
+ return qc.Mono(g.rows,g.offset,g.alpha,g.quad),rotate(v,g.constant,g.global_phase)
+def mono(g,c=1):
+ k,v=normalize(g,tuple(F(c)*x for x in ONE));return{k:v}if any(v)else{}
+def add(a,b):
+ out=dict(a)
+ for k,v in b.items():
+  w=tuple(x+y for x,y in zip(out.get(k,ZERO),v))
+  if any(w):out[k]=w
+  else:out.pop(k,None)
+ return out
+def scale(a,c):return{k:tuple(F(c)*x for x in v)for k,v in a.items()}if c else{}
+def product(a,b):
+ out={}
+ for g,x in a.items():
+  for h,y in b.items():
+   k,v=normalize(g@h,cproduct(x,y));out=add(out,{k:v})
+ return out
+def adjoint(a):
+ out={}
+ for g,v in a.items():
+  k,w=normalize(g.inv(),tuple(x if i%2==0 else-x for i,x in enumerate(v)));out=add(out,{k:w})
+ return out
+def summ(items):
+ out={}
+ for item in items:out=add(out,item)
+ return out
+def eye(n,m):
+ I=mono(qc.identity(m));return[[dict(I)if i==j else{}for j in range(n)]for i in range(n)]
+def mm(A,B):
+ n=len(A);return[[summ(product(A[i][k],B[k][j])for k in range(n)if A[i][k]and B[k][j])for j in range(n)]for i in range(n)]
+def serial(e):return[{'x_monomial':g.data(),'coefficients_by_f_mod4':[[str(v[2*r]),str(v[2*r+1])]for r in range(4)]}for g,v in sorted(e.items(),key=lambda x:str(x[0]))]
+def sm(M):return[[serial(e)for e in row]for row in M]
+def n_pair(m,i):
+ return qc.old_operator({'operator':{'native_blocks':[i],'block_permutation':list(range(m//2)),'sign':1}},m)
+def plane_swap(m,i,j):
+ rows=[1<<k for k in range(m)]
+ for d in(0,1):rows[2*i+d],rows[2*j+d]=rows[2*j+d],rows[2*i+d]
+ return qc.Mono(tuple(rows),0,(0,)*m,(0,)*m)
+def j_operator(m):
+ return qc.from_function(qc.identity(m).rows,3,lambda x:1+qc.parity(x&5)+qc.parity(x&10),1)
+def prefix(m,s):
+ out=qc.identity(m)
+ for i in range(1,s+1):out=n_pair(m,i)@out
+ return out
+
+class Word:
+ def __init__(self,n,m):self.n=n;self.m=m;self.M=eye(n,m);self.Mi=eye(n,m);self.events=[]
+ def add(self,d,s,c=1,label=''):
+  if not c:return
+  need(d!=s,'ADD distinct banks')
+  self.M[d]=[add(x,scale(y,c))for x,y in zip(self.M[d],self.M[s])]
+  for row in self.Mi:row[s]=add(row[s],scale(row[d],-c))
+  self.events.append({'kind':'ADD','dst':d,'src':s,'coefficient':str(c),'label':label})
+ def unary(self,b,g,label='',native=False,family=None):
+  G,Gi=mono(g),mono(g.inv())
+  self.M[b]=[product(G,x)for x in self.M[b]]
+  for row in self.Mi:row[b]=product(row[b],Gi)
+  self.events.append({'kind':'NATIVE'if native else'ADDRESS_OR_UNIT','bank':b,'x_monomial':g.data(),
+                      'rank_per_f':qc.rank(g.polar()),'label':label,'native_family':family})
+ def swap(self,i,j,label=''):
+  self.M[i],self.M[j]=self.M[j],self.M[i]
+  for row in self.Mi:row[i],row[j]=row[j],row[i]
+  self.events.append({'kind':'BANK_SWAP','banks':[i,j],'label':label})
+ def inverse_events(self):
+  out=[]
+  for e in reversed(self.events):
+   d=dict(e)
+   if e['kind']=='ADD':d['coefficient']=str(-F(e['coefficient']))
+   elif e['kind']!='BANK_SWAP':d['x_monomial']=qc.decode(e,self.m).inv().data()
+   if e['kind']not in('ADD','BANK_SWAP')and'one_coordinate_literal_circuit'in e:
+    literal=ce.Op(self.m,tuple(tuple(t)for t in e['one_coordinate_tableau']),e['one_coordinate_literal_circuit']).adjoint()
+    d['one_coordinate_literal_circuit']=literal.circuit;d['one_coordinate_tableau']=[list(t)for t in literal.tab]
+    d['phase_exponent']=-e['phase_exponent']
+    if e.get('native_family'):
+     d['native_family']=dict(e['native_family']);d['native_family']['inverse']=not e['native_family'].get('inverse',False)
+     key=e['native_recipe_id'];d['native_recipe_id']=key[:-3]if key.endswith('inv')else key+'inv'
+   out.append(d)
+  return out
diff --git a/research/coupled-tail-support-floor/original/caller-joint/validate_recipe_links.py b/research/coupled-tail-support-floor/original/caller-joint/validate_recipe_links.py
new file mode 100644
index 0000000000..8b74ec621b
--- /dev/null
+++ b/research/coupled-tail-support-floor/original/caller-joint/validate_recipe_links.py
@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""Verify every native event's selected recipe pointer and actual operator.
+Apache-2.0; substantial OpenAI Codex assistance.
+"""
+from pathlib import Path
+import argparse,hashlib,json
+from joint_algebra import *
+from joint_prefix import check_literal_family
+from literal_events import inverse_events
+HERE=Path(__file__).resolve().parent
+
+def compile_literal(circuit,n):
+ out=ce.ident(n)
+ for gate in circuit:
+  if gate[0]=='P':op=ce.perm(n,tuple(gate[1]))
+  elif gate[0]=='D':op=ce.diag(n,tuple(gate[1]),tuple(gate[2]))
+  elif gate[0]=='C':op=ce.cgate(n,gate[1],gate[2])
+  elif gate[0]=='X':op=ce.xgate(n,gate[1])
+  elif gate[0]=='phase':op=ce.Op(n,ce.identity(n),[tuple(gate)])
+  else:raise ValueError('uncovered selected literal '+str(gate[0]))
+  out=out.then(op)
+ return out
+
+def compile_monomial(rec,n):
+ return compile_literal([('D',rec['quadratic_rows'],rec['linear_Z4']),('P',rec['matrix_rows']),('X',rec['offset']),('phase',rec['phase'])],n)
+def compile_recipe(rec,n):
+ left=compile_monomial(rec['left'],n)
+ if not rec['rank']:return left
+ need(rec['right']is not None,'nonzero native rank has both literal monomial adapters')
+ return compile_monomial(rec['right'],n).then(ce.fourier(n,range(rec['rank']))).then(left)
+
+def embedding_circuit(circuit,embedding,n):
+ d=len(embedding);need(len(set(embedding))==d and all(0<=j<n for j in embedding),'recipe embedding injective')
+ def bits(x):return sum(((x>>i)&1)<<embedding[i]for i in range(d))
+ out=[]
+ for gate in circuit:
+  typ=gate[0]
+  if typ=='P':
+   rows=[1<<i for i in range(n)]
+   for i,j in enumerate(embedding):rows[j]=bits(gate[1][i])
+   out.append(('P',tuple(rows)))
+  elif typ=='D':
+   rows=[0]*n;alpha=[0]*n
+   for i,j in enumerate(embedding):rows[j]=bits(gate[1][i]);alpha[j]=gate[2][i]
+   out.append(('D',tuple(rows),tuple(alpha)))
+  elif typ in('C','X'):out.append((typ,bits(gate[1]),*gate[2:]))
+  elif typ=='phase':out.append(tuple(gate))
+  else:raise ValueError('uncovered embedded recipe '+typ)
+ return out
+
+def check_artifact(path):
+ data=json.loads(path.read_text());counts=[]
+ for fixture in data['fixtures']:
+  m=fixture['ambient_arity'];pool=fixture['native_recipe_pool'];compiled={}
+  for key,p in pool.items():
+   need('selected_native_recipe'in p,'selected-native lowering present in recipe pool '+key)
+   n=len(p['one_coordinate_tableau'])//2
+   actual=ce.Op(n,tuple(tuple(t)for t in p['one_coordinate_tableau']),p['one_coordinate_definition_circuit'])
+   compiled[key]=compile_recipe(p['selected_native_recipe'],n)
+   same(compiled[key],actual,'recipe pool exact selected child and monomial adapters '+key)
+  events=fixture.get('full_events',fixture.get('events',[]));inverse=inverse_events(events,m);used=0
+  need(mm(qc.replay(events,fixture['banks'],m),qc.replay(inverse,fixture['banks'],m))==eye(fixture['banks'],m),'derived full literal inverse covers every original field')
+  for direction,E in(('forward',events),('inverse',inverse)):
+   for e in E:
+    if e['kind']!='NATIVE':continue
+    check_literal_family(e,m)
+    key=e['native_recipe_id'];need(key in pool,direction+' native recipe id missing: '+key)
+    p=pool[key];need(e['phase_exponent']==p['phase_exponent'],direction+' native all-f phase exponent matches pool '+key)
+    actual=ce.Op(m,tuple(tuple(t)for t in e['one_coordinate_tableau']),e['one_coordinate_literal_circuit'])
+    literal=embedding_circuit(compiled[key].circuit,e['recipe_embedding'],m)
+    full=compile_literal(literal,m)
+    same(full,actual,direction+' actual event equals embedded selected recipe '+key)
+    need(ce.rank(x for x,y,p in full.tab[m:])==e['rank_per_f'],direction+' complete selected child rank '+key)
+    used+=1
+  counts.append({'q':fixture['q'],'name':fixture.get('name'),'native_forward_and_inverse_links':used,'pool_entries':len(pool)})
+ return {'path':str(path),'sha256':hashlib.sha256(path.read_bytes()).hexdigest(),'fixtures':counts}
+
+def produce():
+ good=check_artifact(HERE/'JOINT-COMPLETE.json')
+ try:check_artifact(HERE/'before-recipe-id-fix-v1'/'JOINT-COMPLETE.json')
+ except ValueError as e:
+  need('native recipe id missing'in str(e),'before-fix mutant fails specifically for missing inverse pointer')
+  rejected=str(e)
+ else:raise ValueError('before-fix metadata mutant unexpectedly passes')
+ return {'status':'PASS_ALL_FORWARD_INVERSE_RECIPE_LINKS_AND_SELECTED_OPERATORS','checked':[good],
+         'negative_control':{'before_fix_rejected':rejected},
+         'producer_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+         'source_pins':[{'path':str(HERE/'joint_algebra.py'),'sha256':hashlib.sha256((HERE/'joint_algebra.py').read_bytes()).hexdigest()}],
+         'scope':'Derived complete literal inverse, including every prefix event, is replayed. Every selected-native pool recipe is independently recompiled; every forward/inverse native pointer, embedding, actual Gaussian phase, tensor-family phase exponent and rank matches. Original before-fix receipt remains preserved and is rejected.'}
+def main():
+ p=argparse.ArgumentParser();p.add_argument('--write',action='store_true');a=p.parse_args();out=produce();path=HERE/'RECIPE-LINK-VALIDATION.json'
+ if a.write:path.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n')
+ else:need(json.loads(path.read_text())==out,'saved recipe link validation differs')
+ print(out['status'])
+if __name__=='__main__':main()
diff --git a/research/coupled-tail-support-floor/original/coupled-tail-escape/local_block.py b/research/coupled-tail-support-floor/original/coupled-tail-escape/local_block.py
new file mode 100644
index 0000000000..7395bf4486
--- /dev/null
+++ b/research/coupled-tail-support-floor/original/coupled-tail-escape/local_block.py
@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""Exact arbitrary-input q2 cleanup block and its single-entry support gate.
+Apache-2.0. Substantial OpenAI Codex assistance. No new caller/kappa.
+"""
+from pathlib import Path
+from collections import Counter
+import argparse, copy, hashlib, json, sys
+sys.dont_write_bytecode = True
+HERE = Path(__file__).resolve().parent
+RUNDIR = HERE.parent
+PINS = {
+    'two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json': '30d3f569d91304856118796f0c586176d0ad961eff70b09c78fce7532392101f',
+    'two-site-continuation/MANIFEST.json': '44f1e264b3087ab8fdb08b4cd6e27befefbba380852b0119321724b7bc41b5da',
+    'folded-fusion/SIMPLIFIED-FUSIONS.json': '4491cfe2a1f3e48510b33403b9b50c704865c3b1dc6d659ef5157840654e8fc3',
+    'caller-joint/joint_algebra.py': '5782033e347c9b10ad47c01ed12a0a52ea07e901fa9e8f7aa9d3a2a928327232',
+    'caller-joint/validate_recipe_links.py': '7457b3672d5a73c584d2073b5d3312e6429fd3f433151f15f8f07da33aa4c59a',
+}
+for relative, expected in PINS.items():
+    if hashlib.sha256((RUNDIR / relative).read_bytes()).hexdigest() != expected:
+        raise ValueError('frozen source pin: ' + relative)
+sys.path.insert(0, str(RUNDIR / 'caller-joint'))
+from joint_algebra import *
+from validate_recipe_links import compile_literal, compile_recipe, embedding_circuit
+
+
+def extra(e):
+    return tuple(e.get('extra_global_phase_exponent_by_f_mod4',
+                       [e.get('phase_exponent', 0)*(1-r) % 4 for r in range(4)]))
+
+
+def produce():
+    admitted = json.loads((RUNDIR / 'two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json').read_text())
+    source = json.loads((RUNDIR / 'folded-fusion/SIMPLIFIED-FUSIONS.json').read_text())
+    f = next(f for f in admitted['fixtures'] if f['q'] == 2)
+    old = next(f for f in source['fixtures'] if f['q'] == 2)
+    E = f['events']; m, n, cut = f['ambient_arity'], f['banks'], 69
+    need(E[cut]['label'] == 'final independent a J query', 'exact local physical entrance cut')
+    suffix = copy.deepcopy(E[cut:])
+    inverse = copy.deepcopy(f['inverse_events'][:len(suffix)])
+    compiled = {}
+    used_pool = {}
+    # Every unchanged suffix unary retains an explicit source-event binding.
+    for direction, events in [('forward', suffix), ('inverse', inverse)]:
+        for e in events:
+            if e['kind'] in ('ADD', 'SCALE', 'BANK_SWAP'):
+                continue
+            source_event = old['events'][e['source_event_ordinal']]
+            g = qc.decode(source_event, m)
+            if e['source_operator_is_adjoint']:
+                g = g.inv()
+            e['x_monomial'] = g.data()
+            op = compile_literal(e['one_coordinate_literal_circuit'], m)
+            need(op.tab == tuple(tuple(t) for t in e['one_coordinate_tableau']), 'actual signed source unary')
+            need(ce.rank(x for x,z,p in op.tab[m:]) == e['rank_per_f'], 'actual source unary native rank')
+            # The physical definition is compared with the pinned symbolic
+            # coordinate definition using a separately constructed circuit.
+            from joint_prefix import inverse_transpose
+            circ=[]
+            for i,a in enumerate(g.alpha):
+                if a%4 == 1:circ.append(('C',1<<i,1))
+                elif a%4 == 2:circ.extend([('C',1<<i,1)]*2)
+                elif a%4 == 3:circ.append(('C',1<<i,-1))
+            for i,row in enumerate(g.quad):
+                for j in range(i+1,m):
+                    if row>>j&1:circ.extend([('C',1<<i,1),('C',1<<j,1),('C',(1<<i)|(1<<j),-1)])
+            circ.extend([('P',inverse_transpose(g.rows)),('D',(0,)*m,tuple(2*((g.offset>>i)&1)for i in range(m))),
+                         ('phase',(g.constant+g.global_phase)%4)])
+            same(compile_literal(circ,m), op, 'actual source unary exact Gaussian phase')
+            need(extra(e) == tuple(g.global_phase*(1-r)%4 for r in range(4)), 'actual all-f source tensor phase correction')
+            if e['kind'] == 'NATIVE':
+                key=e['native_recipe_id']; rec=f['native_recipe_pool'][key]
+                local_n=len(rec['one_coordinate_tableau'])//2
+                selected=compile_recipe(rec['selected_native_recipe'],local_n)
+                full=compile_literal(embedding_circuit(selected.circuit,e['recipe_embedding'],m),m)
+                same(full,op,'every used forward/inverse selected source recipe and embedding')
+                need(tuple(rec['extra_global_phase_exponent_by_f_mod4'])==extra(e),'selected source recipe tensor-phase correction')
+                used_pool[key]=rec
+            compiled[(direction,e['label'])] = op
+    M = qc.replay(suffix,n,m); Mi = qc.replay(inverse,n,m)
+    need(mm(M,Mi) == mm(Mi,M) == eye(n,m), 'complete serialized suffix inverse both orders on every arbitrary input')
+    A = qc.decode(next(e for e in suffix if e['label']=='final independent a J query'),m)
+    W = qc.decode(next(e for e in suffix if e['label']=='dual Q1 recovery'),m)
+    reverse_events = [e for e in suffix if e['label'] in ('w reverse2 ADDRESS','w reverse2 selected native2','final extraction D_final inverse sign')]
+    RR = qc.identity(m)
+    for e in reverse_events:RR = qc.decode(e,m) @ RR
+    F5 = prefix(m,5); Q = j_operator(m).inv() @ plane_swap(m,0,1) @ n_pair(m,0).inv() @ j_operator(m) @ j_operator(m)
+    need(mono(A) == mono(F5@j_operator(m)@F5.inv()), 'actual A definition')
+    need(mono(W) == mono(F5@Q.inv()@F5.inv()), 'actual W definition')
+    minus = qc.Mono(qc.identity(m).rows,0,(0,)*m,(0,)*m,0,2)
+    need(mono(RR) == mono(minus@n_pair(m,5)@plane_swap(m,0,5)), 'actual reverse-current operator and minus phase')
+    I = mono(qc.identity(m)); Z = {}; IW = add(I,scale(mono(W),-1))
+    expected = [[{}for _ in range(n)]for _ in range(n)]
+    expected[0][0] = mono(A)
+    expected[1][0] = scale(mono(W@A),-1); expected[1][2] = IW; expected[1][3] = mono(W@RR); expected[1][4] = IW
+    expected[2][0] = scale(mono(A),-1); expected[2][2] = I
+    expected[3][0] = scale(mono(A@W@A),-1); expected[3][1] = mono(A)
+    expected[3][2] = product(mono(A),IW)
+    expected[3][3] = product(mono(A),product(scale(IW,-1),mono(RR)))
+    expected[3][4] = scale(mono(A@W),-1)
+    expected[4][4] = I; expected[5][5] = I
+    need(M == expected, 'literal entire local block equals six-by-six symbolic operator target')
+    need(len(M[1][3]) == 1 and qc.rank(next(iter(M[1][3])).polar()) == 6, 'single actual arity-six input3/output1 coefficient')
+    # Independently lower that exact coefficient to certify its uniform row
+    # support. This recipe is a witness, not a proposed complete cleanup.
+    C = ce.ident(m); ce_extra = [0]*4
+    for e in reverse_events + [next(e for e in suffix if e['label']=='dual Q1 recovery')]:
+        C = C.then(compile_literal(e['one_coordinate_literal_circuit'],m))
+        ce_extra = [(x+y)%4 for x,y in zip(ce_extra,extra(e))]
+    need(ce.rank(x for x,z,p in C.tab[m:]) == 6, 'coefficient physical B-rank6')
+    recipe, lowered = ce.lower_child(C)
+    need(recipe['rank'] == 6, 'explicit selected Fourier rank for support witness')
+    same(lowered,C,'support-witness selected child exact Gaussian phase')
+    same(compile_recipe(recipe,m),C,'independent support-witness recipe recompilation')
+    before = sum(e['rank_per_f']for e in E[:cut]if e['kind']=='NATIVE')
+    local_hist = Counter(e['rank_per_f']for e in suffix if e['kind']=='NATIVE')
+    local = sum(r*c for r,c in local_hist.items())
+    need(before == 66 and local == 10 and before+local == f['native_mass'] == 76, 'complete unchanged-prefix plus local-native bill')
+    need(f['stock'] == 72 and f['stock']-before == 6, 'exact below-stock local threshold')
+    mutant = [[dict(v) for v in row] for row in M];mutant[1][3] = {}
+    need(mutant != M, 'discarding arbitrary incoming bank3 changes an original coefficient')
+    omitted_reverse = [e for e in suffix if e['label'] != 'w reverse2 selected native2']
+    wrong = qc.replay(omitted_reverse,n,m)
+    need(wrong != M and len(wrong[1][3]) == 1, 'omitting the reverse-current native query changes the arbitrary-input block')
+    need(qc.rank(next(iter(wrong[1][3])).polar()) == 4, 'omitted reverse query spuriously lowers the witness rank')
+    need(not any(e['kind']=='SCALE'for e in suffix),'actual suffix needs no hidden SCALE cancellation')
+    return dict(status='PASS_EXACT_COUPLED_CLEANUP_BLOCK_AND_SUPPORT_BOUNDARY', no_new_kappa=True,
+                producer_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+                source_pins=[dict(path=str(RUNDIR/p),sha256=h)for p,h in PINS.items()],
+                q=2,banks=n,ambient_arity=m,cut_event_ordinal=cut,cut_label=E[cut]['label'],
+                unchanged_prefix_native_mass=before,local_native_histogram=dict(sorted(local_hist.items())),local_native_mass=local,
+                complete_mass=76,endpoint_stock=72,strict_improvement_requires_local_native_mass_less_than=6,
+                events=suffix,inverse_events=inverse,native_recipe_pool=used_pool,
+                all_original_local_columns=n,literal_inverse_orders=2,
+                complete_local_matrix=sm(M),complete_local_inverse=sm(Mi),
+                operators=dict(A=A.data(),W=W.data(),R=RR.data()),
+                unavoidable_entry=dict(row=1,column=3,operator=serial(M[1][3]),native_arity_per_f=6,
+                                      one_coordinate_tableau=C.tab,one_coordinate_literal_circuit=C.circuit,
+                                      extra_global_phase_exponent_by_f_mod4=ce_extra,
+                                      support_witness_selected_native_recipe=recipe,
+                                      role='Only certifies row support of an entry; not an executed new cleanup/native invoice.'),
+                all_f_support_inequality='sum_native_arities_R_f + binary_fullbank_ADD_count_S_f >=6f',
+                constant_scan_consequence='For this exact local interface, bounded-in-f ADD count implies liminf R_f/f>=6; unchanged prefix66f then gives asymptotic total>=72f.',
+                finite_f_scope='R_f>=6f-S_f, not a pointwise native-only6f lower bound when S_f is positive.',
+                non_native_event_counts=dict(Counter(e['kind']for e in suffix if e['kind']!='NATIVE')),
+                negative_controls=['Discarding arbitrary incoming bank3 deletes a nonzero arity6 coefficient and is rejected.',
+                                   'Omitting reverse-current N5 changes the exact matrix and spuriously lowers entry rank6 to4; rejected.'],
+                limits=['Any replacement must realize this exact current-input matrix on all arbitrary banks, not only a clean/correlated subspace.',
+                        'Arbitrary extra dirty registers restored are permitted by the support proof; their identity coefficient rows start with support1.',
+                        'Native rank mass lower bound uses monomial adapters/scalars of row support1 and binary ADD/COPY gates, counting every support-doubling scan.',
+                        'Growing O(f) ADD counts, partial/fused scan machine models, changed input/output gauges or an earlier fresh/source/coupled cut require separate analysis.',
+                        'No expensive enumeration, new full cleanup factorization, supplier, owner, BIT, recurrence or kappa admission.'])
+
+
+def main():
+    p = argparse.ArgumentParser();p.add_argument('--write',action='store_true');a=p.parse_args()
+    result=json.loads(json.dumps(produce()));out=HERE/'LOCAL-BLOCK.json'
+    if a.write:out.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n')
+    else:need(json.loads(out.read_text())==result,'saved coupled local block')
+    print(result['status'],'fixed66 + local10; unavoidable entry6f; no bounded-scan local bill<6f')
+
+
+if __name__=='__main__':main()
diff --git a/research/coupled-tail-support-floor/original/dependencies/0eb564effb343e2a20af79445b6a319b719621965b2dc82a303bc6541e34d232-PROOF.md b/research/coupled-tail-support-floor/original/dependencies/0eb564effb343e2a20af79445b6a319b719621965b2dc82a303bc6541e34d232-PROOF.md
new file mode 100644
index 0000000000..0c39c1a491
--- /dev/null
+++ b/research/coupled-tail-support-floor/original/dependencies/0eb564effb343e2a20af79445b6a319b719621965b2dc82a303bc6541e34d232-PROOF.md
@@ -0,0 +1,298 @@
+# Charged q2/q3 planning thresholds and the final-a full-scan gate
+
+This is a planning calculation and a conditional transfer obstruction. It does
+not construct a favorable caller or BIT supplier and does not claim a new κ.
+Scientific pin: `20ecf2891d80b5acf18d980b2164fb44ea7faa90`; inspected canonical
+main: `bb4bccbf42844d2801487450727c2f63e10d1d0f`. Only this directory is owned.
+
+## 1. Actual inputs and recurrence convention
+
+The admitted, independently reviewed two-site words have the complete actual
+event histograms
+
+| q | n | ambient m | H2 | H4 | native mass | output stock mass |
+|---|---:|---:|---:|---:|---:|---:|
+| 2 | 6 | 12 | 36 | 1 | 76 | 72 |
+| 3 | 8 | 16 | 64 | 1 | 132 | 128 |
+
+The authenticated admitted artifact has SHA256
+`30d3f569d91304856118796f0c586176d0ad961eff70b09c78fce7532392101f`.
+`screen.py` recounts positive `rank_per_f` entries from the complete emitted
+events rather than accepting the declared histogram alone. The local proof
+and independent review cover every original arbitrary field, both pivots,
+Gaussian f residues, selected native recipes and the serialized inverse.
+They do not admit a favorable recursive multiplication supplier.
+
+Use the explicitly stipulated equal-volume, full-bank normalization: m=2n,
+each declared native call has the same row-volume share, the normalized stock
+is W=n, and every child rank lies strictly between 0 and m. The native test is
+
+    M_b(H) = sum_r H_r (r/m)^(1-b) < n,          0<b<1.       (1)
+
+This is the normalized recurrence of `notes/batched-bit-rows.tex` with
+exponent 1-b and width r floor(e/m), conditional on its actual operator,
+whole-row, integer-width and constant-toll interfaces. In a different volume
+model the test is instead
+
+    sum_j v_j (r_j/m)^(1-b) < 1.                            (2)
+
+One may not use (1) for unequal child/helper volumes merely because the
+unweighted arity sum has the same value. This note grants (1) as a planning
+normalization; it does not supply that missing compiler/interface proof.
+
+For the admitted profiles,
+
+    M_b = n^(1+b) + (2/n)^(1-b) > n.
+
+They fail (1) for every positive b, even with every other cost omitted.
+
+## 2. Minimum net saving and useful integral targets
+
+Write mass(H)=sum_r r H_r and
+
+    P_b(H) = sum_r r H_r [(m/r)^b - 1].
+
+Multiplying (1) by m gives the exact equivalent condition
+
+    D(H) := mn-mass(H) > P_b(H).                            (3)
+
+If S is the net native rank saving from the admitted mass mn+4, (3) is
+
+    S > 4 + P_b(H).                                        (4)
+
+All new native/recursive children belong in H before evaluating this. Because
+P_b(H)>0 for a nonempty proper-child profile, S must exceed four. Thus at
+least five integer arity units are necessary if arbitrary integer ranks are
+available. In an all-even-rank construction at least six are necessary.
+The mass-only lower bound five is not sufficient for an arbitrary histogram.
+
+For the concrete target H4=1, H2=n²-d, (1) is exactly
+
+    d > n² - n^(2-b) + 2^(1-b).                            (5)
+
+The following are outward enclosures of the right side; each displayed value
+has an upper endpoint less than its displayed value plus 10^-12.
+
+| b | q2 threshold d > | q3 threshold d > | smallest integral d |
+|---|---:|---:|---:|
+| .002 | 2.126005140904 | 2.262845134156 | 3 |
+| .003 | 2.188836306167 | 2.393855465354 | 3 |
+| .005 | 2.314156853774 | 2.655054515082 | 3 |
+
+Consequently the final, fully counted native targets
+
+    q2: H2=33, H4=1, mass70, stock72;
+    q3: H2=61, H4=1, mass126, stock128
+
+pass the native-only test at all three b values. They require six net native
+rank units saved from the admitted words. Alternatively deleting H4 and one
+H2 gives H2=n²-1, again saves six and passes all three native-only tests.
+Deleting H4 alone, or deleting only two H2 while keeping H4, is stock-neutral
+and fails every b>0. No realizable changed word is supplied for any target.
+
+The native room remaining for additional equal-normalization recursive work
+in the first target is the strict budget
+
+    E_b < n - (n²-3)n^(b-1) - (2/n)^(1-b).                 (6)
+
+| b | q2 extra moment budget, lower bound | q3 extra moment budget, lower bound |
+|---|---:|---:|
+| .002 | .146188742447 | .092528373827 |
+| .003 | .135922610712 | .076242210019 |
+| .005 | .115335846876 | .043568833024 |
+
+The exact upper and lower bounds are in `SCREEN.json`. One additional full
+rank-two call exhausts this saving at every target: it returns the mass to
+stock and fails. At q3,b=.005 even one additional full rank-one call fails;
+at q2 all three targets, and q3 at .002/.003, one such rank-one call still
+passes this native test. These are sharply different overhead allowances.
+An E_b contribution from COPY, a helper residual, a source adapter or a
+fallback must be measured in the same units. If the changed construction
+changes stock, widths, bank volumes or owner endpoints, recompute (2) from
+the entire construction instead of applying this allowance.
+
+Fixed-count paid monomial/phase scans do not automatically add a complex
+native child to H. Their ADDRESS/bit routing, arithmetic, precision and
+controller costs still require the actual joint transfer. They are not free
+because the native table has room or because their one-coordinate rank is zero.
+
+## 3. Locate the joint transfer before interpreting a target as κ
+
+The current selected record is PR1094, conditional κ
+`836330098538459/500000000000000000 = .001672660197076918`.
+It retains all-size/compiler, common-label/mutable-source, hosting,
+precision/tape, analytic and BIT H1-H5 hypotheses.
+
+Its retained 47-row balanced outer engine sets, for effective bit saving a,
+complex saving b and free eta>0,
+
+    q=a(1-2 eta), epsilon=(1-eta)/(1+q),
+    κ < epsilon q,
+    (1-beta)b > a,
+
+with the other strict margins checked separately. The limiting ceiling is
+a/(1+a), not a. Thus target κ=K requires a>K/(1-K) within that outer family.
+The exact screens also evaluate the strict-limit planning points
+
+    K=.002: b*=1/499;
+    K=.003: b*=3/997;
+    K=.005: b*=1/199.
+
+At these points both native target profiles above still pass, with dmin=3.
+For H2=n²-3,H4=1 their q2/q3 extra budgets are respectively
+`.146147631822/.092463165713`, `.135829854867/.076095040303`, and
+`.115076756175/.043157504732`. Strict moment slack leaves a neighborhood
+above each b*, but no concrete outer parameters or compatible BIT have been
+admitted here. This is not a κ computation from a primitive b.
+
+The later capped-fusion/fine-prime ledger present on primary main uses the
+different source formula
+
+    κ = floor(F epsilon q)/F - B,
+    0<q<a<min(actual_bit_endpoint, complex_endpoint), 0<epsilon<1,
+
+with stopped-tree, geometry, grouping, precision and other strict margins.
+It can approach the common endpoint under its additional hypotheses; the
+older a/(1+a) loss must not be imposed on that different family. Conversely,
+this later formula is not available merely by choosing epsilon near one.
+
+Exact PR3959 head `babd2e36471422cd3e97f912a5cf2846da52a222` was inspected
+read-only from Git. Its `rank7-pooled-r437-bit/verify.py` specifically computes
+
+    C = min(floor24(complex_lower), floor24(bit_pooled));
+    κ_advertised = C - 10^-46 - 10^-70,
+
+where the bit side binds at
+`434184662772236513171/250000000000000000000000`.
+`screen.py` checks this exact equality against its committed CLAIM. That is
+source-bound author-checked candidate arithmetic, not an independently
+admitted joint theorem here. The source README retains cross-replica owner
+and R437 interfaces; its PR3955 predecessor explicitly says the native,
+controller and outer release were not rerun and the outer ledger pins PR589.
+This screen does not rerun PR3959's role audit, native emission or outer stage.
+
+Relative to that exact advertised candidate number, K=.002/.003/.005 is
+larger by about 15.1584%/72.7376%/187.8960%. Its unchanged BIT endpoint and
+complex endpoint are both below .002. Raising only this caller cannot make
+that unchanged pair reach any of these targets.
+
+In either retained outer family a required common favorable supplier saving
+must be strictly greater than K; at least the native screen at b=K is
+therefore necessary by monotonicity. Fully charged BIT must satisfy its own
+complete volume-weighted moment at that same saving, including progress,
+source/COPY, idles, private fields, adapters, fallbacks and residue envelope.
+The separately owned frozen five-helper construction excludes b>=.002 under
+its named fixed chronology, one-unpaid-coordinate, coverage and full-progress
+stock premises. No positive result from the separate partial-progress BIT
+investigation is assumed. A compatible BIT must escape a named premise and
+also discharge arbitrary dirt, literal integer/Boolean behavior, source and
+helper restoration, integral chronological hosting, contraction, precision,
+storage/tape and native-controller obligations. An unverified endpoint alone
+does not discharge those contracts.
+
+## 4. The coupled final-a cut cannot pay for a deficit with full scans
+
+The newly supplied exact `../coupled-tail-escape/PROOF.md` is preserved as
+`inputs/coupled-tail-PROOF.md`, authenticated at SHA256
+`5b4300fb15364dbdb17974d6d0bb7d387a189ff814fd0293057ea2a47ac58587`;
+the accompanying script and exact witness are authenticated in `SCREEN.json`.
+This source fixes the q2 prefix through event68 at mass66, with H2=33.
+The replacement suffix must act on all six arbitrary incoming banks, with
+any extra arbitrary dirty banks restored. Its outputbank1/inputbank3 block
+is a single Clifford C=WR of B-rank6f, with exact Gaussian selected-native
+adapters. Therefore every row of that coefficient has 2^(6f) nonzeros.
+
+Let R_f be the sum of actual native arities of any replacement, and S_f the
+number of scalar binary ADD/COPY accumulations. Initial coefficient rows on
+all original and dirty inputs have support one. Physical monomials, scalars
+and permutations do not increase the maximum support; a native rank-r child
+multiplies it by at most 2^r and a binary ADD by at most two. Cancellation
+cannot increase it. The required coefficient proves the pointwise inequality
+
+    R_f + S_f >= 6f.                                       (7)
+
+The local source expressly prices each counted ADD as a literal scan of the
+same whole bank with V_f=2^(12f) complex payload records. More generally it
+suffices that each scan touches at least c V_f records for fixed c>0 and
+requires at least one elementary step per touched record. These are explicit
+implementation premises. They give
+
+    T_scan(f) >= c V_f S_f.                                (8)
+
+If R_f <= (6-delta)f for fixed delta>0, (7)-(8) give
+
+    T_scan(f) >= c delta V_f f.
+
+For every fixed lambda<1 this is not O(V_f f^lambda), since after cancelling
+V_f the ratio is at least c delta f^(1-lambda), which diverges. In particular
+it cannot meet O(2^(12f) f^(1-b)) for any b>0. The six-unit saving target
+would require local mass at most4, hence S_f>=2f and scan work at least
+2 V_f f in the source's unit full-scan model.
+
+This argument assumes no payload value, field cardinality or precision
+bound. It only uses a lower bound of one elementary step per visited record.
+Greater precision cannot make that lower bound cheaper. If a claimed upper
+budget is instead O(V_f f^lambda P(f)), the conclusion requires
+P(f)=o(f^(1-lambda)); an unrestricted multiplier may not be dropped. For a
+fixed field/precision, or uniformly subpower P(f), the exclusion follows.
+No substitution of p, overflow/range estimate or practical cutoff is supplied.
+
+The exact retained sources phrase the root layer target as O(V d^lambda')
+with lambda'<1, after their explicit log(p), compact bit, precision and outer
+inequalities. They use f=floor(e/12). At a root active width e comparable to
+d, f is comparable to d, and the lower bound is Omega(Vd). Before absorption,
+the displayed layer estimate includes `(log p)^3`; the same comparison is
+valid whenever the actual complete upper budget is o(Vd), for example when
+that multiplier is subpower in d and the remaining exponent has a fixed gap
+below one. This note does not independently prove the source/precision
+relation for the changed caller. The unconditional statement within (7)-(8)
+is the scan lower bound; its contradiction is against the specified sublinear
+normalized step budget, not against a budget with arbitrary hidden factors.
+
+There is also a useful native/scan dichotomy. Any asserted sublinear full-scan
+budget forces S_f=o(f), so (7) gives R_f>=6f-o(f). Concavity/subadditivity of
+x^(1-b) then makes the limiting best possible equal-volume native moment at
+least
+
+    33 (1/6)^(1-b) + (1/2)^(1-b) > 33/6+1/2 = 6.           (9)
+
+Thus even a single concentrated cleanup child at the support floor cannot
+make the component moment favorable. The exact positive gaps at b=.002,
+.003,.005 are enclosed in `SCREEN.json`. This rules out a favorable completion
+of this fixed current-input cut in the explicit full-bank scan model; it does
+not prove local optimality at mass6 or10, nor a global caller obstruction.
+
+Changing the earlier prefix/cut, input/output gauges, output contract, native
+alphabet, physical volumes, or executing partial/fused scans changes a premise
+of this local gate. Those are mathematical construction obligations, not free
+credits within this proof.
+
+## 5. Evidence and remaining obligations
+
+Replay with
+
+    python3 -B /Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-threshold-screen/screen.py
+
+Every rational power enclosure is certified by exact integer-power
+comparisons on adjacent dyadics: for b=u/v and x=A/B, compare
+`y^v B^u` with `2^(Gv) A^u`. A second finer dyadic grid is checked. Stock
+neutrality and adding the omitted extra rank-two child are rejecting cost
+controls. This is a small finite arithmetic certificate plus written
+all-parameter inequalities (3)-(9), not formal-kernel evidence.
+
+No favorable word is constructed. Construction owners still owe the changed
+complete arbitrary-input caller and selected native lowering. BIT owners owe
+an independent compatible positive supplier. Owner/storage/rounded/machine
+specialists owe chronological whole-family capacity, source windows, exact
+cleanup/range/error, numerical workspace, continuation/backing and physical
+execution costs. The final assembly owner owes a source-bound all-size
+dispatcher and the applicable complete outer inequalities on the actual two
+suppliers. None of these follows from the six-unit native planning target.
+
+Credit: the admitted two-site construction and independent audit retain their
+predecessor attribution; the integer-width recurrence and balanced/capped
+outer lineage remain with their source authors. PR3959 is Rohan Arun's
+author-checked pooled R437 candidate, retaining ai-nanachi, Ali Romman,
+Sagar Thakrar, mightyOil and its complex-side lineage. The new threshold
+calculation and full-scan consequence were prepared with substantial OpenAI
+Codex assistance. No publication action is requested or performed.
diff --git a/research/coupled-tail-support-floor/original/dependencies/4e52d2469b648d73c2af67615116c994b434fdcca2cd0aa573debe98db87324e-MANIFEST.json b/research/coupled-tail-support-floor/original/dependencies/4e52d2469b648d73c2af67615116c994b434fdcca2cd0aa573debe98db87324e-MANIFEST.json
new file mode 100644
index 0000000000..cba1ac036a
--- /dev/null
+++ b/research/coupled-tail-support-floor/original/dependencies/4e52d2469b648d73c2af67615116c994b434fdcca2cd0aa573debe98db87324e-MANIFEST.json
@@ -0,0 +1,178 @@
+{
+  "external_dependencies": [
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/stabilizer-escape/full_stabilizer_bound.py",
+      "sha256": "f073a00ad4831616e873eb110fd33ad7226010a7c2f6cfa6a6b63167bf58ef75"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/free_ops.py",
+      "sha256": "5806fe91b9fda162d5986b12e085b14eb3df9a4703f749f61c1f10363138ca77"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_family.py",
+      "sha256": "88f425d12baf8a4f849cccd24605f21680eb8ce8d199054db4b4e7734eca72b6"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_prefix.py",
+      "sha256": "9ec10cb0243c0c829475ad7290f4953cdff27cb0f90f70b687c4bbee98af676b"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/pivot_plane_probe.py",
+      "sha256": "fcd0a4a0a301c4fddfb8b132894e8b5b751b08cacdb0e5ed41e80b0d4903d499"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py",
+      "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/even_parity_source.py",
+      "sha256": "961f136e4bc1b5da930bdd4ba9bbb594892b9e27f7ab44749d747d4fe16b4cb3"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/lifted_algebra.py",
+      "sha256": "3b9a58a2048a762ab520ac7fdbb28cbfeb7b30345aaeb777d8dabdd9fb1034d9"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py",
+      "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/orthogonal_source_normalizer.py",
+      "sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-chronology/quadratic_charts.py",
+      "sha256": "de2a36f6a6b567360c90477b58da44e2f1b618fd006d058ab1ea04e983952c3f"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/caller-joint/joint_algebra.py",
+      "sha256": "5782033e347c9b10ad47c01ed12a0a52ea07e901fa9e8f7aa9d3a2a928327232"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/caller-joint/joint_prefix.py",
+      "sha256": "a4dcaa1ad05ef8dbba60ddd47b3ad44a3095ebb5fd31f6adfb935a7b1c46a2c7"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/caller-joint/literal_events.py",
+      "sha256": "cb8e0bb5bc0624efbe534df05c9ebb8b2ed3492059886206cea2d83ffec27536"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/caller-joint/validate_recipe_links.py",
+      "sha256": "7457b3672d5a73c584d2073b5d3312e6429fd3f433151f15f8f07da33aa4c59a"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/fusion-audit/MANIFEST.json",
+      "sha256": "75f0679178d18d29891b7de962823ca54b67c15184bfcbf9739896e72fcaa12f"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/fusion-audit/audit_fusions.py",
+      "sha256": "26c35f6d61ad6568da1c650a343b82caea174330ff8054c4cdab1fe183ad2173"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-native/joint_coefficient_gate.py",
+      "sha256": "43bc5229a10e7ed6af3d5bff057c61cfd6d37a222cc0a2eb2e88cbe0ac410d07"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-native/literal_inverse_binding.py",
+      "sha256": "74bdbc9c35db4153e00ed15c8d9df27b63e1c50cd76fcd33f987f3f97d412d96"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json",
+      "sha256": "30d3f569d91304856118796f0c586176d0ad961eff70b09c78fce7532392101f"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/CONTINUED-ISOLATION-Q2.json",
+      "sha256": "d944c5b3181442af3cfd855b6f7d059f6bdfaed35755eff549ee7e96c66c5da7"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/HANDOFF.md",
+      "sha256": "404e01603b99f3e865ce5f7f3fd0a6bd9ca79db4217c105816b7010cc371dbf0"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/INPUT-EVENTS.json",
+      "sha256": "412e126144828455ebfa9d7baafb392e6f8cc5ff956876884451c59545765cfa"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/ISOLATED-FUSION-Q2.json",
+      "sha256": "5ee7878ccd08a1eff40b9bc68e2d0476e501819aea39fda75cbeeadfb9f81d2e"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/ISOLATED-FUSION-Q3.json",
+      "sha256": "4997bab27dda2e20d39209f9002af71c1cee42caa1e69b7a8a2f9eb7f4393fd8"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/MANIFEST.json",
+      "sha256": "44f1e264b3087ab8fdb08b4cd6e27befefbba380852b0119321724b7bc41b5da"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/PROOF.md",
+      "sha256": "2506f7a89239d2375f14a1d7084aaaf11678818d6a20eb81e29de0a66a9f751a"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/admit_fusions.py",
+      "sha256": "15c921045d86fe581725d284b1f9557b4adcdff204951b2e12d0b237b2065b09"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/continue_isolated.py",
+      "sha256": "89551fe31fbf92cdc1167c7a0149b345733abac09da14aa7e482adc3842442a0"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/inputs/REPAIRED-MANIFEST.json",
+      "sha256": "dde942457256b0f037a65eebeb5df822fe4d8911c0441657816c77a4c20c6f1c"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/inputs/REPAIRED-SIMPLIFIED-FUSIONS.json",
+      "sha256": "4491cfe2a1f3e48510b33403b9b50c704865c3b1dc6d659ef5157840654e8fc3"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/isolated_fusion.py",
+      "sha256": "eafc4bd6e0cb0e2136dc9da8454d72ebe2da6f194c7bc62815601ba93d56094e"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/two_site.py",
+      "sha256": "a3d902fd3ad674caf56c532a7a06926395f3b9fa78a74b77f439373603d9e38a"
+    },
+    {
+      "path": "/Users/ross/git/math/integer-mult-bounds/research/kernel92-frame-composition/vendor/pr531/vendor/clifford/clifford_exact.py",
+      "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962"
+    }
+  ],
+  "files": [
+    {
+      "path": "AUDIT.json",
+      "sha256": "e3333eb9c0166a2b66bec2599e8c837a5fd6459e560abcb190c792653bca2ed7"
+    },
+    {
+      "path": "CONTINUATION-REPLAY.json",
+      "sha256": "9894e740599d348a6a9aed4ef8e45cf5b214caa8f77ca9b40388bb252048dd05"
+    },
+    {
+      "path": "HANDOFF.md",
+      "sha256": "2e15f2d03df05ee915ce2d2e4fd25d82f728fa40cb38b589906cd179481acc32"
+    },
+    {
+      "path": "REVIEW.md",
+      "sha256": "418f4124d399955e0873043c55788e59899d6bac468d0aa42e8dfb10734d315b"
+    },
+    {
+      "path": "SOURCE-PINS.json",
+      "sha256": "57a041b947794930ad5406713323111ab488d309ae7fff81ea59d77a7db4f58c"
+    },
+    {
+      "path": "VALIDATION.json",
+      "sha256": "8e571a9a8e59121fa8dbc4090f3b6cb773d91ea9a3951f2a79cfe6776af5b451"
+    },
+    {
+      "path": "audit_two_sites.py",
+      "sha256": "a20cb5bf3577e508e112abe76bf9177a1c3ec7dc397ab74eef37c05de23eb9c9"
+    },
+    {
+      "path": "replay_continuation.py",
+      "sha256": "0ffba268eae17fa0413b1f719d2dbce08af20684f5f2cacd10aca1b8cd2cec95"
+    }
+  ],
+  "no_new_kappa": true,
+  "no_publication": true,
+  "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "status": "FROZEN_INDEPENDENT_TWO_SITE_CORRECTNESS_REVIEW"
+}
diff --git a/research/coupled-tail-support-floor/original/dependencies/e3333eb9c0166a2b66bec2599e8c837a5fd6459e560abcb190c792653bca2ed7-AUDIT.json b/research/coupled-tail-support-floor/original/dependencies/e3333eb9c0166a2b66bec2599e8c837a5fd6459e560abcb190c792653bca2ed7-AUDIT.json
new file mode 100644
index 0000000000..938a06e7af
--- /dev/null
+++ b/research/coupled-tail-support-floor/original/dependencies/e3333eb9c0166a2b66bec2599e8c837a5fd6459e560abcb190c792653bca2ed7-AUDIT.json
@@ -0,0 +1,200 @@
+{
+  "cases": [
+    {
+      "L_R_U_W_ranks_per_f": [
+        4,
+        2,
+        0,
+        2
+      ],
+      "all_original_columns": 6,
+      "all_positive_f": "exact source transport, general Clifford local identity and four scalar residues",
+      "all_used_forward_inverse_recipes": 14,
+      "both_literal_inverse_orders": "PASS_by_complete_primitive_inverse_and_forward_gluing",
+      "complete_endpoint": "diag(F_k J)",
+      "equivalent_positive_control": "opposite whole-field i/-i gauges on U/W preserve the exact local identity",
+      "histogram": {
+        "2": 36,
+        "4": 1
+      },
+      "native_event_links": 74,
+      "native_mass": 76,
+      "negative_controls": [
+        "opposite-direction inverse native pointer",
+        "f2-only phase mutant with f1 unchanged",
+        "omitted first free monomial rejects arbitrary-input correction"
+      ],
+      "phase_vectors": {
+        "L": [
+          0,
+          0,
+          0,
+          0
+        ],
+        "R": [
+          3,
+          0,
+          1,
+          2
+        ],
+        "U": [
+          0,
+          0,
+          0,
+          0
+        ],
+        "W": [
+          3,
+          0,
+          1,
+          2
+        ]
+      },
+      "proof_method": "Independent old X-character bank matrix transport and source all-column replay; emitted general Clifford U/W and selected recipes checked in physical coordinates, no author generator or general tensor algebra imported.",
+      "q": 2,
+      "source_transport_row_and_column": "isolated",
+      "stock": 72
+    },
+    {
+      "L_R_U_W_ranks_per_f": [
+        8,
+        6,
+        0,
+        2
+      ],
+      "all_original_columns": 8,
+      "all_positive_f": "exact source transport, general Clifford local identity and four scalar residues",
+      "all_used_forward_inverse_recipes": 14,
+      "both_literal_inverse_orders": "PASS_by_complete_primitive_inverse_and_forward_gluing",
+      "complete_endpoint": "diag(F_k J)",
+      "equivalent_positive_control": "opposite whole-field i/-i gauges on U/W preserve the exact local identity",
+      "histogram": {
+        "2": 64,
+        "4": 1
+      },
+      "native_event_links": 130,
+      "native_mass": 132,
+      "negative_controls": [
+        "opposite-direction inverse native pointer",
+        "f2-only phase mutant with f1 unchanged",
+        "omitted first free monomial rejects arbitrary-input correction"
+      ],
+      "phase_vectors": {
+        "L": [
+          2,
+          0,
+          2,
+          0
+        ],
+        "R": [
+          1,
+          0,
+          3,
+          2
+        ],
+        "U": [
+          0,
+          0,
+          0,
+          0
+        ],
+        "W": [
+          3,
+          0,
+          1,
+          2
+        ]
+      },
+      "proof_method": "Independent old X-character bank matrix transport and source all-column replay; emitted general Clifford U/W and selected recipes checked in physical coordinates, no author generator or general tensor algebra imported.",
+      "q": 3,
+      "source_transport_row_and_column": "isolated",
+      "stock": 128
+    }
+  ],
+  "exact_source_execution": {
+    "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/stabilizer-escape/full_stabilizer_bound.py": "f073a00ad4831616e873eb110fd33ad7226010a7c2f6cfa6a6b63167bf58ef75",
+    "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/free_ops.py": "5806fe91b9fda162d5986b12e085b14eb3df9a4703f749f61c1f10363138ca77",
+    "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f",
+    "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/even_parity_source.py": "961f136e4bc1b5da930bdd4ba9bbb594892b9e27f7ab44749d747d4fe16b4cb3",
+    "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/lifted_algebra.py": "3b9a58a2048a762ab520ac7fdbb28cbfeb7b30345aaeb777d8dabdd9fb1034d9",
+    "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3",
+    "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/orthogonal_source_normalizer.py": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa",
+    "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/fusion-audit/audit_fusions.py": "26c35f6d61ad6568da1c650a343b82caea174330ff8054c4cdab1fe183ad2173",
+    "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-native/joint_coefficient_gate.py": "43bc5229a10e7ed6af3d5bff057c61cfd6d37a222cc0a2eb2e88cbe0ac410d07",
+    "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-native/literal_inverse_binding.py": "74bdbc9c35db4153e00ed15c8d9df27b63e1c50cd76fcd33f987f3f97d412d96",
+    "/Users/ross/git/math/integer-mult-bounds/research/kernel92-frame-composition/vendor/pr531/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962"
+  },
+  "no_all_q_construction": true,
+  "no_new_kappa": true,
+  "producer_sha256": "a20cb5bf3577e508e112abe76bf9177a1c3ec7dc397ab74eef37c05de23eb9c9",
+  "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "source_loader": "Workspace Python modules executed from the exact bytes hashed in memory, ignoring bytecode caches; historical workspace assertions explicitly active under parent -O.",
+  "source_loader_controls": [
+    "unchecked-hash poisoned bytecode bypassed",
+    "workspace source assertions active",
+    "retained Clifford assertion active"
+  ],
+  "source_pins": [
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/MANIFEST.json",
+      "sha256": "44f1e264b3087ab8fdb08b4cd6e27befefbba380852b0119321724b7bc41b5da"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/HANDOFF.md",
+      "sha256": "404e01603b99f3e865ce5f7f3fd0a6bd9ca79db4217c105816b7010cc371dbf0"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/PROOF.md",
+      "sha256": "2506f7a89239d2375f14a1d7084aaaf11678818d6a20eb81e29de0a66a9f751a"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json",
+      "sha256": "30d3f569d91304856118796f0c586176d0ad961eff70b09c78fce7532392101f"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/admit_fusions.py",
+      "sha256": "15c921045d86fe581725d284b1f9557b4adcdff204951b2e12d0b237b2065b09"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/isolated_fusion.py",
+      "sha256": "eafc4bd6e0cb0e2136dc9da8454d72ebe2da6f194c7bc62815601ba93d56094e"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/continue_isolated.py",
+      "sha256": "89551fe31fbf92cdc1167c7a0149b345733abac09da14aa7e482adc3842442a0"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/ISOLATED-FUSION-Q2.json",
+      "sha256": "5ee7878ccd08a1eff40b9bc68e2d0476e501819aea39fda75cbeeadfb9f81d2e"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/ISOLATED-FUSION-Q3.json",
+      "sha256": "4997bab27dda2e20d39209f9002af71c1cee42caa1e69b7a8a2f9eb7f4393fd8"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/CONTINUED-ISOLATION-Q2.json",
+      "sha256": "d944c5b3181442af3cfd855b6f7d059f6bdfaed35755eff549ee7e96c66c5da7"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/INPUT-EVENTS.json",
+      "sha256": "412e126144828455ebfa9d7baafb392e6f8cc5ff956876884451c59545765cfa"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/inputs/REPAIRED-SIMPLIFIED-FUSIONS.json",
+      "sha256": "4491cfe2a1f3e48510b33403b9b50c704865c3b1dc6d659ef5157840654e8fc3"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/inputs/REPAIRED-MANIFEST.json",
+      "sha256": "dde942457256b0f037a65eebeb5df822fe4d8911c0441657816c77a4c20c6f1c"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/fusion-audit/audit_fusions.py",
+      "sha256": "26c35f6d61ad6568da1c650a343b82caea174330ff8054c4cdab1fe183ad2173"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/fusion-audit/MANIFEST.json",
+      "sha256": "75f0679178d18d29891b7de962823ca54b67c15184bfcbf9739896e72fcaa12f"
+    }
+  ],
+  "status": "PASS_INDEPENDENT_TWO_SITE_TRANSPORT_LITERAL_PHASE_AND_NATIVE_ADMISSION"
+}
diff --git a/research/coupled-tail-support-floor/original/dependencies/e90d8163c1e5c9797534dd3ed7d6279d1095ff001d84b20dd5c33f8d70d68c6c-MANIFEST.json b/research/coupled-tail-support-floor/original/dependencies/e90d8163c1e5c9797534dd3ed7d6279d1095ff001d84b20dd5c33f8d70d68c6c-MANIFEST.json
new file mode 100644
index 0000000000..6c1fe14043
--- /dev/null
+++ b/research/coupled-tail-support-floor/original/dependencies/e90d8163c1e5c9797534dd3ed7d6279d1095ff001d84b20dd5c33f8d70d68c6c-MANIFEST.json
@@ -0,0 +1,13 @@
+{
+  "created_utc": "2026-10-19T14:49:27.812446+00:00",
+  "files": {
+    "HANDOFF.md": "9466b6d2c04f2808753fa3d424f1b5ddaca108e057fcbc8a6dd16688e17f39d7",
+    "PROOF.md": "0eb564effb343e2a20af79445b6a319b719621965b2dc82a303bc6541e34d232",
+    "SCREEN.json": "bf87a8facad36ac76958b30e7d6d135173841dfcaf96d2c7947943f96b54ae2d",
+    "VALIDATION.json": "1af7193661e01853569668f42d82258879b2727896207c64345f71ed2c59dbb4",
+    "inputs/coupled-tail-PROOF.md": "5b4300fb15364dbdb17974d6d0bb7d387a189ff814fd0293057ea2a47ac58587",
+    "screen.py": "dbedee019ecbbe1f1faf062f724135b7224e52be5bb5beb4079e1850c9823b90"
+  },
+  "no_new_kappa": true,
+  "status": "FROZEN_LOCAL_PLANNING_AND_CONDITIONAL_GATE"
+}
diff --git a/research/coupled-tail-support-floor/original/dependencies/ef3697eece91ee6d52ae3f5e88b95028091829d6961118052dff1e25df212ba3-MANIFEST.json b/research/coupled-tail-support-floor/original/dependencies/ef3697eece91ee6d52ae3f5e88b95028091829d6961118052dff1e25df212ba3-MANIFEST.json
new file mode 100644
index 0000000000..20c54d169b
--- /dev/null
+++ b/research/coupled-tail-support-floor/original/dependencies/ef3697eece91ee6d52ae3f5e88b95028091829d6961118052dff1e25df212ba3-MANIFEST.json
@@ -0,0 +1,64 @@
+{
+  "files": [
+    {
+      "bytes": 15060,
+      "path": "AUDIT.json",
+      "sha256": "a2f98dc08085c0fb66e50ce4fb96fba271d4089a8308fca182b0c1668046ad3a"
+    },
+    {
+      "bytes": 3428,
+      "path": "HANDOFF.md",
+      "sha256": "69a8db3dd0c7ece9329e52622deb589b0ad8344b29099f90de5ecd282c49e118"
+    },
+    {
+      "bytes": 2271466,
+      "path": "PAIRING-AUDIT.json",
+      "sha256": "e40ad925d1cf4e46bf28f176d74de6d393bddf6d82300757e88734b6e2944912"
+    },
+    {
+      "bytes": 10929,
+      "path": "REVIEW.md",
+      "sha256": "c034f3fda71e440978c3a589da95f1f37cb95b44bf996c5295f179e6ed2fefe1"
+    },
+    {
+      "bytes": 19701,
+      "path": "SOURCE-PINS.json",
+      "sha256": "3ae658408161bb6c79c81e153c1172e935156d94551c479cd9ccf03ac53d889a"
+    },
+    {
+      "bytes": 5908,
+      "path": "SOURCE-REPLAYS.json",
+      "sha256": "35a37b41cc4ca0199523389453d04130a52705756819f40002e85031421a3591"
+    },
+    {
+      "bytes": 996,
+      "path": "VALIDATION.json",
+      "sha256": "5ab4351bf0840bddeae085a9322a518af9cf21fee375f564480c449e704cafca"
+    },
+    {
+      "bytes": 17680,
+      "path": "audit_gates.py",
+      "sha256": "051ba51e02e9f143b8a8bea0b91d69e7e1e32edf0f98d2d40db290f02043d460"
+    },
+    {
+      "bytes": 9267,
+      "path": "pairing_audit.py",
+      "sha256": "f567f9239431d60c915d6bf8ca23c9e74f932a1b08ddb7980a82ba1a855c21dc"
+    },
+    {
+      "bytes": 2572,
+      "path": "replay_sources.py",
+      "sha256": "a9a5d147b97afca170c49ad71a7cbc061853d0aff7ec5db5a61b7288f56b72aa"
+    },
+    {
+      "bytes": 943,
+      "path": "validate_review.py",
+      "sha256": "8e9eb49b74d9241de8bdaf81c446cdec5da28a6d18f938ef723f3316e0a7b021"
+    }
+  ],
+  "no_new_kappa": true,
+  "scientific_main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "scope": "Independent completed-gate review: fixed-two-site conditional all-q skew implication; finite-q general-frame trajectory and crossed stock certificates; cubic whole-field quadratic trace gate.",
+  "source_count": 74,
+  "source_pin_file": "SOURCE-PINS.json"
+}
diff --git a/research/coupled-tail-support-floor/original/joint-native/joint_coefficient_gate.py b/research/coupled-tail-support-floor/original/joint-native/joint_coefficient_gate.py
new file mode 100644
index 0000000000..aa289b7c60
--- /dev/null
+++ b/research/coupled-tail-support-floor/original/joint-native/joint_coefficient_gate.py
@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""A single original-column coefficient constrains the unfactored J cleanup.
+
+Apache-2.0; substantial OpenAI Codex assistance. This is a scoped exact
+coefficient/support gate, not a complete supplier or a new exponent.
+"""
+from pathlib import Path
+from fractions import Fraction
+import argparse
+import hashlib
+import importlib.util
+import json
+import sys
+
+sys.dont_write_bytecode = True
+HERE = Path(__file__).resolve().parent
+FROZEN = HERE.parents[1] / 'kappa-four-coordinate-20261019T0717Z'
+NATIVE = FROZEN / 'native-frames'
+PINS = {
+    NATIVE / 'native_model.py': '6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3',
+    NATIVE / 'even_parity_source.py': '961f136e4bc1b5da930bdd4ba9bbb594892b9e27f7ab44749d747d4fe16b4cb3',
+    NATIVE / 'EVEN-PARITY-SOURCE.json': 'dbeea9cb1abe6fff72cc98e98d9f70eed578d5094cf5f310ed7c500e26af3f3c',
+    FROZEN / 'caller' / 'free_ops.py': '5806fe91b9fda162d5986b12e085b14eb3df9a4703f749f61c1f10363138ca77',
+}
+for path, digest in PINS.items():
+    if hashlib.sha256(path.read_bytes()).hexdigest() != digest:
+        raise ValueError('frozen source pin differs: ' + str(path))
+sys.path.insert(0, str(NATIVE))
+from native_model import Model, PIN, b, ce, mul, need, phase, same
+from even_parity_source import kernels
+from lifted_algebra import Algebra
+
+spec = importlib.util.spec_from_file_location('joint_gate_free_ops', FROZEN / 'caller' / 'free_ops.py')
+f = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(f)
+
+
+def formal_core():
+    """Independent inverse formula over arbitrary noncommuting Q1/B2."""
+    Q, B2 = f.mono((1,)), f.mono((2,))
+    Qi, Bi = f.inv(Q), f.inv(B2)
+    K = [[f.add(f.add(B2, Q), f.neg(f.I)), f.add(f.I, f.neg(B2))],
+         [f.add(Q, f.neg(f.I)), f.I]]
+    Kinv = [[f.prod(Qi, Bi), f.prod(Qi, f.add(f.I, f.neg(Bi)))],
+            [f.prod(f.add(Qi, f.neg(f.I)), Bi),
+             f.add(Qi, f.prod(f.add(f.I, f.neg(Qi)), Bi))]]
+    need(f.mm(K, Kinv) == f.mm(Kinv, K) == f.eye(2),
+         'independent arbitrary-Q1/B2 core inverse both orders')
+
+    # Four public inputs and two arbitrary pivot inputs. Public coupling L
+    # has eight independent noncommuting coefficients; it is not set zero.
+    n, p = 6, 4
+    Du, Dv = f.mono((3,)), f.mono((4,))
+    H = [[f.mul(Du, x) for x in K[1]], [f.mul(Dv, x) for x in K[0]]]
+    Hinv = f.mm(Kinv, [[f.Z, f.inv(Dv)], [f.inv(Du), f.Z]])
+    need(f.mm(H, Hinv) == f.mm(Hinv, H) == f.eye(2), 'whole pivot inverse')
+    L = [[f.mono((10 + 4 * i + j,)) for j in range(p)] for i in range(2)]
+    M = f.eye(n)
+    for i in range(p):
+        M[i][i] = f.N
+    for i in range(2):
+        M[p + i] = L[i] + H[i]
+    W = f.eye(n)
+    for i in range(2):
+        for j in range(p):
+            W[p + i][j] = f.neg(f.prod(f.N, f.summ(f.mul(Hinv[i][k], L[k][j])
+                                                              for k in range(2)), f.inv(f.N)))
+        for j in range(2):
+            W[p + i][p + j] = f.prod(f.N, Hinv[i][j])
+    target = [[f.N if i == j else f.Z for j in range(n)] for i in range(n)]
+    need(f.mm(W, M) == target, 'joint correction all six original columns including public L')
+    Minv = f.eye(n)
+    for i in range(p):
+        Minv[i][i] = f.inv(f.N)
+    for i in range(2):
+        for j in range(p):
+            Minv[p + i][j] = f.neg(f.prod(f.summ(f.mul(Hinv[i][k], L[k][j])
+                                                      for k in range(2)), f.inv(f.N)))
+        for j in range(2):
+            Minv[p + i][p + j] = Hinv[i][j]
+    need(f.mm(M, Minv) == f.mm(Minv, M) == f.eye(n), 'full prefix inverse with all coupling')
+    coefficient = f.prod(f.N, Qi, Bi, f.inv(Dv))
+    need(W[p][p + 1] == coefficient, 'single current V to original t coefficient independent of L')
+    mutant = [row[:] for row in W]
+    mutant[p][p + 1] = f.prod(f.N, Bi, Qi, f.inv(Dv))
+    need(f.mm(mutant, M) != target, 'reversed Schur inverse order defect rejected')
+    return {
+        'independent_original_columns': n,
+        'independent_public_coupling_coefficients': 8,
+        'K': f.sm(K), 'K_inverse': f.sm(Kinv),
+        'H_row_order': ['Du * K_row2', 'Dv * K_row1'],
+        'required_retarded_coefficient': 'J Q1^-1 B2^-1 Dv^-1',
+        'coefficient_free_word': f.serial(coefficient),
+        'public_L_cannot_change_coefficient': True,
+        'defect_control': 'reverse Q1^-1 and B2^-1, rejected on original columns',
+    }
+
+
+def operators(q, fsize):
+    z = Model(fsize, 2 * q + 1)
+    _, J = kernels(z)
+    A = mul(z.N.adjoint(), J)
+    B1, B2 = mul(z.P[0], A), mul(z.P[1], A)
+    Q1 = mul(J.adjoint(), B1, J)
+    Dv = z.I
+    for r in range(2, q + 1):
+        Dv = mul(z.P[2 * r], z.N, Dv)
+    Dv = mul(phase(z.n, 2 * (q - 2)), Dv)
+    F = z.prefix(2 * q + 1)
+    C = mul(F, J, Q1.adjoint(), B2.adjoint(), Dv.adjoint(), F.adjoint())
+    collapsed = mul(F, A.adjoint(), z.P[0].adjoint(), z.N,
+                    z.P[1].adjoint(), Dv.adjoint(), F.adjoint())
+    return z, J, A, B1, B2, Q1, Dv, F, C, collapsed
+
+
+def expected_gamma(q, fsize):
+    n = (4 * q + 4) * fsize
+    rows = [0] * n
+    for half in (0, 1):
+        for bit in range(fsize):
+            ix = lambda plane: (2 * plane + half) * fsize + bit
+            x, y = ix(0), ix(1)
+            rows[x] = (1 << x) | (1 << y)
+            rows[y] = 1 << x
+            for plane in [2] + list(range(5, 2 * q + 2, 2)):
+                rows[ix(plane)] = 1 << ix(plane)
+    return tuple(rows)
+
+
+def left_gamma(op):
+    # U has binary form S(Gamma) P. Recover Gamma=B P^-1 independently.
+    n = op.n
+    acols = tuple(x for x, zz, ph in op.tab[:n])
+    need(all(zz == 0 and x.bit_count() == 1 for x, zz, ph in op.tab[:n]),
+         'actual coefficient X image is a coordinate permutation')
+    arows = ce.transpose(acols, n)
+    ainv_cols = ce.transpose(ce.inv(arows, n), n)
+    bcols = tuple(x for x, zz, ph in op.tab[n:])
+    def apply_cols(cols, word):
+        out = 0
+        while word:
+            bit = word & -word
+            out ^= cols[bit.bit_length() - 1]
+            word ^= bit
+        return out
+    gamma_cols = tuple(apply_cols(bcols, x) for x in ainv_cols)
+    return ce.transpose(gamma_cols, n)
+
+
+def all_f_phase(q, C1):
+    a = Algebra(2 * q + 1)
+    _, j1 = kernels(a.model)
+    J = a.lift(j1, exponent=1)
+    A = a.product(a.adjoint(a.N), J)
+    B1, B2 = a.product(a.P[0], A), a.product(a.P[1], A)
+    Q1 = a.product(a.product(a.adjoint(J), B1), J)
+    Dv = a.one
+    for r in range(2, q + 1):
+        Dv = a.product(a.product(a.P[2 * r], a.N), Dv)
+    Dv = a.scale(Dv, (-1) ** (q - 2))
+    F = a.one
+    for t in a.T:
+        F = a.product(F, t)
+    C = F
+    for x in (J, a.adjoint(Q1), a.adjoint(B2), a.adjoint(Dv), a.adjoint(F)):
+        C = a.product(C, x)
+    exponent = 6 - 3 * q
+    need(C == a.lift(C1, exponent=exponent), 'complete all-f Gaussian tensor phase, all four residues')
+    return {'q': q, 'tensor_phase_exponent': exponent,
+            'identity': 'C_f=i^((6-3q)*(1-f)) C_1^tensor(f), after bit regrouping',
+            'all_four_f_mod4_residues': 'PASS'}
+
+
+def run():
+    core = formal_core()
+    rank_checks, row_checks, phase_checks = [], [], []
+    for q in range(2, 13):
+        for fs in (1, 2):
+            z, J, A, B1, B2, Q1, Dv, F, C, collapsed = operators(q, fs)
+            gamma = left_gamma(C)
+            need(gamma == expected_gamma(q, fs), 'exact all-q block-diagonal left Gamma formula')
+            need(b.native_rank(C) == (2 * q + 4) * fs,
+                 'unfactored original-column coefficient native arity')
+            need(C.tab == collapsed.tab, 'actual collapsed signed tableau')
+            if fs == 1 and q in (2, 3, 4):
+                same(C, collapsed, 'exact core collapse with mandatory global phases')
+                state, depth = b.sparse_column(C.adjoint())
+                need(len(state) == 1 << ((2 * q + 4) * fs), 'actual row support including all cancellations')
+                row_checks.append({'q': q, 'f': fs, 'row_nonzeros': len(state), 'Gaussian_depth': depth})
+                phase_checks.append(all_f_phase(q, C))
+            rank_checks.append({'q': q, 'f': fs, 'native_arity': b.native_rank(C),
+                                'native_margin_per_f': 2 * q,
+                                'Gamma_formula': 'two copies of [[1,1],[1,0]] on(0,1), plus diagonal2 andodd5..2q+1'})
+    return {
+        'status': 'PASS_UNFACTORED_JOINT_J_COEFFICIENT_SUPPORT_GATE',
+        'scientific_pin': PIN,
+        'producer_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+        'source_pins': [{'path': str(p), 'sha256': hashlib.sha256(p.read_bytes()).hexdigest()}
+                        for p in list(PINS) + [NATIVE / 'lifted_algebra.py']],
+        'formal_original_column_core': core,
+        'physical_coefficient': 'C_tV=F J Q1^-1 B2^-1 Dv^-1 F^-1, Q1=J^-1B1J, B_s=P_s N^-1J',
+        'exact_collapsed_operator': 'F (N^-1J)^-1 P1^-1 N P2^-1 Dv^-1 F^-1',
+        'Dv': '(-1)^(q-2) (P_(2q+1)N)...(P5N)',
+        'target_gauge': 'The actual isolated output on original t is F J t. Its outgoing left monomial gauge preserves the support bound. No arbitrary replacement of its input right gauge or desired target operator is made.',
+        'all_q_native_arity': '(2q+4)f for q>=2,f>=1',
+        'rank_checks': rank_checks,
+        'actual_row_support_checks': row_checks,
+        'all_f_phase_checks': phase_checks,
+        'support_tariff': 'For the complete bank-by-address linear tail, let r_j be each native query actual arity and S the number of binary bank-ADD primitives. Then sum_j r_j+S >= (2q+4)f. Monomial ADDRESS/bank routing, nonzero Gaussian pointwise scales and phases have row branching1; each ADD has branching<=2; a rank-r native Fourier child with monomial adapters has branching2^r. Arbitrary cancellations and extra dirty/restored banks cannot increase the upper bound.',
+        'bounded_word_corollary': 'If sum r_j=R*f and S=o(f), then R>=2q+4 asymptotically. In particular R<2q cannot provide positive native deficit in such a tail. This is an explicit model premise, not an assertion that bounded-in-f scans are a repository default.',
+        'growing_scan_requirement': 'If R<2q, S >= (2q+4-R)f >4f. A paid O(f) full/partial scan construction is not excluded by this combinatorial gate. Its outer-transfer allowance belongs to the root source-bound scan audit.',
+        'extra_dirty_banks': 'Any number of independent additional dirty banks may be used and restored exactly. The full required inverse is unique on all inputs, so its original-V/current-bank coefficient remains C_tV. Initial/final zero private cells do not improve the maximum-row-support induction either.',
+        'limits': ['The full actual all-q physical prefix and source-bound H/L binding are owned by the caller lane and are not inferred from the homogeneous factory formulas alone.',
+                   'A changed initial core, right input chart/target operator, coupled owner endpoint, nonlinear computation or scan alphabet outside the stated row-branching model is not covered.',
+                   'Any operator-valued ADD with multiple monomial terms must expose those primitive ADDs or charge its actual row branching; it is not a free scalar ADD.',
+                   'No kappa, all-size supplier, owner allocation, precision or fixed-tape claim is made.'],
+        'no_new_kappa': True,
+    }
+
+
+if __name__ == '__main__':
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--write', action='store_true')
+    args = ap.parse_args()
+    out = json.loads(json.dumps(run()))
+    path = HERE / 'JOINT-COEFFICIENT-GATE.json'
+    if args.write:
+        path.write_text(json.dumps(out, indent=2, sort_keys=True) + '\n')
+    else:
+        need(json.loads(path.read_text()) == out, 'saved joint coefficient gate differs')
+    print(out['status'])
+    print('native arity (2q+4)f; exact support tariff sum(r_j)+S >= (2q+4)f')
diff --git a/research/coupled-tail-support-floor/original/native-frames/native_model.py b/research/coupled-tail-support-floor/original/native-frames/native_model.py
new file mode 100644
index 0000000000..03925dd36e
--- /dev/null
+++ b/research/coupled-tail-support-floor/original/native-frames/native_model.py
@@ -0,0 +1,67 @@
+"""Pinned Gaussian Clifford model for common2/fresh2 native bridges.
+Apache-2.0; substantial OpenAI Codex assistance. Frozen imports are read only.
+"""
+from pathlib import Path
+import hashlib,importlib.util,sys
+sys.dont_write_bytecode=True
+BASE=Path('/Users/ross/git/math')
+PIN='20ecf2891d80b5acf18d980b2164fb44ea7faa90'
+CE_PATH=BASE/'integer-mult-bounds/research/kernel92-frame-composition/vendor/pr531/vendor/clifford/clifford_exact.py'
+CE_SHA='2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962'
+BOUND_PATH=BASE/'.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/stabilizer-escape/full_stabilizer_bound.py'
+BOUND_SHA='f073a00ad4831616e873eb110fd33ad7226010a7c2f6cfa6a6b63167bf58ef75'
+def need(ok,why):
+ if not ok:raise ValueError(why)
+def load(name,path,sha):
+ need(hashlib.sha256(path.read_bytes()).hexdigest()==sha,'source pin '+str(path))
+ spec=importlib.util.spec_from_file_location(name,path);mod=importlib.util.module_from_spec(spec);sys.modules[name]=mod;spec.loader.exec_module(mod);return mod
+ce=load('native_frames_pinned_clifford',CE_PATH,CE_SHA)
+b=load('native_frames_frozen_independent',BOUND_PATH,BOUND_SHA)
+def mul(*ops):return b.standard_product(ce,*ops)
+def same(a,c,why,phase=True):
+ need(a.tab==c.tab,why+' signed tableau')
+ if phase:need(b.sparse_column(a)==b.sparse_column(c),why+' actual Gaussian phase')
+def phase(n,p):return ce.Op(n,ce.identity(n),[('phase',p%4)])
+def symplectic_defect_rank(op):
+ return b.binary_rank(x^y for x,y in zip(b.binary_tableau(op),b.binary_tableau(ce.ident(op.n))))
+def pauli(n,x=0,z=0,p=0):
+ out=ce.diag(n,[0]*n,[2*((z>>j)&1)for j in range(n)])
+ return mul(phase(n,p),ce.xgate(n,x),out)
+def conjugated_pauli(op,x=0,z=0,p=0):
+ triple=ce.apply(op.tab,(x,z,p));return pauli(op.n,*triple),triple
+class Model:
+ def __init__(self,f=1,stages=4):
+  need(f>=1 and stages>=1,'positive chunk/stages');self.f=f;self.stages=stages;self.n=(2+2*stages)*f;self.I=ce.ident(self.n)
+  self.N=self.Npair(0,1);self.U=self.Hp(0);self.V=mul(self.N,self.U.adjoint())
+  self.P=[self.swap_pair(s+1)for s in range(stages)];self.T=[self.Npair(2+2*s,3+2*s)for s in range(stages)]
+  self.Q=ce.xgate(self.n,1)
+ def Hp(self,chunk):
+  out=self.I
+  for j in range(self.f):
+   bit=chunk*self.f+j;alpha=[0]*self.n;alpha[bit]=2
+   out=mul(ce.diag(self.n,[0]*self.n,alpha),ce.cgate(self.n,1<<bit).adjoint(),out)
+  return out
+ def Hq(self,chunk):
+  out=self.I
+  for j in range(self.f):
+   bit=chunk*self.f+j;alpha=[0]*self.n;alpha[bit]=2
+   out=mul(ce.diag(self.n,[0]*self.n,alpha),ce.cgate(self.n,1<<bit),out)
+  return out
+ def Npair(self,p,q):return mul(phase(self.n,1),self.Hp(p),self.Hq(q))
+ def swap_pair(self,s):
+  rows=[1<<j for j in range(self.n)]
+  for k in range(2*self.f):rows[k],rows[2*s*self.f+k]=rows[2*s*self.f+k],rows[k]
+  return ce.perm(self.n,rows)
+ def prefix(self,s):return mul(self.I,*self.T[:s])
+ def phi(self,a):return mul(self.N.adjoint(),a,self.N)
+ def tau(self,a):return mul(self.U,a,self.U.adjoint())
+ def upsilon(self,a):return mul(self.V,a,self.V.adjoint())
+ def pqqp(self):
+  need(self.stages>=4,'pqqp uses4 stages');gs=[self.I,self.I];controls=[];F=self.I
+  for s,(kind,W) in enumerate(zip('FGFG',[self.U,self.V,self.V,self.U])):
+   required=self.phi(gs[1])if kind=='F'else mul(W,self.N.adjoint(),gs[1],self.N,W.adjoint())
+   L=mul(required,gs[0].adjoint());controls.append(L);gs[0]=required
+   if kind=='F':gs=[gs[0],mul(W,self.P[s],gs[1],W.adjoint())]
+   else:gs=[mul(W.adjoint(),gs[0],W),mul(self.P[s],gs[1])]
+   F=mul(self.T[s],F)
+  return gs,controls
diff --git a/research/coupled-tail-support-floor/source/caller-joint/joint_algebra.py b/research/coupled-tail-support-floor/source/caller-joint/joint_algebra.py
new file mode 100644
index 0000000000..d73e3b0ce0
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/caller-joint/joint_algebra.py
@@ -0,0 +1,113 @@
+"""Pinned exact all-f Gaussian X-character operator algebra.
+Apache-2.0; substantial OpenAI Codex assistance.
+"""
+from pathlib import Path
+from fractions import Fraction as F
+import hashlib,importlib.util,sys
+sys.dont_write_bytecode=True
+OLD=Path(__file__).resolve().parents[1]
+PINS={
+ 'root-chronology/quadratic_charts.py':'de2a36f6a6b567360c90477b58da44e2f1b618fd006d058ab1ea04e983952c3f',
+ 'native-frames/native_model.py':'b4291b2868f91f6e77058e58e936b2efe965a9d9ae58095745fa2dad8c1d5c68',
+ 'native-frames/even_parity_source.py':'961f136e4bc1b5da930bdd4ba9bbb594892b9e27f7ab44749d747d4fe16b4cb3',
+ 'caller/nested_prefix.py':'9ec10cb0243c0c829475ad7290f4953cdff27cb0f90f70b687c4bbee98af676b',
+ 'caller/nested_family.py':'88f425d12baf8a4f849cccd24605f21680eb8ce8d199054db4b4e7734eca72b6',
+}
+def need(c,m):
+ if not c:raise ValueError(m)
+for p,h in PINS.items():need(hashlib.sha256((OLD/p).read_bytes()).hexdigest()==h,'frozen source pin '+p)
+spec=importlib.util.spec_from_file_location('joint_pinned_quadratic',OLD/'root-chronology/quadratic_charts.py')
+qc=importlib.util.module_from_spec(spec);sys.modules[spec.name]=qc;spec.loader.exec_module(qc)
+sys.path.insert(0,str(OLD/'caller'));sys.path.insert(0,str(OLD/'native-frames'))
+from nested_prefix import skeleton
+from nested_family import retraction
+from native_model import Model,ce,mul,same
+from even_parity_source import kernels
+
+ZERO=(F(0),)*8;ONE=(F(1),F(0))*4
+def rotate(v,c,g):
+ out=[]
+ for r in range(4):
+  a,b=v[2*r:2*r+2];out.extend(((a,b),(-b,a),(-a,-b),(b,-a))[(c*r+g)%4])
+ return tuple(out)
+def cproduct(a,b):
+ return tuple(z for r in range(4)for z in(a[2*r]*b[2*r]-a[2*r+1]*b[2*r+1],a[2*r]*b[2*r+1]+a[2*r+1]*b[2*r]))
+def normalize(g,v):
+ return qc.Mono(g.rows,g.offset,g.alpha,g.quad),rotate(v,g.constant,g.global_phase)
+def mono(g,c=1):
+ k,v=normalize(g,tuple(F(c)*x for x in ONE));return{k:v}if any(v)else{}
+def add(a,b):
+ out=dict(a)
+ for k,v in b.items():
+  w=tuple(x+y for x,y in zip(out.get(k,ZERO),v))
+  if any(w):out[k]=w
+  else:out.pop(k,None)
+ return out
+def scale(a,c):return{k:tuple(F(c)*x for x in v)for k,v in a.items()}if c else{}
+def product(a,b):
+ out={}
+ for g,x in a.items():
+  for h,y in b.items():
+   k,v=normalize(g@h,cproduct(x,y));out=add(out,{k:v})
+ return out
+def adjoint(a):
+ out={}
+ for g,v in a.items():
+  k,w=normalize(g.inv(),tuple(x if i%2==0 else-x for i,x in enumerate(v)));out=add(out,{k:w})
+ return out
+def summ(items):
+ out={}
+ for item in items:out=add(out,item)
+ return out
+def eye(n,m):
+ I=mono(qc.identity(m));return[[dict(I)if i==j else{}for j in range(n)]for i in range(n)]
+def mm(A,B):
+ n=len(A);return[[summ(product(A[i][k],B[k][j])for k in range(n)if A[i][k]and B[k][j])for j in range(n)]for i in range(n)]
+def serial(e):return[{'x_monomial':g.data(),'coefficients_by_f_mod4':[[str(v[2*r]),str(v[2*r+1])]for r in range(4)]}for g,v in sorted(e.items(),key=lambda x:str(x[0]))]
+def sm(M):return[[serial(e)for e in row]for row in M]
+def n_pair(m,i):
+ return qc.old_operator({'operator':{'native_blocks':[i],'block_permutation':list(range(m//2)),'sign':1}},m)
+def plane_swap(m,i,j):
+ rows=[1<<k for k in range(m)]
+ for d in(0,1):rows[2*i+d],rows[2*j+d]=rows[2*j+d],rows[2*i+d]
+ return qc.Mono(tuple(rows),0,(0,)*m,(0,)*m)
+def j_operator(m):
+ return qc.from_function(qc.identity(m).rows,3,lambda x:1+qc.parity(x&5)+qc.parity(x&10),1)
+def prefix(m,s):
+ out=qc.identity(m)
+ for i in range(1,s+1):out=n_pair(m,i)@out
+ return out
+
+class Word:
+ def __init__(self,n,m):self.n=n;self.m=m;self.M=eye(n,m);self.Mi=eye(n,m);self.events=[]
+ def add(self,d,s,c=1,label=''):
+  if not c:return
+  need(d!=s,'ADD distinct banks')
+  self.M[d]=[add(x,scale(y,c))for x,y in zip(self.M[d],self.M[s])]
+  for row in self.Mi:row[s]=add(row[s],scale(row[d],-c))
+  self.events.append({'kind':'ADD','dst':d,'src':s,'coefficient':str(c),'label':label})
+ def unary(self,b,g,label='',native=False,family=None):
+  G,Gi=mono(g),mono(g.inv())
+  self.M[b]=[product(G,x)for x in self.M[b]]
+  for row in self.Mi:row[b]=product(row[b],Gi)
+  self.events.append({'kind':'NATIVE'if native else'ADDRESS_OR_UNIT','bank':b,'x_monomial':g.data(),
+                      'rank_per_f':qc.rank(g.polar()),'label':label,'native_family':family})
+ def swap(self,i,j,label=''):
+  self.M[i],self.M[j]=self.M[j],self.M[i]
+  for row in self.Mi:row[i],row[j]=row[j],row[i]
+  self.events.append({'kind':'BANK_SWAP','banks':[i,j],'label':label})
+ def inverse_events(self):
+  out=[]
+  for e in reversed(self.events):
+   d=dict(e)
+   if e['kind']=='ADD':d['coefficient']=str(-F(e['coefficient']))
+   elif e['kind']!='BANK_SWAP':d['x_monomial']=qc.decode(e,self.m).inv().data()
+   if e['kind']not in('ADD','BANK_SWAP')and'one_coordinate_literal_circuit'in e:
+    literal=ce.Op(self.m,tuple(tuple(t)for t in e['one_coordinate_tableau']),e['one_coordinate_literal_circuit']).adjoint()
+    d['one_coordinate_literal_circuit']=literal.circuit;d['one_coordinate_tableau']=[list(t)for t in literal.tab]
+    d['phase_exponent']=-e['phase_exponent']
+    if e.get('native_family'):
+     d['native_family']=dict(e['native_family']);d['native_family']['inverse']=not e['native_family'].get('inverse',False)
+     key=e['native_recipe_id'];d['native_recipe_id']=key[:-3]if key.endswith('inv')else key+'inv'
+   out.append(d)
+  return out
diff --git a/research/coupled-tail-support-floor/source/caller-joint/joint_prefix.py b/research/coupled-tail-support-floor/source/caller-joint/joint_prefix.py
new file mode 100644
index 0000000000..d50b52134a
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/caller-joint/joint_prefix.py
@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""Literal all-q phase-correct J prefix with diagonal pivot continuation.
+Apache-2.0; substantial OpenAI Codex assistance. No cleanup saving claimed.
+"""
+from pathlib import Path
+from collections import Counter
+from functools import lru_cache
+import argparse,hashlib,json
+from joint_algebra import *
+HERE=Path(__file__).resolve().parent
+
+def build(q,omit_raw_a_restore=False,continue_wrong_carrier=False):
+ need(q>=2,'at least two public pairs')
+ n,k,m=2*q+2,2*q+1,4*q+4
+ W=Word(n,m);N=n_pair(m,0);J=j_operator(m);stage=0
+ def query(bank,s,inverse=False,label=''):
+  f=prefix(m,s);g=f@J@f.inv()
+  if inverse:g=g.inv()
+  need(qc.rank(g.polar())==2,'source J query has native rank2 per coordinate')
+  W.unary(bank,g,label,True,{'kind':'J','completed':s,'inverse':inverse})
+ def source_swap(bank,s,label):W.unary(bank,plane_swap(m,0,s),label)
+ def progress(src,s,dst=None):
+  for bank in range(n):
+   if bank!=src:W.unary(bank,n_pair(m,s),f'query{s} target fresh'if bank==dst else f'query{s} idle fresh',True,{'kind':'N','plane':s,'inverse':False})
+ for r in range(2,q+1):W.add(2*r+1,3,1,'raw c basis')
+ query(1,0,label='shared initial J exposure');W.add(2,1,1,'shared initial J fanout');query(1,0,True,'shared initial J inverse')
+ _,ops=skeleton(q,[1]+[0]*(q-1))
+ for typ,d,s,z in ops:
+  if typ=='a':
+   if z[1]:need(stage==0 and d==2 and s==1 and z[1]==1,'only initial J-valued bridge is shared')
+   else:W.add(d,s,z[0],'initial nested scalar bridge')
+  elif typ=='s':W.swap(d,s,'initial nested permutation')
+  else:
+   stage+=1;u=retraction(q,stage)
+   if stage==4:
+    for bank,(aa,bb)in enumerate(u):
+     if bank!=s:W.add(bank,s,-aa,'query4 scalar entrance')
+    break
+   for bank,(aa,bb)in enumerate(u):
+    if bank!=s:W.add(bank,s,-aa,f'query{stage} scalar entrance')
+   query(s,stage-1,label=f'query{stage} source J')
+   for bank,(aa,bb)in enumerate(u):
+    if bank!=s:W.add(bank,s,-bb,f'query{stage} source pre-delivery fanout')
+   W.add(d,s,1,f'query{stage} delivery')
+   source_swap(s,stage,f'query{stage} source swap');progress(s,stage,d)
+   if stage==3:
+    for bank,(aa,bb)in enumerate(u):
+     if bank!=s:W.add(bank,s,-bb,'query3 source pre-continuation fanout')
+    query(s,stage,label='query3 retained source continuation')
+   for bank,(aa,bb)in enumerate(u):
+    if bank!=s:W.add(bank,s,aa,f'query{stage} scalar exit')
+ if not omit_raw_a_restore:
+  for r in range(3,q+1):W.add(0,2*r,-1,'restore independent raw a')
+ W.add(3,0,-1,'held source subtract raw a')
+ for r in range(2,q+1):W.add(3,2*r,-1,'held source subtract future raw b')
+ for r in range(2,q+1):
+  e,o,b,c=2*r,2*r+1,2*r,2*r+1
+  query(1,e-1,label=f'query{e} source J');W.add(1,3,-1,'even isolate c difference');W.swap(1,3,'even source handoff')
+  source_swap(1,e,f'query{e} source swap');progress(1,e,3);W.swap(3,c,'move completed c difference')
+  query(b,o-1,label=f'query{o} source J')
+  for ell in range(r+1,q+1):W.add(2*ell+1,b,1,'odd future-c first fanout')
+  W.add(3,b,1,'odd delivery');W.swap(b,3,'odd source handoff')
+  W.add(2,b,-1,'odd b accumulator')
+  for ell in range(r+1,q+1):W.add(2*ell+1,b,-1,'odd future-c second fanout')
+  source_swap(b,o,f'query{o} source swap');progress(b,o,3)
+  if r<q:
+   nextc=2*r+3
+   W.add(2,b,1,'diagonal continuation retain V in b accumulator')
+   for ell in range(r+2,q+1):
+    W.add(2*ell+1,nextc,-1,'diagonal continuation next c difference')
+    W.add(2*ell+1,b,1,'diagonal continuation future V reader')
+   W.add(nextc,1,1,'diagonal continuation combine U and next delta')
+   query(b if continue_wrong_carrier else 1,o,label='diagonal retained J continuation on U')
+   W.swap(1,nextc,'diagonal t and held move');W.swap(nextc,b,'diagonal dirty V move');W.swap(b,3,'diagonal completed b move')
+  else:W.swap(b,3,'final completed b move')
+ query(0,k,label='final independent a J query');W.add(2,0,-1,'final b accumulator isolation')
+ for r in range(3,q+1):W.add(2*r+1,2*r-1,1,'triangular public c decode')
+ return W
+
+def original_formula(q):
+ n,k,m=2*q+2,2*q+1,4*q+4
+ I,N,J=mono(qc.identity(m)),mono(n_pair(m,0)),mono(j_operator(m))
+ A=product(adjoint(N),J);B={s:product(mono(plane_swap(m,0,s)),A)for s in range(1,k+1)}
+ Q1=product(product(adjoint(J),B[1]),J)
+ K=[[summ((B[2],Q1,scale(I,-1))),add(I,scale(B[2],-1))],[add(Q1,scale(I,-1)),I]]
+ E=I
+ for r in range(2,q+1):E=product(B[2*r],E)
+ D={r:product(B[2*r+1],J)for r in range(2,q+1)}
+ T=I
+ for r in range(2,q):T=product(scale(D[r],-1),T)
+ T=product(D[q],T)
+ Du=product(product(E,B[3]),J)
+ H=[[product(Du,x)for x in K[1]],[product(T,x)for x in K[0]]]
+ L=[[{}for _ in range(n)]for _ in range(2)]
+ uS=product(product(E,B[3]),add(B[1],scale(I,-2)))
+ uB=product(E,B[3])
+ vS=product(T,summ((scale(J,3),scale(product(J,B[1]),-1),scale(product(B[2],J),-1))))
+ for bank in[0]+[2*r for r in range(1,q+1)]:L[0][bank]=dict(uS);L[1][bank]=dict(vS)
+ L[0][2]=add(L[0][2],uB);L[1][2]=add(L[1][2],scale(product(T,J),-1))
+ R={q:scale(D[q],-1)}
+ for r in range(2,q):
+  rr=D[r]
+  for j in range(r+1,q):rr=product(scale(D[j],-1),rr)
+  R[r]=product(D[q],rr)
+ for r in range(2,q+1):L[1][2*r]=add(L[1][2*r],product(R[r],J))
+ M=eye(n,m)
+ for i in range(n):M[i]=[J if i==j else{}for j in range(n)]
+ for row,bank in enumerate((1,3)):
+  M[bank]=list(L[row]);M[bank][1]=H[row][0];M[bank][3]=H[row][1]
+ return {'matrix':M,'H':H,'L_original_columns':L,'K':K,'Du':Du,'Dv':T,'B':B,'Q1':Q1,'R':R}
+
+def native_pool():
+ z=Model(1,1);_,J=kernels(z);Jc=mul(z.T[0],J,z.T[0].adjoint())
+ pool={}
+ for name,op,exponent in(('N',z.N,1),('J0',J,1),('Jcompleted',Jc,1)):
+  for inv in(False,True):
+   literal=op.adjoint()if inv else op;rec,compiled=ce.lower_child(literal);same(compiled,literal,'selected native query actual Gaussian phase')
+   need(rec['rank']==2,'one native2 query')
+   pool[name+('inv'if inv else'')]={'one_coordinate_tableau':[list(t)for t in literal.tab],'one_coordinate_definition_circuit':literal.circuit,
+        'selected_native_recipe':rec,'phase_exponent':-exponent if inv else exponent,
+        'all_f_phase':'i^(phase_exponent*(1-f)) times coordinatewise tensor; selected-native child and both monomial adapters are literal and all arbitrary data are retained'}
+ return pool
+
+def metadata(events,q):
+ m=4*q+4;z=Model(1,2*q+1);_,J=kernels(z)
+ for e in events:
+  if e['kind']in('ADD','BANK_SWAP'):continue
+  fam=e['native_family']
+  if fam:
+   inv=fam.get('inverse',False)
+   if fam['kind']=='N':
+    i=fam['plane'];op=z.N if i==0 else z.T[i-1];dummy=1 if i==0 else 0
+    key='N';embedding=[2*i,2*i+1,2*dummy,2*dummy+1]
+   else:
+    completed=fam['completed'];op=mul(z.T[0],J,z.T[0].adjoint())if completed else J
+    key='Jcompleted'if completed else'J0';embedding=[0,1,2,3]
+   if inv:op=op.adjoint();key+='inv'
+   e['native_recipe_id']=key;e['recipe_embedding']=embedding;e['phase_exponent']=-1 if inv else 1
+  else:
+   # The only free unary in this prefix is a literal whole-plane ADDRESS.
+   rows=qc.decode(e,m).rows
+   # Plane swaps are symmetric involutions, so X and ordinary address rows coincide.
+   op=ce.perm(m,rows);e['phase_exponent']=0
+  e['one_coordinate_literal_circuit']=op.circuit
+  e['one_coordinate_tableau']=[list(t)for t in op.tab]
+  check_literal_family(e,m)
+
+@lru_cache(None)
+def inverse_transpose(rows):
+ r=qc.inverse(rows);n=len(rows)
+ return tuple(sum(((r[j]>>i)&1)<<j for j in range(n))for i in range(n))
+
+def literal_x(circuit,n,x):
+ phase=0
+ for e in circuit:
+  if e[0]=='P':x=qc.linear(inverse_transpose(tuple(e[1])),x)
+  elif e[0]=='C':phase+=e[2]*qc.parity(e[1]&x)
+  elif e[0]=='X':phase+=2*qc.parity(e[1]&x)
+  elif e[0]=='D':
+   need(not any(e[1])and all(v%2==0 for v in e[2]),'literal source phase is explicitly Pauli')
+   x^=sum(((v//2)&1)<<i for i,v in enumerate(e[2]))
+  elif e[0]=='phase':phase+=e[1]
+  else:raise ValueError('uncovered literal event '+e[0])
+ return x,phase%4
+
+def check_literal_family(e,m):
+ g=qc.decode(e,m);circuit=e['one_coordinate_literal_circuit'];exp=e['phase_exponent']
+ _,c0=literal_x(circuit,m,0)
+ for x in[0,(1<<m)-1]+[1<<i for i in range(m)]+[(1<<i)|(1<<j)for i in range(m)for j in range(i+1,m)]:
+  y,p=literal_x(circuit,m,x)
+  need(y==g.act(x),'actual source/ADDRESS circuit X-character map')
+  for f in(1,2,3,4):
+   need((exp*(1-f)+p+(f-1)*c0)%4==(g.global_phase+g.q(x)+(f-1)*g.q(0))%4,
+        'actual source/ADDRESS all-f Gaussian phase')
+
+def prove(q):
+ W=build(q);n,k,m=W.n,2*q+1,W.m
+ need(mm(W.M,W.Mi)==mm(W.Mi,W.M)==eye(n,m),'every independent original input and both literal inverse orders')
+ need(qc.replay(W.events,n,m)==W.M,'separate direct all-f event replay matches incremental operator matrix')
+ f=prefix(m,k);ret=[[product(mono(f.inv()),x)for x in row]for row in W.M]
+ formula=original_formula(q)
+ need(ret==formula['matrix'],'source-bound original-input H/L formula matches every physical prefix column')
+ target=mono(f@j_operator(m));public=[i for i in range(n)if i not in(1,3)]
+ need(all(W.M[i]==[target if j==i else{}for j in range(n)]for i in public),'all public outputs equal actual F_k J on their independent original inputs')
+ hist=Counter(e['rank_per_f']for e in W.events if e['kind']=='NATIVE')
+ need(hist=={2:n*k+q+2},'full source/query/idle/continuation histogram')
+ need(qc.rank((f@j_operator(m)).polar())==m,'actual output F_k J full native arity')
+ metadata(W.events,q)
+ inverse_events=W.inverse_events()
+ for e in inverse_events:
+  if e['kind']not in('ADD','BANK_SWAP'):check_literal_family(e,m)
+ need(qc.replay(inverse_events,n,m)==W.Mi,'literal reversed physical word matches full inverse on every column')
+ # Original t0 output versus the current V carrier is a fixed, single
+ # Clifford inverse entry, independent of all public L readers.
+ Cactual=product(target,W.Mi[1][3])
+ predicted=product(mono(f),product(mono(j_operator(m)),product(adjoint(formula['Q1']),product(adjoint(formula['B'][2]),product(adjoint(formula['Dv']),mono(f.inv()))))))
+ need(Cactual==predicted and len(Cactual)==1,'original-t inverse coefficient binds unfactored joint H/L')
+ need(qc.rank(next(iter(Cactual)).polar())==2*q+4,'actual F_k J inverse coefficient native arity')
+ return {'q':q,'width':n,'banks':n,'ambient_arity':m,'stages':k,'events':W.events,'inverse_events':W.inverse_events(),
+         'histogram':dict(hist),'native_rank_mass':2*hist[2],'stock_if_pivots_complete':n*m,'D_before_cleanup':2*q,
+         'public_rows':public,'pivot_rows':[1,3],'physical_matrix':sm(W.M),'physical_inverse':sm(W.Mi),
+         'retarded_matrix':sm(ret),'H':sm(formula['H']),'L_original_columns':sm(formula['L_original_columns']),
+         'core_K':sm(formula['K']),'Du':serial(formula['Du']),'Dv':serial(formula['Dv']),
+         'original_t_from_current_V_correction':serial(Cactual),'original_t_from_current_V_native_arity_per_f':2*q+4,
+         'native_recipe_pool':native_pool(),
+         'all_input_domain':'Every original input, including t0,k0 and all c fields, arbitrary and independent; all positive f via exact tensor phase polynomials.',
+         'limits':['Prefix only; joint cleanup not included.','Actual output is F_k J, with its right gauge retained; it is not silently E.','No independent helper stock is credited from a coupled H.']}
+
+def produce():
+ fixtures=[prove(q)for q in(2,3)]
+ wrong=build(3,omit_raw_a_restore=True)
+ need(wrong.M!=build(3).M,'omitted raw-a restoration changes original columns')
+ wrong=build(3,continue_wrong_carrier=True)
+ need(wrong.M!=build(3).M,'continuing V instead of U changes original columns')
+ return {'status':'PASS_J_DIAGONAL_PHYSICAL_PREFIX_ALL_ORIGINAL_COLUMNS_ALL_F',
+         'scientific_pin':'20ecf2891d80b5acf18d980b2164fb44ea7faa90','fixtures':fixtures,
+         'negative_controls':['Omitted independent raw-a restoration rejected.','Continued V instead of U rejected.'],
+         'source_pins':[{'path':str(OLD/p),'sha256':h}for p,h in PINS.items()]+[{'path':str(HERE/'joint_algebra.py'),'sha256':hashlib.sha256((HERE/'joint_algebra.py').read_bytes()).hexdigest()}],
+         'producer_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),'no_new_kappa':True}
+def main():
+ p=argparse.ArgumentParser(description=__doc__);p.add_argument('--write',action='store_true');a=p.parse_args()
+ out=json.loads(json.dumps(produce()));path=HERE/'JOINT-PREFIX.json'
+ if a.write:path.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n')
+ else:need(json.loads(path.read_text())==out,'saved joint physical prefix differs')
+ print(out['status'])
+if __name__=='__main__':main()
diff --git a/research/coupled-tail-support-floor/source/caller-joint/validate_recipe_links.py b/research/coupled-tail-support-floor/source/caller-joint/validate_recipe_links.py
new file mode 100644
index 0000000000..09cc7b2e72
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/caller-joint/validate_recipe_links.py
@@ -0,0 +1,42 @@
+"""Four unchanged source-authenticated recipe functions; unused cold imports omitted. Apache-2.0; Codex assistance."""
+from joint_algebra import *
+
+def compile_literal(circuit,n):
+ out=ce.ident(n)
+ for gate in circuit:
+  if gate[0]=='P':op=ce.perm(n,tuple(gate[1]))
+  elif gate[0]=='D':op=ce.diag(n,tuple(gate[1]),tuple(gate[2]))
+  elif gate[0]=='C':op=ce.cgate(n,gate[1],gate[2])
+  elif gate[0]=='X':op=ce.xgate(n,gate[1])
+  elif gate[0]=='phase':op=ce.Op(n,ce.identity(n),[tuple(gate)])
+  else:raise ValueError('uncovered selected literal '+str(gate[0]))
+  out=out.then(op)
+ return out
+
+def compile_monomial(rec,n):
+ return compile_literal([('D',rec['quadratic_rows'],rec['linear_Z4']),('P',rec['matrix_rows']),('X',rec['offset']),('phase',rec['phase'])],n)
+
+def compile_recipe(rec,n):
+ left=compile_monomial(rec['left'],n)
+ if not rec['rank']:return left
+ need(rec['right']is not None,'nonzero native rank has both literal monomial adapters')
+ return compile_monomial(rec['right'],n).then(ce.fourier(n,range(rec['rank']))).then(left)
+
+def embedding_circuit(circuit,embedding,n):
+ d=len(embedding);need(len(set(embedding))==d and all(0<=j<n for j in embedding),'recipe embedding injective')
+ def bits(x):return sum(((x>>i)&1)<<embedding[i]for i in range(d))
+ out=[]
+ for gate in circuit:
+  typ=gate[0]
+  if typ=='P':
+   rows=[1<<i for i in range(n)]
+   for i,j in enumerate(embedding):rows[j]=bits(gate[1][i])
+   out.append(('P',tuple(rows)))
+  elif typ=='D':
+   rows=[0]*n;alpha=[0]*n
+   for i,j in enumerate(embedding):rows[j]=bits(gate[1][i]);alpha[j]=gate[2][i]
+   out.append(('D',tuple(rows),tuple(alpha)))
+  elif typ in('C','X'):out.append((typ,bits(gate[1]),*gate[2:]))
+  elif typ=='phase':out.append(tuple(gate))
+  else:raise ValueError('uncovered embedded recipe '+typ)
+ return out
diff --git a/research/coupled-tail-support-floor/source/caller/free_ops.py b/research/coupled-tail-support-floor/source/caller/free_ops.py
new file mode 100644
index 0000000000..327bcb37aa
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/caller/free_ops.py
@@ -0,0 +1,108 @@
+"""Exact free operators N^2=-I and arbitrary invertible noncommuting P_j.
+
+Apache-2.0; substantial OpenAI Codex assistance. Derived from this lane's
+frozen coded caller verifier; no native admission is inferred here.
+"""
+from fractions import Fraction
+
+
+def need(x, why):
+    if not x:
+        raise ValueError(why)
+
+
+def reduce_word(w):
+    a, sign = [], 1
+    for x in w:
+        if a and x == a[-1] == 0:
+            a.pop()
+            sign = -sign
+        elif a and x != 0 and x == -a[-1]:
+            a.pop()
+        else:
+            a.append(x)
+    return tuple(a), sign
+
+
+def mono(w=(), c=1):
+    w, sign = reduce_word(w)
+    return {w: Fraction(c) * sign} if c else {}
+
+
+Z, I, N = {}, mono(), mono((0,))
+
+
+def add(a, b):
+    c = dict(a)
+    for w, v in b.items():
+        c[w] = c.get(w, 0) + v
+        if not c[w]:
+            del c[w]
+    return c
+
+
+def neg(a):
+    return {w: -v for w, v in a.items()}
+
+
+def mul(a, b):
+    c = {}
+    for w, x in a.items():
+        for v, y in b.items():
+            c = add(c, mono(w + v, x * y))
+    return c
+
+
+def prod(*args):
+    a = I
+    for b in args:
+        a = mul(a, b)
+    return a
+
+
+def inv(a):
+    need(len(a) == 1, 'invert one literal word')
+    (w, c), = a.items()
+    b = mono((), 1 / c)
+    for x in reversed(w):
+        b = mul(b, neg(N) if x == 0 else mono((-x,)))
+    need(mul(a, b) == mul(b, a) == I, 'literal phase inverse')
+    return b
+
+
+def summ(args):
+    a = Z
+    for b in args:
+        a = add(a, b)
+    return a
+
+
+def eye(n):
+    return [[I if i == j else Z for j in range(n)] for i in range(n)]
+
+
+def mm(a, b):
+    return [[summ(mul(x, y) for x, y in zip(r, c)) for c in zip(*b)] for r in a]
+
+
+def es(n, dst, src, coefficient):
+    a = eye(n)
+    a[dst][src] = add(a[dst][src], coefficient)
+    return a
+
+
+def unary(n, b, coefficient):
+    a = eye(n)
+    a[b][b] = coefficient
+    return a
+
+
+def serial(a):
+    return [{'coefficient': str(c),
+             'word': ['N' if x == 0 else 'P' + str(abs(x)) + ('^-1' if x < 0 else '') for x in w]}
+            for w, c in sorted(a.items())]
+
+
+def sm(a):
+    return [[serial(x) for x in r] for r in a]
+
diff --git a/research/coupled-tail-support-floor/source/caller/nested_family.py b/research/coupled-tail-support-floor/source/caller/nested_family.py
new file mode 100644
index 0000000000..76e5827c61
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/caller/nested_family.py
@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""Explicit nested source-retraction family and its one-coordinate cocycle.
+
+The native implementation still pays 2q-1 continuations. Algebraic
+telescoping alone is not permission to remove these queries.
+Apache-2.0; substantial OpenAI Codex assistance.
+"""
+from pathlib import Path
+import argparse
+import hashlib
+import json
+import sys
+sys.dont_write_bytecode=True
+from fractions import Fraction
+import free_ops as F
+from nested_prefix import skeleton, prefixes, Z, I, N, add, neg, mul, mm
+
+HERE=Path(__file__).resolve().parent
+
+
+def ec(z):return F.add(F.mono((),z[0]),F.mono((0,),z[1]))
+
+
+def retraction(q,s):
+    n=2*q+2;u=[Z]*n
+    if s==1:
+        u[0]=I;u[2]=I
+    elif s==2:
+        u[1]=I
+        for r in range(1,q+1):u[2*r+1]=I
+    elif s==2*q+2:
+        u[1]=I;u[0]=N;u[2]=neg(I)
+    elif s==2*q+3:
+        u[0]=I;u[2]=N
+    elif s%2:
+        r=(s-1)//2;u[2*r]=I
+        for j in range(1,r):u[2*j+1]=I
+        for j in range(r+1,q+1):u[2*j+1]=neg(N)
+    else:
+        r=(s-2)//2;u[1]=I;u[2*(r+1)]=N
+        for j in range(1,r+1):u[2*j+1]=N
+        for j in range(r+1,q+1):u[2*j+1]=I
+    return u
+
+
+def coordinates(q,s):
+    if s==1:return(neg(N),neg(N)),(N,Z)
+    if s==2:return(neg(I),Z),(neg(I),I)
+    if s==2*q+2:return(I,Z),(I,Z)
+    if s==2*q+3:return(neg(N),Z),(N,Z)
+    if s%2:return(Z,neg(N)),(Z,N)
+    return(Z,I),(Z,I)
+
+
+def continued(q,s):
+    return (3<=s<=2*q and s!=2)or s==2*q+2
+
+
+def formal(q):
+    n,ops=skeleton(q,[1]+[0]*(q-1));M=F.eye(n);Mi=F.eye(n);s=0;sources=[]
+    def app(A,Ai):
+        nonlocal M,Mi
+        F.need(F.mm(A,Ai)==F.mm(Ai,A)==F.eye(n),'each event has its full inverse')
+        M=F.mm(A,M);Mi=F.mm(Mi,Ai)
+    def a(d,src,c):app(F.es(n,d,src,c),F.es(n,d,src,F.neg(c)))
+    for r in range(2,q+1):a(2*r+1,3,F.I)
+    for typ,d,src,z in ops:
+        if typ=='a':a(d,src,ec(z))
+        elif typ=='s':
+            B=F.eye(n);B[d],B[src]=B[src],B[d];app(B,B)
+        else:
+            s+=1;u=retraction(q,s)
+            F.need(u[src]==I,'source normalization')
+            for j,z in enumerate(u):
+                if j!=src and z!=Z:a(j,src,F.neg(ec(z)))
+            P=F.mono((s,));P=F.mul(F.N,P)if continued(q,s)else P
+            A=F.mm(F.unary(n,src,P),F.es(n,d,src,F.N))
+            Ai=F.mm(F.es(n,d,src,F.neg(F.N)),F.unary(n,src,F.inv(P)))
+            app(A,Ai)
+            for j,z in enumerate(u):
+                if j!=src and z!=Z:a(j,src,ec(z))
+            sources.append({'stage':s,'src':src,'dst':d,'u':[[str(a),str(b)]for a,b in u],
+                            'source_code':('N P'if continued(q,s)else'P')+str(s)})
+    for r in range(2,q+1):a(2*r+1,3,F.neg(F.I))
+    F.need(F.mm(M,Mi)==F.mm(Mi,M)==F.eye(n),'all-column literal inverse in both orders')
+    public=[i for i in range(n)if i not in(1,3)]
+    F.need(all(M[i]==[F.N if j==i else F.Z for j in range(n)]for i in public),
+           'all n-2 public outputs are exactly N times independent inputs')
+    H=[[M[i][j]for j in(1,3)]for i in(1,3)];L=[[M[i][j]for j in public]for i in(1,3)]
+    P={j:F.mono((j,))for j in range(1,2*q+4)}
+    A3=F.prod(*(P[j]for j in range(2*q+1,2,-1)))
+    if(q-1)%2:A3=F.neg(A3)
+    Q1=F.prod(F.inv(F.N),P[1],F.N)
+    J=[[F.add(F.add(P[2],Q1),F.neg(F.I)),F.add(F.I,F.neg(P[2]))],
+       [F.add(Q1,F.neg(F.I)),F.I]]
+    D=[[F.neg(F.mul(P[2*q+3],P[2*q+2])),F.Z],[F.Z,F.mul(A3,F.N)]]
+    F.need(H==F.mm(D,J),'five-factory H factor for the explicit family')
+    # Independently rebuild H using only the two-dimensional source-coordinate updates.
+    B=F.eye(2)
+    for s in range(1,2*q+4):
+        w,r=coordinates(q,s);w=list(map(ec,w));r=list(map(ec,r))
+        Ptilde=F.mul(F.N,P[s])if continued(q,s)else P[s]
+        T=[[F.add(F.I if i==j else F.Z,F.prod(w[i],F.add(Ptilde,F.neg(F.I)),r[j]))for j in range(2)]for i in range(2)]
+        B=F.mm(T,B)
+    F.need(H==[[F.mul(F.N,x)for x in row]for row in B],
+           'two-coordinate update proof independently reconstructs H')
+    return {'q':q,'banks':n,'raw_calls':2*q+3,'public_rows':public,'pivot_rows':[1,3],
+            'source_retractions':sources,'complete_matrix':F.sm(M),'complete_inverse':F.sm(Mi),
+            'H':F.sm(H),'L':F.sm(L),'D':F.sm(D),'J':F.sm(J),'A3':F.serial(A3),
+            'continuations':[s for s in range(1,2*q+4)if continued(q,s)],
+            'separate_progress_profile':{'H2':n*(2*q+3)+2*q+1,'ambient':4*q+8,
+                                         'rank_deficit_before_tail':2}}
+
+
+def prefix_coordinates(q):
+    n=2*q+2;_,pre=prefixes(q,[1]+[0]*(q-1))
+    V=[[I if i==1 else Z,I if i>=3 and i%2 else Z]for i in range(n)]
+    for s,(M,src,dst)in enumerate(pre,1):
+        B=mm(M,V);w,r=coordinates(q,s)
+        F.need([add(mul(row[0],w[0]),mul(row[1],w[1]))for row in B]==retraction(q,s),
+               'displayed normalized source column lies in the transported fixed plane')
+        F.need(tuple(B[src])==r,'displayed source functional on both pivot coordinates')
+
+
+def cocycle():
+    # Columns(z,A,c,d,b) are independent fields. Po and Pe do not commute.
+    ZR=[F.I,F.Z,F.Z,F.Z,F.Z];AR=[F.Z,F.I,F.Z,F.Z,F.Z]
+    CR=[F.Z,F.Z,F.I,F.Z,F.Z];DR=[F.Z,F.Z,F.Z,F.I,F.Z];BR=[F.Z,F.Z,F.Z,F.Z,F.I]
+    def plus(*rows):return[F.summ(row[j]for row in rows)for j in range(5)]
+    def left(a,row):return[F.mul(a,x)for x in row]
+    Po,Pe=F.mono((1,)),F.mono((2,))
+    y=plus(left(F.N,ZR),left(F.neg(F.I),AR),left(F.N,CR))
+    fodd=plus(left(F.neg(F.I),AR),left(F.N,CR))
+    zodd=plus(left(F.mul(Po,F.N),ZR),left(F.add(Po,F.N),fodd))
+    even_source=plus(zodd,left(F.N,AR),DR)
+    F.need(even_source==plus(left(Po,y),DR,left(F.neg(F.I),CR)),
+           'next source is the old source through one ADDRESS plus the raw c difference')
+    feven=plus(left(F.N,AR),DR)
+    zeven=plus(left(F.mul(F.N,Pe),zodd),left(F.add(F.mul(F.N,Pe),F.neg(F.I)),feven))
+    ynext=plus(left(F.N,zeven),left(F.N,DR),left(F.neg(F.I),AR),BR)
+    rhs=plus(left(F.neg(F.mul(Pe,Po)),y),BR,left(Pe,CR),left(F.neg(Pe),DR))
+    F.need(ynext==rhs,'middle two-call affine ADDRESS cocycle on every independent public/pivot column')
+    return {'source_y':'y_r=N z-A_r+N c_r, A_r=a+sum_(l>r)b_l; c1 means zero public reader',
+            'next_even_source':'P_o y_r+c_(r+1)-c_r',
+            'next_y':'-P_e P_o y_r+b_(r+1)+P_e(c_r-c_(r+1))',
+            'independent_columns':['z','A_r','c_r','c_(r+1)','b_(r+1)'],
+            'covered_domain':'Arbitrary independent invertible noncommuting Po,Pe; N^2=-I; literal affine operator identity.',
+            'not_native_admission':'The virtual coordinate is a literal source at the odd cut. Holding its chart through the even cut still requires an explicit invertible bank encoder, all public readers at actual frames, and restoration of the other independent dirty field.'}
+
+
+def prove():
+    for q in range(1,9):prefix_coordinates(q)
+    fixtures=[formal(q)for q in(1,2,3,4)]
+    from nested_six import formal_word
+    M,Mi,_,_,_=formal_word()
+    F.need(fixtures[1]['complete_matrix']==F.sm(M)and fixtures[1]['complete_inverse']==F.sm(Mi),
+           'q2 direct family agrees exactly with independently compiled NESTED-SIX')
+    return {'status':'PASS_EXPLICIT_NESTED_SOURCE_FAMILY_AND_ONE_COORDINATE_AFFINE_COCYCLE',
+            'scientific_pin':'20ecf2891d80b5acf18d980b2164fb44ea7faa90','fixtures':fixtures,'affine_cocycle':cocycle(),
+            'all_parameter_proof':'The ideal nested response skeleton gives N on every field after its output isolation. Its two transported pivot columns obey the displayed source-functional/retraction table. Conjugated source-code insertions therefore act by 2x2 updates I+w(Ptilde-I)r. The first two updates multiply to J(P2,Q1); all middle updates are on only the second coordinate and telescope to Ad_(N^-1)(A3), A3=(-1)^(q-1)P_(2q+1)...P3; the last two updates give the first diagonal factor. Left multiplication by the ideal final N yields H=diag(-P_last P_penult,A3 N)J. No source code or public coupling is discarded.',
+            'initial_basis':'At raw ZERO, c_r+=c1 for r>=2. One common N/N^-1 exposure fanouts b1+=N*t only. The inverse c-basis is applied after the last query; its other public rows are retained.',
+            'finite_checks':'Every free-operator matrix column and both inverse orders for q1..4. Exact transported-plane/source-functional table for q1..8. q2 entire matrix agrees with NESTED-SIX.',
+            'native_invoice':'With the current literal compiler c=2q-1 retained N continuations, two shared input N calls and all separate fresh progress: H2=(2q+2)(2q+3)+2q+1, m=4q+8, n=2q+2, D_before_tail=2. Wide batching changes moment pressure, not this mass. No amortized query removal is asserted.',
+            'limits':['H has a bounded five-factory form, but the complete L readers and their native cuts remain part of the contract.',
+                      'The affine ADDRESS cocycle is an algebraic grouping target, not an implemented shared-native controller.',
+                      'The finite checks and written all-parameter recurrence are not a formal-kernel proof.'],
+            'source_pins':[{'path':str(HERE/p),'sha256':hashlib.sha256((HERE/p).read_bytes()).hexdigest()}
+                           for p in('nested_prefix.py','nested_six.py','NESTED-SIX.json','free_ops.py')],
+            'no_new_kappa':True}
+
+
+def main():
+    ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--write',action='store_true');args=ap.parse_args()
+    out=prove();out['producer_sha256']=hashlib.sha256(Path(__file__).read_bytes()).hexdigest();path=HERE/'NESTED-FAMILY.json'
+    out=json.loads(json.dumps(out))
+    if args.write:path.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n')
+    else:F.need(json.loads(path.read_text())==out,'saved nested-family receipt differs')
+    print(out['status'])
+
+
+if __name__=='__main__':main()
diff --git a/research/coupled-tail-support-floor/source/caller/nested_prefix.py b/research/coupled-tail-support-floor/source/caller/nested_prefix.py
new file mode 100644
index 0000000000..d7e424e224
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/caller/nested_prefix.py
@@ -0,0 +1,113 @@
+"""Exact ideal prefixes for nested three-response replacements.
+
+This is a construction helper, not a native admission or a receipt.
+Apache-2.0; substantial OpenAI Codex assistance.
+"""
+from fractions import Fraction as F
+from itertools import combinations
+from pivot_plane_probe import Z, I, N, add, neg, mul, inv, eye, mm, es, null, summ
+
+
+def skeleton(q, betas=None):
+    n = 2*q+2
+    out = []
+    def a(d,s,c=I): out.append(('a',d,s,c))
+    def query(d,s,depth):
+        if depth == 0:
+            out.append(('q',d,s,N))
+            return
+        b,c = 2*depth, 2*depth+1
+        a(c,d,neg(I));a(s,b)
+        query(d,s,depth-1)
+        a(s,b,neg(I));a(d,c)
+        out.append(('q',b,d,N))
+        a(d,c,neg(I))
+        out.append(('q',c,b,N))
+        a(b,s);a(c,d);a(d,c,neg(I))
+        out.append(('s',b,c,I))
+    # All independent incoming b fields use the same paid input exposure.
+    betas=[F(1)]*q if betas is None else list(map(F,betas))
+    for j in range(1,q+1):a(2*j,1,(F(0),betas[j-1]))
+    query(1,0,q)
+    out.append(('q',0,1,N));out.append(('q',1,0,N))
+    out.append(('s',0,1,I))
+    for j in range(1,q+1):a(2*j,1,(F(0),-betas[j-1]))
+    return n,out
+
+
+def prefixes(q,betas=None):
+    n,ops=skeleton(q,betas)
+    M=eye(n);out=[]
+    for typ,d,s,c in ops:
+        if typ=='s':
+            M=[list(row) for row in M]
+            M[d],M[s]=M[s],M[d]
+        else:
+            M=mm(es(n,d,s,c),M)
+        if typ=='q':out.append((M,s,d))
+    target=[[N if i==j else Z for j in range(n)]for i in range(n)]
+    if M!=target:raise ValueError('nested ideal skeleton not full N')
+    return ops,out
+
+
+def rref_null(A):
+    return null(A)
+
+
+def source_choice(B,src,prefer_real=True):
+    """Choose E-column coefficients with source1, minimizing N-row support.
+
+    B has two E-columns. The search is only the finitely many possible
+    active constraints of its at-most-two-dimensional affine solution.
+    """
+    n=len(B)
+    # c_j=a_j+N*b_j.  Source normalization is exact (real1,N0).
+    realrows=[];imagrows=[]
+    for row in B:
+        realrows.append([z for x in row for z in (x[0],-x[1])])
+        imagrows.append([z for x in row for z in (x[1],x[0])])
+    def solve(A,b):
+        m=len(A);k=4;A=[list(row)+[rhs]for row,rhs in zip(A,b)];r=0;p=[]
+        for j in range(k):
+            h=next((h for h in range(r,m)if A[h][j]),None)
+            if h is None:continue
+            A[r],A[h]=A[h],A[r];v=A[r][j];A[r]=[x/v for x in A[r]]
+            for h in range(m):
+                if h!=r and A[h][j]:
+                    v=A[h][j];A[h]=[x-v*y for x,y in zip(A[h],A[r])]
+            p.append(j);r+=1
+        if any(not any(row[:k]) and row[k]for row in A):return None
+        x=[F(0)]*k
+        for h,j in enumerate(p):x[j]=A[h][k]
+        return x
+    candidates=[]
+    # Two normalization constraints leave at most two independent choices.
+    for count in range(3):
+        for chosen in combinations(range(n),count):
+            A=[realrows[src],imagrows[src]]+[imagrows[i]for i in chosen]
+            x=solve(A,[F(1),F(0)]+[F(0)]*count)
+            if x is None:continue
+            u=[summ(mul(z,(x[2*j],x[2*j+1]))for j,z in enumerate(row))for row in B]
+            if u[src]!=I:raise ValueError('source normalization')
+            key=(sum(z[1]!=0 for z in u),sum(z!=Z for z in u),sum(abs(z[0])+abs(z[1])for z in u))
+            candidates.append((key,u,x))
+    if not candidates:return None
+    return min(candidates,key=lambda t:t[0])
+
+
+def probe(q,c_weights=None,betas=None):
+    n=2*q+2;ops,pre=prefixes(q,betas)
+    weights=[1]*q if c_weights is None else c_weights
+    V=[[I if i==1 else Z, (F(weights[(i-3)//2]),F(0))if i>=3 and i%2 else Z]for i in range(n)]
+    rows=[]
+    for M,src,dst in pre:
+        answer=source_choice(mm(M,V),src)
+        rows.append((src,dst,answer))
+    return rows
+
+
+if __name__=='__main__':
+    for q in(1,2,3):
+        print('q',q)
+        for src,dst,res in probe(q):
+            print(src,'->',dst, None if res is None else (res[0],res[1]))
diff --git a/research/coupled-tail-support-floor/source/caller/pivot_plane_probe.py b/research/coupled-tail-support-floor/source/caller/pivot_plane_probe.py
new file mode 100644
index 0000000000..fd793eba19
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/caller/pivot_plane_probe.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""Bounded n4 source-retraction screen; actual code/native closure not inferred."""
+from fractions import Fraction as F
+from itertools import product
+from pathlib import Path
+import json, sys
+sys.dont_write_bytecode=True
+Z=(F(0),F(0));I=(F(1),F(0));N=(F(0),F(1))
+def add(a,b):return(a[0]+b[0],a[1]+b[1])
+def neg(a):return(-a[0],-a[1])
+def mul(a,b):return(a[0]*b[0]-a[1]*b[1],a[0]*b[1]+a[1]*b[0])
+def inv(a):
+ d=a[0]*a[0]+a[1]*a[1]
+ if not d:raise ValueError('nonunit')
+ return(a[0]/d,-a[1]/d)
+def eye(n):return [[I if i==j else Z for j in range(n)] for i in range(n)]
+def mm(A,B):return [[summ(mul(x,y) for x,y in zip(r,c)) for c in zip(*B)] for r in A]
+def summ(xs):
+ a=Z
+ for b in xs:a=add(a,b)
+ return a
+def es(n,d,s,c):
+ A=eye(n);A[d][s]=c;return A
+def null(A):
+ A=[list(r) for r in A];m=len(A);n=len(A[0]);p=[];r=0
+ for c in range(n):
+  k=next((k for k in range(r,m) if A[k][c]),None)
+  if k is None:continue
+  A[r],A[k]=A[k],A[r];v=A[r][c];A[r]=[x/v for x in A[r]]
+  for j in range(m):
+   if j!=r and A[j][c]:
+    v=A[j][c];A[j]=[x-v*y for x,y in zip(A[j],A[r])]
+  p.append(c);r+=1
+  if r==m:break
+ out=[]
+ for c in range(n):
+  if c in p:continue
+  v=[F(0)]*n;v[c]=F(1)
+  for j,d in enumerate(p):v[d]=-A[j][c]
+  out.append(v)
+ return out
+
+def rank(A):
+ A=[list(r) for r in A];m=len(A);n=len(A[0]);r=0
+ for c in range(n):
+  k=next((k for k in range(r,m) if A[k][c]!=Z),None)
+  if k is None:continue
+  A[r],A[k]=A[k],A[r];v=inv(A[r][c]);A[r]=[mul(x,v) for x in A[r]]
+  for j in range(m):
+   if j!=r and A[j][c]!=Z:
+    v=A[j][c];A[j]=[add(x,neg(mul(v,y))) for x,y in zip(A[j],A[r])]
+  r+=1
+  if r==m:break
+ return r
+
+def prefixes(n=4):
+ ops=[('q',0,1,N),('a',0,2,I),('q',1,0,N),('a',0,2,neg(I)),('a',1,3,I),('q',2,1,N),('a',1,3,neg(I)),('q',3,2,N),('a',1,3,I),('a',2,0,I),('q',0,3,neg(N)),('a',2,0,neg(I))]
+ M=eye(n);Mi=eye(n);out=[]
+ for typ,d,s,c in ops:
+  M=mm(es(n,d,s,c),M);Mi=mm(Mi,es(n,d,s,neg(c)))
+  if typ=='q':out.append((M,Mi,s,d))
+ return out
+
+def real_source(B,src):
+ ns=null([[z for x in r for z in (x[1],x[0])] for r in B])
+ for v in ns:
+  u=[summ(mul(x,(v[2*j],v[2*j+1])) for j,x in enumerate(r)) for r in B]
+  if any(x[1] for x in u):raise ValueError('nonreal null witness')
+  if u[src][0]:return [x[0]/u[src][0] for x in u]
+ return None
+
+def serial(A):return [[[str(x),str(y)] for x,y in r] for r in A]
+def run():
+ pre=prefixes();found=[];count=0;dimension_fail=0
+ for tail1 in product((-1,0,1),repeat=3):
+  u1=list(map(F,tail1));u1.insert(pre[0][2],F(1))
+  v1=mm(pre[0][1],[[(x,F(0))] for x in u1])
+  for tail2 in product((-1,0,1),repeat=3):
+   count+=1;u2=list(map(F,tail2));u2.insert(pre[1][2],F(1))
+   v2=mm(pre[1][1],[[(x,F(0))] for x in u2])
+   V=[[v1[i][0],v2[i][0]] for i in range(4)]
+   if rank(V)!=2:dimension_fail+=1;continue
+   choices=[]
+   for M,Mi,src,dst in pre:
+    u=real_source(mm(M,V),src)
+    if u is None:break
+    choices.append([str(x) for x in u])
+   else:found.append({'first_source':list(map(str,u1)),'second_source':list(map(str,u2)),'input_plane':serial(V),'source_retractions':choices})
+ return {'status':'BOUNDED_EXACT_SOURCE_RETRACTION_SCREEN','candidate_pairs':count,'source_tail_alphabet':[-1,0,1],'dimension_failures':dimension_fail,'solutions':found,'scope':'Old n4 five-shear ideal topology only; arbitrary real source-retraction columns allowed at later queries. Source-code algebra, native encoder and actual correction are not inferred.','native_invoice_if_admitted':'Same five raw carriers plus full global fresh progress; constant bank GL source changes only. Any N-dependent initial plane encoder and terminal correction remain paid/open.'}
+if __name__=='__main__':
+ out=run();Path(__file__).with_name('PIVOT-PLANE-PROBE.json').write_text(json.dumps(out,indent=2,sort_keys=True)+'\n');print(out['status'],out['candidate_pairs'],'pairs',len(out['solutions']),'solutions')
+ if out['solutions']:print(json.dumps(out['solutions'][0]))
diff --git a/research/coupled-tail-support-floor/source/completed-gates-review/audit_gates.py b/research/coupled-tail-support-floor/source/completed-gates-review/audit_gates.py
new file mode 100644
index 0000000000..273ac580b4
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/completed-gates-review/audit_gates.py
@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+"""Independent identity, invoice and strand audit of two completed gates.
+Apache-2.0; substantial OpenAI Codex assistance. No new supplier claim.
+"""
+from pathlib import Path
+from fractions import Fraction
+from collections import Counter
+import hashlib, importlib.machinery, json, sys, argparse, copy
+sys.dont_write_bytecode=True
+HERE=Path(__file__).resolve().parent; R=HERE.parent
+EXECUTED={};original=importlib.machinery.SourceFileLoader.get_code
+def source_only(self, name):
+    p=Path(self.path)
+    if str(p).startswith('/Users/ross/git/math/'):
+        raw=p.read_bytes();EXECUTED[str(p)]=hashlib.sha256(raw).hexdigest()
+        return compile(raw,str(p),'exec',dont_inherit=True,optimize=0)
+    return original(self,name)
+importlib.machinery.SourceFileLoader.get_code=source_only
+sys.path.insert(0,str(R/'two-site-independent-audit'))
+import audit_two_sites as independent
+sys.path.insert(0,str(R/'caller-joint'))
+import joint_algebra as ja
+ce,qc=independent.ce,ja.qc
+K=R/'general-clifford-retiming/kernel-search'; T=R/'pauli-caller-retiming'
+def need(c,s):
+    if not c:raise ValueError(s)
+def sha(p):return hashlib.sha256(Path(p).read_bytes()).hexdigest()
+def stable(x):return json.dumps(x,sort_keys=True,separators=(',',':'))
+def rank(vs):
+    basis={}
+    for v in vs:
+        while v:
+            bit=v.bit_length()-1
+            if bit in basis:v^=basis[bit]
+            else:basis[bit]=v;break
+    return len(basis)
+def eq(a,b):return ja.mono(a)==ja.mono(b)
+def native(g):return rank(g.polar())
+def scalar(m,p):return qc.Mono(qc.identity(m).rows,0,(0,)*m,(0,)*m,0,p)
+def N(m,s):
+    a=[0]*m;a[2*s]=3;a[2*s+1]=1
+    return qc.Mono(qc.identity(m).rows,3<<(2*s),tuple(a),(0,)*m,0,1)
+def P(m,s):
+    rows=list(qc.identity(m).rows)
+    for d in (0,1):rows[d],rows[2*s+d]=rows[2*s+d],rows[d]
+    return qc.Mono(tuple(rows),0,(0,)*m,(0,)*m)
+def F(m,s):
+    x=qc.identity(m)
+    for i in range(1,s+1):x=N(m,i)@x
+    return x
+def embed(d,m):return qc.Mono(tuple(d['rows'])+tuple(1<<i for i in range(4,m)),d['offset'],tuple(d['alpha'])+(0,)*(m-4),tuple(d['quad'])+(0,)*(m-4),d['constant'],d['global_phase'])
+def oldexpr(g):return independent.old.serialized_family(ja.serial(ja.mono(g)))
+def kernel_checks():
+    manifest=json.loads((K/'MANIFEST.json').read_text())
+    for p in manifest['files']:need(sha(K/p['path'])==p['sha256'],'kernel frozen manifest '+p['path'])
+    raw=(K/'EXACT-FIXTURES.json').read_bytes();need(raw==(K/'EXACT-FIXTURES-OPTIMIZED.json').read_bytes(),'kernel normal/-O bytes')
+    data=json.loads(raw);cases={x['kernel']:x['J_four_axes'] for x in data['fixtures']};rows=[];bindings=[]
+    for name,d in cases.items():
+        for q in range(2,9):
+            k=2*q+1;m=4*q+4;J=embed(d,m);bar=N(m,1)@J@N(m,1).inv()
+            B={s:P(m,s)@N(m,0).inv()@J for s in range(1,k+1)}
+            Q=J.inv()@B[1]@J
+            need(eq(J@J,scalar(m,2)),'all-f skew square')
+            need(eq(Q,J@P(m,1)@N(m,0).inv()),'Q simplified with whole-field sign')
+            need(eq((N(m,1)@Q.inv()@N(m,1).inv())@(N(m,1)@J),N(m,1)@N(m,0)@P(m,1)),'Q-target exact product')
+            transport=P(m,4)@bar;chain=B[4]
+            for r in range(3,q+1):
+                transport=P(m,2*r)@bar@N(m,2*r-1)@transport
+                chain=B[2*r]@B[2*r-1]@chain
+            # The displayed ellipsis in the source proof means EVEN indices.
+            chain=qc.identity(m)
+            for s in range(4,2*q+1,2):chain=B[s]@chain
+            need(eq(F(m,2*q).inv()@transport,chain@F(m,3).inv()),'transport exact telescope')
+            Du=chain@B[3]@J;C=F(m,2*q)@Du.inv()@F(m,2*q).inv()
+            L=C@transport@P(m,3);RR=transport.inv()@P(m,2*q)
+            closed=scalar(m,2)
+            for s in range(3,2*q+1):closed=N(m,s)@closed
+            need(eq(L,closed),'closed L all-f sign and phase')
+            a,b,v,w=native(J),native(bar),native(N(m,1)@J),native(N(m,1)@Q.inv()@N(m,1).inv())
+            rho=native(RR);ell=native(L)
+            need(ell==4*q-4 and rho<=(q-1)*b+2*(q-2),'L transport rank and R upper bound')
+            need(w+v>=4 and v<=4 and a>=max(v-2,0) and b>=max(v-2,0),'coupled rank restrictions')
+            mass=8*q*q+10*q+2+2*a+3*q*b+w+abs(ell-rho);stock=(2*q+2)*(4*q+v)
+            upper=(2*q+3)*v-(4*q+6)-2*a-(2*q+1)*b
+            need(stock-mass<=upper<=0,'all-q inequality at exact finite witness')
+            rows.append(dict(kernel=name,q=q,a=a,b=b,v=v,w=w,rho=rho,ell=ell,mass=mass,stock=stock,deficit=stock-mass))
+            if q<=3:
+                case=next(x for x in data['fixtures'] if x['kernel']==name and x['default']['q']==q)
+                df,cf=case['default'],case['isolated'];E=df['events'];n=df['banks']
+                col,row=independent.transported(df['prefix_events'],*cf['sites'],n,m)
+                bank=df['prefix_events'][cf['sites'][1]]['bank']
+                need(all(not x for i,x in enumerate(col) if i!=bank) and all(not x for i,x in enumerate(row) if i!=bank),'independent complete forward-column/inverse-row isolation')
+                need(col[bank]==oldexpr(transport),'independent all-f actual transported column')
+                need(row[bank]==oldexpr(transport.inv()),'independent all-f actual transported inverse row')
+                hist=Counter(e['rank_per_f'] for e in cf['events'] if e['kind']=='NATIVE')
+                need(sum(r*c for r,c in hist.items())==mass==cf['mass'],'independent retained histogram invoice')
+                for e in E:
+                    if e['kind'] not in ('ADD','SCALE','BANK_SWAP'):independent.old.event_op(e,m)
+                M=independent.replay_old(E,n,m);Mi=independent.replay_old(E,n,m,inverse=True)
+                target=oldexpr(F(m,k)@J);need(M==[[target if i==j else{}for j in range(n)]for i in range(n)],'independent full default target every original column all-f')
+                need(independent.mm(M,Mi)==independent.identity(n,m)==independent.mm(Mi,M),'independent default literal inverse both orders')
+                need(oldexpr(L)==independent.old.serialized_family(cf['L']),'saved L full tensor phase')
+                need(oldexpr(RR)==independent.old.serialized_family(cf['R']),'saved R full tensor phase')
+                Lop,Lex=independent.to_op(oldexpr(L));Rop,Rex=independent.to_op(oldexpr(RR))
+                U=independent.op_of(json.dumps(cf['first_monomial']['literal_circuit']),m);ue=cf['events'][cf['sites'][0]];ve=cf['events'][cf['sites'][1]]
+                need(independent.equal_op(U,independent.op_of(json.dumps(ue['one_coordinate_literal_circuit']),m)) and ue['extra_global_phase_exponent_by_f_mod4']==[0]*4,'first actual event equals declared physical monomial family')
+                V=independent.op_of(json.dumps(ve['one_coordinate_literal_circuit']),m)
+                need(rank(x for x,z,p in U.tab[m:])==0,'first replacement physical monomial')
+                need(independent.equal_op(V,independent.mul(Lop,U.adjoint(),Rop)),'independent local V=L U^-1 R Gaussian phase')
+                need(ve['extra_global_phase_exponent_by_f_mod4']==[(a+b)%4 for a,b in zip(Lex,Rex)],'local replacement all-f tensor phase')
+                need(len(cf['events'])==len(cf['inverse_events']),'complete changed inverse event coverage')
+                for ef,ei in zip(cf['events'],reversed(cf['inverse_events'])):
+                    need(ef['kind']==ei['kind'],'changed inverse event kind/order')
+                    if ef['kind']=='ADD':need((ef['dst'],ef['src'])==(ei['dst'],ei['src']) and Fraction(ef['coefficient'])==-Fraction(ei['coefficient']),'changed inverse ADD sign')
+                    elif ef['kind']=='SCALE':need(ef['bank']==ei['bank'] and Fraction(ef['coefficient'])*Fraction(ei['coefficient'])==1,'changed inverse SCALE')
+                    elif ef['kind']=='BANK_SWAP':need(ef['banks']==ei['banks'],'changed inverse bank swap')
+                    else:
+                        of=independent.op_of(json.dumps(ef['one_coordinate_literal_circuit']),m);oi=independent.op_of(json.dumps(ei['one_coordinate_literal_circuit']),m)
+                        need(stable(of.adjoint().circuit)==stable(oi.circuit) and of.adjoint().tab==oi.tab,'changed literal inverse unary actual adjoint')
+                        need(ei['extra_global_phase_exponent_by_f_mod4']==[(-p)%4 for p in ef['extra_global_phase_exponent_by_f_mod4']],'changed inverse tensor phase sign')
+                bindings.append(dict(kernel=name,q=q,actual_original_columns=n,default_full_target_all_f=True,literal_inverse_orders=2,isolated_bank=bank,L_rank=ell,R_rank=rho,mass=mass,stock=stock))
+    # Formula controls are sensitive to all-f phase and completed-frame conjugacy.
+    need(not eq(L,scalar(m,1)@L),'wrong whole-field phase rejected')
+    addr=embed(cases['address_swap_rankzero_J'],12)
+    need(native(addr)==0 and native(N(12,1)@addr@N(12,1).inv())==4,'completed J bill cannot use uncompleted arity')
+    need(native(embed(cases['odd_rankone_involution'],12))==1,'odd native skew response retained')
+    return dict(finite_rank_identity_grid=rows,actual_q2_q3_transport_bindings=bindings,controls=['wrong whole-field phase differs','completed address kernel rank changes 0 to 4','odd native rank one retained'],all_q_scope='Written proof conditional on displayed repeating scalar/isolation transport and fixed two-site edits; no all-q serialized physical compiler or selected-new-native admission.')
+def phase_family(op,extra):
+    out=independent.from_circuit(op,0)
+    units=independent.UNITS
+    return {k:tuple(c*units[extra[r]%4] for r,c in enumerate(v))for k,v in out.items()}
+def trajectory_checks(cert=None):
+    if cert is None:cert=json.loads((T/'TRAJECTORY-CERTIFICATES.json').read_text())
+    results=[]
+    for f in cert['fixtures']:
+        m,n=f['ambient_arity'],f['banks'];src=json.loads((T/f['source']['path']).read_text())
+        need(sha(T/f['source']['path'])==f['source']['sha256'],'trajectory source pin')
+        sf=next(x for x in src['fixtures'] if x['q']==f['q']);events=sf.get('full_events',sf['events'])
+        labels=list(range(n));ops=[ce.ident(m) for _ in range(n)];phase=[(0,)*4 for _ in range(n)]
+        for e in events:
+            if e['kind']=='BANK_SWAP':
+                i,j=e['banks'];labels[i],labels[j]=labels[j],labels[i];ops[i],ops[j]=ops[j],ops[i];phase[i],phase[j]=phase[j],phase[i]
+            elif e['kind'] not in ('ADD','SCALE'):
+                op=independent.op_of(json.dumps(e['one_coordinate_literal_circuit']),m);b=e['bank'];ops[b]=ops[b].then(op)
+                extra=e.get('extra_global_phase_exponent_by_f_mod4',[(e.get('phase_exponent',0)*(1-r))%4 for r in range(4)])
+                phase[b]=tuple((a+c)%4 for a,c in zip(phase[b],extra))
+        edges=f['edges'];used=[];unaries=[];bound=0
+        for path in f['trajectories']:
+            at=0;op=ce.ident(m);extra=(0,)*4
+            for eid in path['edges']:
+                used.append(eid);ed=edges[eid];need(ed['id']==eid and ed['u']==at,'trajectory edge incidence');at=ed['v']
+                seg=independent.op_of(json.dumps(ed['one_coordinate_literal_circuit']),m);op=op.then(seg)
+                need(seg.tab==tuple(tuple(t)for t in ed['one_coordinate_tableau']),'edge actual signed operator')
+                extra=tuple((a+b)%4 for a,b in zip(extra,ed['extra_global_phase_exponent_by_f_mod4']))
+                unaries.extend(ed['source_event_ordinals'])
+            need(at==0,'path endpoint Z boundary')
+            bank=labels.index(path['initial_bank']);need(bank==path['final_bank'],'physical strand transport includes swaps')
+            need(op.tab==ops[bank].tab and stable(op.circuit)==stable(ops[bank].circuit) and extra==phase[bank],
+                 'independent exact all-f literal holonomy circuit and tensor phase traversal')
+            r=rank(x for x,z,p in op.tab[m:]);need(r==path['native_holonomy_arity_per_f'],'independent holonomy native rank')
+            Z=tuple(1<<(m+i) for i in range(m));GZ=tuple(x|(z<<m) for x,z,p in op.tab[m:])
+            need(rank(Z+GZ)-m==r,'independent Lagrangian distance')
+            bound+=r
+        need(sorted(used)==list(range(len(edges))),'edge-disjoint exhaustive path partition')
+        need(sorted(unaries)==[i for i,e in enumerate(events) if e['kind'] not in ('ADD','SCALE','BANK_SWAP')],'every actual unary assigned to one edge')
+        mass=sum(e['rank_per_f'] for e in events if e['kind']=='NATIVE')
+        need(bound==f['trajectory_floor_per_f'] and bound<=mass==f['original_native_mass'],'trajectory floor and invoice')
+        if f['family'].startswith('PAULI'):need(bound==mass==f['stock'],'sharp Pauli finite bound')
+        results.append(dict(family=f['family'],q=f['q'],floor=bound,mass=mass,stock=f['stock'],edges=len(edges),paths=n))
+    return results
+def controls():
+    cert=json.loads((T/'TRAJECTORY-CERTIFICATES.json').read_text());rejected=[]
+    try:ce.diag(2,(2,0),(0,0))
+    except AssertionError:rejected.append(dict(control='legacy checker live under -O',error='nonsymmetric Clifford phase rejected'))
+    else:raise ValueError('retained legacy source assertions disabled')
+    bad=copy.deepcopy(cert);bad['fixtures'][0]['trajectories'][0]['edges'].pop(0)
+    for name,value in [('omitted trajectory edge',bad)]:
+        try:trajectory_checks(value)
+        except ValueError as e:rejected.append(dict(control=name,error=str(e)))
+        else:raise ValueError('negative control accepted: '+name)
+    bad=copy.deepcopy(cert);bad['fixtures'][0]['edges'][0]['extra_global_phase_exponent_by_f_mod4'][2]^=1
+    try:trajectory_checks(bad)
+    except ValueError as e:rejected.append(dict(control='f2-only wrong holonomy phase',error=str(e)))
+    else:raise ValueError('negative control accepted: wrong holonomy tensor phase')
+    return rejected
+def cubic_checks():
+    CUB=R/'general-clifford-retiming/order-three-response'
+    manifest=json.loads((CUB/'MANIFEST.json').read_text())
+    for x in manifest['files']:need(sha(CUB/x['path'])==x['sha256'],'cubic manifest pin '+x['path'])
+    raw=(CUB/'CUBIC.json').read_bytes();need(raw==(CUB/'CUBIC-OPTIMIZED.json').read_bytes(),'cubic normal/-O bytes')
+    data=json.loads(raw);zero=(Fraction(0),Fraction(0));one=(Fraction(1),Fraction(0))
+    def add(a,b):return a[0]+b[0],a[1]+b[1]
+    def mul(a,b):return a[0]*b[0]-a[1]*b[1],a[0]*b[1]+a[1]*b[0]
+    def sumg(xs):
+        v=zero
+        for x in xs:v=add(v,x)
+        return v
+    def mm(a,b):return [[sumg(mul(a[i][k],b[k][j])for k in range(len(a)))for j in range(len(a))]for i in range(len(a))]
+    def eye(n):return [[one if i==j else zero for j in range(n)]for i in range(n)]
+    def tensor(a,b):return [[mul(a[i][j],b[k][l])for j in range(len(a))for l in range(len(b))]for i in range(len(a))for k in range(len(b))]
+    def matrix(op):
+        cols=[]
+        for j in range(1<<op.n):
+            col,d=op.zero_state(j);cols.append([(Fraction(a,1<<d),Fraction(b,1<<d))for a,b in col])
+        return [list(x)for x in zip(*cols)]
+    J=[[tuple(Fraction(x)for x in z)for z in row]for row in data['base_matrix']]
+    need(sumg(J[i][i]for i in range(2))==(Fraction(-1),Fraction(0)),'cubic base trace')
+    need(mm(mm(J,J),J)==eye(2),'cubic base order')
+    current=[[one]];rows=[]
+    for f in data['fixtures']:
+        size=f['f'];current=tensor(current,J)
+        op=independent.op_of(json.dumps(f['literal_circuit']),size);need(matrix(op)==current,'independent every-entry cubic tensor circuit')
+        need(op.tab==tuple(tuple(t)for t in f['signed_tableau']),'cubic signed tableau')
+        need(rank(x for x,z,p in op.tab[size:])==size==f['native_B_rank'],'cubic actual native arity')
+        dim=1<<size;A2=mm(current,current);need(mm(A2,current)==eye(dim),'independent tensor cubic order')
+        residual=[[sumg((current[i][j],A2[i][j],one if i==j else zero))for j in range(dim)]for i in range(dim)]
+        need(all(v==zero for row in residual for v in row)==(size==1),'quadratic fails beyond tensor base')
+        if size==2:
+            need(sumg(residual[i][i]for i in range(dim))==(Fraction(6),Fraction(0)),'f2 nonzero quadratic trace control')
+            wrong=[[mul(v,(Fraction(0),Fraction(-1)))for v in row]for row in current]
+            need(mm(mm(wrong,wrong),wrong)!=eye(dim),'wrong single global phase fails actual cubic family')
+        rows.append(dict(f=size,native_rank=size,quadratic=(size==1)))
+    # Independent rational scalar SWAP matrix and omitted-sign control.
+    X=[[Fraction(i==j)for j in range(2)]for i in range(2)]
+    for d,s,c in ((0,1,1),(1,0,-1),(0,1,1)):X[d]=[a+c*b for a,b in zip(X[d],X[s])]
+    need(X==[[0,1],[-1,0]],'three ADD signed swap');X[1]=[-a for a in X[1]]
+    need(X==[[0,1],[1,0]],'sign-complete all-input scalar SWAP')
+    return dict(exact_cubic_fixtures=rows,written_trace_gate_review='Q(i) trace forces equal primitive multiplicities; nonzero Pauli fixed-character sum then rank(S-I)=2 and B-rank<=2.',scalar_swap_all_input_matrix=True)
+def main():
+    p=argparse.ArgumentParser();p.add_argument('--write',action='store_true');args=p.parse_args()
+    out=dict(status='PASS_INDEPENDENT_COMPLETED_GATES_REVIEW',kernel=kernel_checks(),trajectory=trajectory_checks(),negative_controls=controls(),cubic=cubic_checks(),executed_source_hashes=independent.EXECUTED,no_new_kappa=True)
+    out=json.loads(json.dumps(out));dest=HERE/'AUDIT.json'
+    if args.write:dest.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n')
+    else:need(json.loads(dest.read_text())==out,'saved independent audit differs')
+    print(out['status']);print('kernel actual cases',len(out['kernel']['actual_q2_q3_transport_bindings']),'rank grid',len(out['kernel']['finite_rank_identity_grid']),'trajectory cases',len(out['trajectory']))
+if __name__=='__main__':main()
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-escape/ALL-Q-TAIL-LEMMA.md b/research/coupled-tail-support-floor/source/coupled-tail-escape/ALL-Q-TAIL-LEMMA.md
new file mode 100644
index 0000000000..3a5533bfe8
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/coupled-tail-escape/ALL-Q-TAIL-LEMMA.md
@@ -0,0 +1,43 @@
+# Conditional repeating-tail extension
+
+The exact q3 suffix of the admitted word, starting at event119 just before
+the final independent-a J, has native mass12f, fixed preceding mass120f,
+and stock128f. All eight incoming physical fields are arbitrary. Full
+source-operator/phase/native-recipe and both serialized inverse checks pass.
+The single inputbank3/outputbank1 coefficient has arity8f. Thus its local
+support inequality is R_f+S_f>=8f, exactly the q2 mechanism with8 in place6.
+
+For an all-q tail obeying the same declared event pattern, put k=2q+1 and
+n=2q+2. The reverse-current calls on bank3 are on the distinct odd planes
+5,7,...,k. Other tail public readers do not alter the coefficient of the
+independent incoming bank3. Before Q recovery this coefficient is therefore
+
+    R_q=epsilon_q (N5 N7 ... Nk)(P5 P7 ... Pk),
+
+in this ordered ADDRESS product. Each P_s commutes with later distinct N_t
+for t!=s, permitting the N factors to be grouped on the left. The literal
+source scalar phase epsilon_q is retained; it has no effect on row support.
+For the frozen original J, W=F_k Q^-1 F_k^-1 is supported only on planes0/1
+and has native arity4f. The N5,N7,... factors act on disjoint planes outside
+that support. The ADDRESS word on the right is monomial. Hence
+
+    nu(W R_q)=4f+2(q-1)f=(2q+2)f=nf.
+
+The same support proof in PROOF.md gives R_f+S_f>=nf for any replacement
+of this exact local interface, including extra restored arbitrary dirt.
+The declared local inventory is final-a J2, q-1 reverse N2, Q4, final-k J2,
+mass(2q+6)f. If the whole admitted template has mass(stock+4)f, then the
+fixed prefix has mass(stock-n)f. It cannot get below stock through a
+bounded-in-f scan replacement of this suffix.
+
+The invoice is for the same-volume FULL-BANK native macroarities. It does
+not automatically reprice arbitrary partial-volume or striped calls; any
+runtime corollary also needs an ADD scan lower bound of a fixed positive
+multiple of the whole bank volume.
+
+This is a conditional tail lemma. It does not assert that a complete all-q
+selected supplier/controller or the stock+4 prefix profile has been newly
+compiled here. The exact complete suffix checks are q2 andq3. A changed
+earlier source/fresh cut, kernel support, entrance/exit or owner contract
+changes the hypotheses. Growing ADD counts/partial scan controllers need
+their separate full work/transfer analysis. No new kappa or BIT is claimed.
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-escape/HANDOFF.md b/research/coupled-tail-support-floor/source/coupled-tail-escape/HANDOFF.md
new file mode 100644
index 0000000000..925e547ffb
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/coupled-tail-escape/HANDOFF.md
@@ -0,0 +1,55 @@
+# Coupled-tail escape: exact local stop gate
+
+Outcome: no bounded-in-f full-bank cleanup replacement of the saved final-a
+suffix can cross stock at the fixed entrance/exit. No factorization census
+was run after this early gate. The caller's earlier source/fresh/coupled
+chronology remains an explicit constructive escape, rather than being
+declared globally impossible.
+
+For admitted q2 mass76, the exact event69 suffix has mass10 and the unchanged
+prefix mass66. Its complete six-by-six arbitrary-current-input matrix has
+one coefficient C=WR of native arity6f. For admitted q3 mass132, the event119
+suffix has mass12 and fixed prefix120; the analogous coefficient has arity8f.
+The endpoint stocks are72 and128. Complete local matrices, both actual
+serialized inverse orders, all source phases and used-only selected recipe
+pointers/embeddings are checked. The single-entry selected lowering only
+certifies row support; it is not advertised as a complete new cleanup.
+
+For a replacement whose total FULL-BANK native macroarity is R_f and binary
+ADD/accumulation count is S_f, maximum row support gives R_f+S_f>=6f(q2)
+or8f(q3). These exact inequalities permit finite-f savings paid by ADDs;
+with S_f bounded independently of f they force normalized native mass at
+least6/8, reaching stock after the fixed prefix. Arbitrary extra dirty banks
+restored and arbitrary monomial/scalar coupling topology are allowed by this
+support proof. No clean or correlated input promise is used.
+
+All arrays here have the same full bank volume. A runtime corollary needs
+each ADD scan to cost a fixed positive multiple of that volume. Partial,
+striped or fused-volume query models are not automatically priced by the
+unweighted histogram and need a separate weighted proof. Growing O(f) ADD
+counts are a conditional escape from the bounded-scan conclusion, not a
+claimed supplier or a globally impossible machine algorithm.
+
+`PROOF.md` gives the q2 local matrix/inverse and support argument.
+`ALL-Q-TAIL-LEMMA.md` derives the same n=2q+2 entry rank condition for an
+all-q tail with the declared reverse odd-plane pattern and stock+4 total
+profile. This is conditional on that tail/profile: this package has not
+newly compiled a complete all-q physical caller or native controller.
+Exact complete suffix checks are q2/q3 only.
+
+Reproduce from this directory:
+
+    python3 -B local_block.py
+    python3 -B -O local_block.py
+    python3 -B q3_tail.py
+    python3 -B -O q3_tail.py
+
+The initial optimized q3 readback was accidentally started before the
+normal writer had saved its output and failed with a missing receipt.
+It was rerun only after that file existed. This ordering failure and final
+normal/optimized outcomes are retained in `VALIDATION.json`; no source or
+mathematical check was skipped. q2 rejects an omitted reverse N5 (which
+would spuriously lower the coefficient6 to4) and discarding incomingbank3.
+
+All original frozen words remain unchanged. No BIT, push, PR, publication,
+owner or improved-kappa claim occurred. Final pins are in `MANIFEST.json`.
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-escape/LOCAL-BLOCK.json.gz b/research/coupled-tail-support-floor/source/coupled-tail-escape/LOCAL-BLOCK.json.gz
new file mode 100644
index 0000000000..c714f3d4e1
Binary files /dev/null and b/research/coupled-tail-support-floor/source/coupled-tail-escape/LOCAL-BLOCK.json.gz differ
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-escape/MANIFEST.json b/research/coupled-tail-support-floor/source/coupled-tail-escape/MANIFEST.json
new file mode 100644
index 0000000000..838b52032f
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/coupled-tail-escape/MANIFEST.json
@@ -0,0 +1,46 @@
+{
+  "files": [
+    {
+      "bytes": 2424,
+      "path": "ALL-Q-TAIL-LEMMA.md",
+      "sha256": "f3b8c42c0fe7d5c5a542e38fe0b3d14601c170959e18a45b60f26128703560b2"
+    },
+    {
+      "bytes": 3049,
+      "path": "HANDOFF.md",
+      "sha256": "25aa7a2e7408cca9402e34ba809bb8a487c79a4d012d5b8c4700dc81502741aa"
+    },
+    {
+      "bytes": 178927,
+      "path": "LOCAL-BLOCK.json",
+      "sha256": "aad2ee156a1f1e028b4e0329b4af1c38285f0be90c27da720d4bb71885c29294"
+    },
+    {
+      "bytes": 7537,
+      "path": "PROOF.md",
+      "sha256": "5b4300fb15364dbdb17974d6d0bb7d387a189ff814fd0293057ea2a47ac58587"
+    },
+    {
+      "bytes": 275744,
+      "path": "Q3-LOCAL-BLOCK.json",
+      "sha256": "3ad4d1bb498cd67588af0c0558c32b441b35dac56b9f3bb7001ae317fadc28fa"
+    },
+    {
+      "bytes": 1947,
+      "path": "VALIDATION.json",
+      "sha256": "e1b6ccf248fa65973645d41b34a7119f07df5d70e73dcfb36cf335ff2ec45e31"
+    },
+    {
+      "bytes": 11678,
+      "path": "local_block.py",
+      "sha256": "ac8abc744c616e60a221e8fadf1b590f2248f953bafcb2f61675d1c2541f7fe1"
+    },
+    {
+      "bytes": 4952,
+      "path": "q3_tail.py",
+      "sha256": "8fac76761684d17231ae4d766b7d9464a4ff5675e99038dfbd839bb8cf0d1082"
+    }
+  ],
+  "no_new_kappa": true,
+  "status": "FROZEN_LOCAL_COUPLED_CLEANUP_SUPPORT_BOUNDARY"
+}
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-escape/PROOF.md b/research/coupled-tail-support-floor/source/coupled-tail-escape/PROOF.md
new file mode 100644
index 0000000000..62c7762e8d
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/coupled-tail-escape/PROOF.md
@@ -0,0 +1,147 @@
+# Exact coupled-cleanup boundary at the q2 final-a cut
+
+The admitted q2 word has native rank mass76f and endpoint stock72f. Fix its
+physical prefix through event68. That prefix costs66f. Replace the entire
+suffix starting at event69, just before the final independent-a J query,
+by any new coupled cleanup on the current banks, with optional extra dirty
+banks restored. A strict native mass improvement below stock would require
+the replacement to have normalized native mass below6.
+
+The exact suffix is not cheap enough under a bounded whole-bank scan word.
+It contains an unavoidable original-current-input coefficient of native
+arity6f. The argument below changes neither source nor current boundary and
+permits arbitrary new scalar coupling topology within this local block.
+It is therefore distinct from the earlier fixed-ADD-graph frame certificate
+and isolated two-existing-site screens.
+
+## Complete arbitrary-input local target
+
+Use the actual six incoming physical banks x0,...,x5 at the event69 cut.
+They are arbitrary independent arrays: the fixed prefix is reversible, so
+its image is the full product space. No current public bank is promised zero
+or correlated with another one for purposes of this local replacement.
+
+Set F=F5, let J be the actual frozen phase-correct skew response, and define
+
+    A = F J F^-1,
+    Q = J^-1 (P1 N0^-1 J) J,
+    W = F Q^-1 F^-1,
+    R = -N5 P5.
+
+The chronological reverse-current step is P5, then N5, then the literal
+minus sign, hence its operator is exactly R in this order. The native
+arities of A,W,R are respectively2f,4f,2f. All complete circuits, phases,
+selected recipe pointers/embeddings and inverse pointers are retained from
+the unchanged admitted source. Both J applications are charged separately.
+
+Direct exact replay of events69 through90 gives the full local matrix
+(rows and columns ordered0,...,5):
+
+    [ A       0   0          0           0       0 ]
+    [ -WA     0   I-W        WR          I-W     0 ]
+    [ -A      0   I          0           0       0 ]
+    [ -AWA    A   A(I-W)     A(W-I)R     -AW     0 ]
+    [ 0       0   0          0           I       0 ]
+    [ 0       0   0          0           0       I ].
+
+In particular bank2 is changed by its required public isolation; it is not
+quietly restored to its incoming value. Banks4 and5 are arbitrary retained
+inputs. The matrix involves four mutable bank outputs, even if a proposed
+coupled controller calls only three of them active and treats bank2's ADD
+as an outside scalar reader. That choice cannot discard its coefficient.
+
+An explicit inverse, with y the six output banks, is
+
+    x0 = A^-1 y0,        x2 = y2+y0,       x4=y4, x5=y5,
+    z  = W^-1(y1-x2-x4)+y0+x2+x4,
+    x3 = R^-1 z,
+    x1 = A^-1 y3+z-y1+x4.
+
+These are unitary operator inverses with paid source recipes, not free
+inversion of a nonunit coefficient. The producer independently replays the
+actual serialized local inverse and checks both matrix product orders on
+all six arbitrary incoming columns in the exact all-f tensor-family algebra.
+
+## Native bill and the arity-six coefficient
+
+The suffix's entire native inventory is
+
+    final-a A:2, reverse-current N5:2, W:4, final-original-k A:2,
+
+so the local bill is10 and the unchanged prefix bill is66. There are no
+hidden SCALE gates in this suffix. Its source ADD and BANK_SWAP scans are
+listed in the receipt and remain paid. A new local replacement must realize
+the same matrix and the same current-input boundary; the current coefficient
+from inputbank3 to outputbank1 is exactly the single Clifford
+
+    C = W R = (F Q^-1 F^-1)(-N5 P5).
+
+Its B-block rank is6f. This is checked independently from the actual literal
+source circuits, including the minus sign and Gaussian phase. The receipt
+also lowers the coordinate operator to a rank6 selected Fourier child with
+explicit physical monomial adapters, then independently recompiles it.
+That recipe is only a witness for C's row support; it is not a completed
+cleanup factorization or a new recursive supplier.
+
+Because both monomial adapters preserve row support, each row of C_f has
+exactly2^(6f) nonzero original-address coefficients. The actual family is the
+saved scalar phase times C_1 tensorf, so this holds for every positive f,
+with no finite-f extrapolation and no scalar/permutation stand-in for C.
+
+## Support proof for any new local topology
+
+The native invoice here sums FULL-BANK query macroarities at the same bank
+volume V_f as the fixed source. Actual selected child embeddings and their
+primitive meaning must be retained. Partial-volume or striped queries do
+not automatically have this unweighted native histogram; repricing them
+requires a separate weighted argument.
+
+Consider the matrix of a proposed replacement on all current-bank and extra
+dirty-bank coordinates. Initially every row is an identity row with support1.
+If clean auxiliaries were expressly allowed, their zero coefficient rows
+would also satisfy this upper bound; no such promise is needed here.
+
+An invertible monomial adapter, address permutation, field SCALE or literal
+bank routing does not increase maximum row support. A native Clifford of
+actual B-rank r has2^r nonzero entries per row, and therefore multiplies the
+maximum support by at most2^r. A scalar binary ADD increases it by at most2.
+A reversible COPY/target accumulation with two input rows is such a counted
+binary operation; there is no free fan-in COPY. Arbitrary scalar coefficients
+and cancellations can decrease support, not violate this upper bound.
+
+Consequently, if R_f is the sum of all native B-ranks in the replacement
+and S_f counts its elementary binary ADD/accumulation scans, every output
+row has support at most2^(R_f+S_f). The exact outputbank1/inputbank3 block
+already has2^(6f) nonzeros in each row, so necessarily
+
+    R_f + S_f >= 6f.
+
+This argument applies to arbitrary scalar/monomial coupling topology and
+any number of restored arbitrary dirty registers. It does not assume that
+the replacement intermediate coefficients are single Clifford rays, that
+the old ADD graph is preserved, or that edits are row-confined. Additional
+dirty inputs cannot change the required coefficient on the old inputbank3.
+
+For a fixed local scan word with S_f=O(1), this implies
+
+    liminf_(f->infinity) R_f/f >= 6.
+
+Adding the fixed66f prefix prevents a total normalized mass below72 at this
+cut. In the present integer-per-f query architecture, a candidate saving at
+least6 from the original76 bill would use local mass at most4; it would
+instead require S_f>=2f. This is the optimistic charge gate, before owner,
+controller, COPY, precision or outer moment costs are added.
+
+This is not a pointwise native-only bound6f for one finite f: the exact
+finite-f statement is R_f>=6f-S_f. A growing O(f) ADD word is a conditional
+escape from the bounded-scan conclusion. Its full scan costs belong to a
+separate transfer analysis. Here an elementary ADD is explicitly a scan
+of the same full bank of volume V_f=2^(12f); each scalar/address operation
+is charged, rather than hidden in a projected or partial-bank operation.
+No exclusion of a different partial/fused-scan controller is inferred.
+
+Changing an earlier source/fresh-progress cut, the physical entrance/exit
+gauges, or the target contract changes this local matrix and reopens the
+problem. The weaker inequality does not prove the local minimum is6 or10,
+nor say that no other coupled caller can improve the stock. No expensive
+enumeration was run after the gate. No BIT or improved kappa is asserted.
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-escape/Q3-LOCAL-BLOCK.json.gz b/research/coupled-tail-support-floor/source/coupled-tail-escape/Q3-LOCAL-BLOCK.json.gz
new file mode 100644
index 0000000000..98f5394701
Binary files /dev/null and b/research/coupled-tail-support-floor/source/coupled-tail-escape/Q3-LOCAL-BLOCK.json.gz differ
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-escape/VALIDATION.json b/research/coupled-tail-support-floor/source/coupled-tail-escape/VALIDATION.json
new file mode 100644
index 0000000000..bee9a64974
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/coupled-tail-escape/VALIDATION.json
@@ -0,0 +1,80 @@
+{
+  "commands": [
+    {
+      "argv": [
+        "python3",
+        "-B",
+        "local_block.py",
+        "--write"
+      ],
+      "exit_code": 0
+    },
+    {
+      "argv": [
+        "python3",
+        "-B",
+        "-O",
+        "local_block.py"
+      ],
+      "exit_code": 0
+    },
+    {
+      "argv": [
+        "python3",
+        "-B",
+        "q3_tail.py",
+        "--write"
+      ],
+      "exit_code": 0
+    },
+    {
+      "argv": [
+        "python3",
+        "-B",
+        "-O",
+        "q3_tail.py"
+      ],
+      "exit_code": 0
+    }
+  ],
+  "earlier_attempt": {
+    "argv": [
+      "python3",
+      "-B",
+      "-O",
+      "q3_tail.py"
+    ],
+    "error": "FileNotFoundError for Q3-LOCAL-BLOCK.json: readback was started before normal writer finished; final rerun after file creation passed.",
+    "exit_code": 1
+  },
+  "files": [
+    {
+      "path": "local_block.py",
+      "sha256": "ac8abc744c616e60a221e8fadf1b590f2248f953bafcb2f61675d1c2541f7fe1"
+    },
+    {
+      "path": "LOCAL-BLOCK.json",
+      "sha256": "aad2ee156a1f1e028b4e0329b4af1c38285f0be90c27da720d4bb71885c29294"
+    },
+    {
+      "path": "PROOF.md",
+      "sha256": "5b4300fb15364dbdb17974d6d0bb7d387a189ff814fd0293057ea2a47ac58587"
+    },
+    {
+      "path": "q3_tail.py",
+      "sha256": "8fac76761684d17231ae4d766b7d9464a4ff5675e99038dfbd839bb8cf0d1082"
+    },
+    {
+      "path": "Q3-LOCAL-BLOCK.json",
+      "sha256": "3ad4d1bb498cd67588af0c0558c32b441b35dac56b9f3bb7001ae317fadc28fa"
+    },
+    {
+      "path": "ALL-Q-TAIL-LEMMA.md",
+      "sha256": "f3b8c42c0fe7d5c5a542e38fe0b3d14601c170959e18a45b60f26128703560b2"
+    }
+  ],
+  "no_active_processes": true,
+  "no_new_kappa": true,
+  "proof_domain": "Exact q2/q3 local current-input matrices; conditional all-q tail lemma only. R_f is full-bank same-volume native macroarity; partial/striped volume repricing outside.",
+  "status": "PASS_FINAL_Q2_Q3_LOCAL_MATRICES_INVERSES_PHASES_RECIPES_SUPPORT_WITNESSES"
+}
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-escape/local_block.py b/research/coupled-tail-support-floor/source/coupled-tail-escape/local_block.py
new file mode 100644
index 0000000000..7395bf4486
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/coupled-tail-escape/local_block.py
@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""Exact arbitrary-input q2 cleanup block and its single-entry support gate.
+Apache-2.0. Substantial OpenAI Codex assistance. No new caller/kappa.
+"""
+from pathlib import Path
+from collections import Counter
+import argparse, copy, hashlib, json, sys
+sys.dont_write_bytecode = True
+HERE = Path(__file__).resolve().parent
+RUNDIR = HERE.parent
+PINS = {
+    'two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json': '30d3f569d91304856118796f0c586176d0ad961eff70b09c78fce7532392101f',
+    'two-site-continuation/MANIFEST.json': '44f1e264b3087ab8fdb08b4cd6e27befefbba380852b0119321724b7bc41b5da',
+    'folded-fusion/SIMPLIFIED-FUSIONS.json': '4491cfe2a1f3e48510b33403b9b50c704865c3b1dc6d659ef5157840654e8fc3',
+    'caller-joint/joint_algebra.py': '5782033e347c9b10ad47c01ed12a0a52ea07e901fa9e8f7aa9d3a2a928327232',
+    'caller-joint/validate_recipe_links.py': '7457b3672d5a73c584d2073b5d3312e6429fd3f433151f15f8f07da33aa4c59a',
+}
+for relative, expected in PINS.items():
+    if hashlib.sha256((RUNDIR / relative).read_bytes()).hexdigest() != expected:
+        raise ValueError('frozen source pin: ' + relative)
+sys.path.insert(0, str(RUNDIR / 'caller-joint'))
+from joint_algebra import *
+from validate_recipe_links import compile_literal, compile_recipe, embedding_circuit
+
+
+def extra(e):
+    return tuple(e.get('extra_global_phase_exponent_by_f_mod4',
+                       [e.get('phase_exponent', 0)*(1-r) % 4 for r in range(4)]))
+
+
+def produce():
+    admitted = json.loads((RUNDIR / 'two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json').read_text())
+    source = json.loads((RUNDIR / 'folded-fusion/SIMPLIFIED-FUSIONS.json').read_text())
+    f = next(f for f in admitted['fixtures'] if f['q'] == 2)
+    old = next(f for f in source['fixtures'] if f['q'] == 2)
+    E = f['events']; m, n, cut = f['ambient_arity'], f['banks'], 69
+    need(E[cut]['label'] == 'final independent a J query', 'exact local physical entrance cut')
+    suffix = copy.deepcopy(E[cut:])
+    inverse = copy.deepcopy(f['inverse_events'][:len(suffix)])
+    compiled = {}
+    used_pool = {}
+    # Every unchanged suffix unary retains an explicit source-event binding.
+    for direction, events in [('forward', suffix), ('inverse', inverse)]:
+        for e in events:
+            if e['kind'] in ('ADD', 'SCALE', 'BANK_SWAP'):
+                continue
+            source_event = old['events'][e['source_event_ordinal']]
+            g = qc.decode(source_event, m)
+            if e['source_operator_is_adjoint']:
+                g = g.inv()
+            e['x_monomial'] = g.data()
+            op = compile_literal(e['one_coordinate_literal_circuit'], m)
+            need(op.tab == tuple(tuple(t) for t in e['one_coordinate_tableau']), 'actual signed source unary')
+            need(ce.rank(x for x,z,p in op.tab[m:]) == e['rank_per_f'], 'actual source unary native rank')
+            # The physical definition is compared with the pinned symbolic
+            # coordinate definition using a separately constructed circuit.
+            from joint_prefix import inverse_transpose
+            circ=[]
+            for i,a in enumerate(g.alpha):
+                if a%4 == 1:circ.append(('C',1<<i,1))
+                elif a%4 == 2:circ.extend([('C',1<<i,1)]*2)
+                elif a%4 == 3:circ.append(('C',1<<i,-1))
+            for i,row in enumerate(g.quad):
+                for j in range(i+1,m):
+                    if row>>j&1:circ.extend([('C',1<<i,1),('C',1<<j,1),('C',(1<<i)|(1<<j),-1)])
+            circ.extend([('P',inverse_transpose(g.rows)),('D',(0,)*m,tuple(2*((g.offset>>i)&1)for i in range(m))),
+                         ('phase',(g.constant+g.global_phase)%4)])
+            same(compile_literal(circ,m), op, 'actual source unary exact Gaussian phase')
+            need(extra(e) == tuple(g.global_phase*(1-r)%4 for r in range(4)), 'actual all-f source tensor phase correction')
+            if e['kind'] == 'NATIVE':
+                key=e['native_recipe_id']; rec=f['native_recipe_pool'][key]
+                local_n=len(rec['one_coordinate_tableau'])//2
+                selected=compile_recipe(rec['selected_native_recipe'],local_n)
+                full=compile_literal(embedding_circuit(selected.circuit,e['recipe_embedding'],m),m)
+                same(full,op,'every used forward/inverse selected source recipe and embedding')
+                need(tuple(rec['extra_global_phase_exponent_by_f_mod4'])==extra(e),'selected source recipe tensor-phase correction')
+                used_pool[key]=rec
+            compiled[(direction,e['label'])] = op
+    M = qc.replay(suffix,n,m); Mi = qc.replay(inverse,n,m)
+    need(mm(M,Mi) == mm(Mi,M) == eye(n,m), 'complete serialized suffix inverse both orders on every arbitrary input')
+    A = qc.decode(next(e for e in suffix if e['label']=='final independent a J query'),m)
+    W = qc.decode(next(e for e in suffix if e['label']=='dual Q1 recovery'),m)
+    reverse_events = [e for e in suffix if e['label'] in ('w reverse2 ADDRESS','w reverse2 selected native2','final extraction D_final inverse sign')]
+    RR = qc.identity(m)
+    for e in reverse_events:RR = qc.decode(e,m) @ RR
+    F5 = prefix(m,5); Q = j_operator(m).inv() @ plane_swap(m,0,1) @ n_pair(m,0).inv() @ j_operator(m) @ j_operator(m)
+    need(mono(A) == mono(F5@j_operator(m)@F5.inv()), 'actual A definition')
+    need(mono(W) == mono(F5@Q.inv()@F5.inv()), 'actual W definition')
+    minus = qc.Mono(qc.identity(m).rows,0,(0,)*m,(0,)*m,0,2)
+    need(mono(RR) == mono(minus@n_pair(m,5)@plane_swap(m,0,5)), 'actual reverse-current operator and minus phase')
+    I = mono(qc.identity(m)); Z = {}; IW = add(I,scale(mono(W),-1))
+    expected = [[{}for _ in range(n)]for _ in range(n)]
+    expected[0][0] = mono(A)
+    expected[1][0] = scale(mono(W@A),-1); expected[1][2] = IW; expected[1][3] = mono(W@RR); expected[1][4] = IW
+    expected[2][0] = scale(mono(A),-1); expected[2][2] = I
+    expected[3][0] = scale(mono(A@W@A),-1); expected[3][1] = mono(A)
+    expected[3][2] = product(mono(A),IW)
+    expected[3][3] = product(mono(A),product(scale(IW,-1),mono(RR)))
+    expected[3][4] = scale(mono(A@W),-1)
+    expected[4][4] = I; expected[5][5] = I
+    need(M == expected, 'literal entire local block equals six-by-six symbolic operator target')
+    need(len(M[1][3]) == 1 and qc.rank(next(iter(M[1][3])).polar()) == 6, 'single actual arity-six input3/output1 coefficient')
+    # Independently lower that exact coefficient to certify its uniform row
+    # support. This recipe is a witness, not a proposed complete cleanup.
+    C = ce.ident(m); ce_extra = [0]*4
+    for e in reverse_events + [next(e for e in suffix if e['label']=='dual Q1 recovery')]:
+        C = C.then(compile_literal(e['one_coordinate_literal_circuit'],m))
+        ce_extra = [(x+y)%4 for x,y in zip(ce_extra,extra(e))]
+    need(ce.rank(x for x,z,p in C.tab[m:]) == 6, 'coefficient physical B-rank6')
+    recipe, lowered = ce.lower_child(C)
+    need(recipe['rank'] == 6, 'explicit selected Fourier rank for support witness')
+    same(lowered,C,'support-witness selected child exact Gaussian phase')
+    same(compile_recipe(recipe,m),C,'independent support-witness recipe recompilation')
+    before = sum(e['rank_per_f']for e in E[:cut]if e['kind']=='NATIVE')
+    local_hist = Counter(e['rank_per_f']for e in suffix if e['kind']=='NATIVE')
+    local = sum(r*c for r,c in local_hist.items())
+    need(before == 66 and local == 10 and before+local == f['native_mass'] == 76, 'complete unchanged-prefix plus local-native bill')
+    need(f['stock'] == 72 and f['stock']-before == 6, 'exact below-stock local threshold')
+    mutant = [[dict(v) for v in row] for row in M];mutant[1][3] = {}
+    need(mutant != M, 'discarding arbitrary incoming bank3 changes an original coefficient')
+    omitted_reverse = [e for e in suffix if e['label'] != 'w reverse2 selected native2']
+    wrong = qc.replay(omitted_reverse,n,m)
+    need(wrong != M and len(wrong[1][3]) == 1, 'omitting the reverse-current native query changes the arbitrary-input block')
+    need(qc.rank(next(iter(wrong[1][3])).polar()) == 4, 'omitted reverse query spuriously lowers the witness rank')
+    need(not any(e['kind']=='SCALE'for e in suffix),'actual suffix needs no hidden SCALE cancellation')
+    return dict(status='PASS_EXACT_COUPLED_CLEANUP_BLOCK_AND_SUPPORT_BOUNDARY', no_new_kappa=True,
+                producer_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+                source_pins=[dict(path=str(RUNDIR/p),sha256=h)for p,h in PINS.items()],
+                q=2,banks=n,ambient_arity=m,cut_event_ordinal=cut,cut_label=E[cut]['label'],
+                unchanged_prefix_native_mass=before,local_native_histogram=dict(sorted(local_hist.items())),local_native_mass=local,
+                complete_mass=76,endpoint_stock=72,strict_improvement_requires_local_native_mass_less_than=6,
+                events=suffix,inverse_events=inverse,native_recipe_pool=used_pool,
+                all_original_local_columns=n,literal_inverse_orders=2,
+                complete_local_matrix=sm(M),complete_local_inverse=sm(Mi),
+                operators=dict(A=A.data(),W=W.data(),R=RR.data()),
+                unavoidable_entry=dict(row=1,column=3,operator=serial(M[1][3]),native_arity_per_f=6,
+                                      one_coordinate_tableau=C.tab,one_coordinate_literal_circuit=C.circuit,
+                                      extra_global_phase_exponent_by_f_mod4=ce_extra,
+                                      support_witness_selected_native_recipe=recipe,
+                                      role='Only certifies row support of an entry; not an executed new cleanup/native invoice.'),
+                all_f_support_inequality='sum_native_arities_R_f + binary_fullbank_ADD_count_S_f >=6f',
+                constant_scan_consequence='For this exact local interface, bounded-in-f ADD count implies liminf R_f/f>=6; unchanged prefix66f then gives asymptotic total>=72f.',
+                finite_f_scope='R_f>=6f-S_f, not a pointwise native-only6f lower bound when S_f is positive.',
+                non_native_event_counts=dict(Counter(e['kind']for e in suffix if e['kind']!='NATIVE')),
+                negative_controls=['Discarding arbitrary incoming bank3 deletes a nonzero arity6 coefficient and is rejected.',
+                                   'Omitting reverse-current N5 changes the exact matrix and spuriously lowers entry rank6 to4; rejected.'],
+                limits=['Any replacement must realize this exact current-input matrix on all arbitrary banks, not only a clean/correlated subspace.',
+                        'Arbitrary extra dirty registers restored are permitted by the support proof; their identity coefficient rows start with support1.',
+                        'Native rank mass lower bound uses monomial adapters/scalars of row support1 and binary ADD/COPY gates, counting every support-doubling scan.',
+                        'Growing O(f) ADD counts, partial/fused scan machine models, changed input/output gauges or an earlier fresh/source/coupled cut require separate analysis.',
+                        'No expensive enumeration, new full cleanup factorization, supplier, owner, BIT, recurrence or kappa admission.'])
+
+
+def main():
+    p = argparse.ArgumentParser();p.add_argument('--write',action='store_true');a=p.parse_args()
+    result=json.loads(json.dumps(produce()));out=HERE/'LOCAL-BLOCK.json'
+    if a.write:out.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n')
+    else:need(json.loads(out.read_text())==result,'saved coupled local block')
+    print(result['status'],'fixed66 + local10; unavoidable entry6f; no bounded-scan local bill<6f')
+
+
+if __name__=='__main__':main()
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-escape/q3_tail.py b/research/coupled-tail-support-floor/source/coupled-tail-escape/q3_tail.py
new file mode 100644
index 0000000000..7cf3206bb1
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/coupled-tail-escape/q3_tail.py
@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Exact q3 suffix and the same isolated entry support boundary.
+Apache-2.0. Substantial OpenAI Codex assistance. No all-q caller claim.
+"""
+from pathlib import Path
+import argparse,copy,hashlib,json,sys
+sys.dont_write_bytecode=True
+HERE=Path(__file__).resolve().parent
+sys.path.insert(0,str(HERE))
+import local_block as base
+from joint_algebra import *
+from validate_recipe_links import compile_literal,compile_recipe,embedding_circuit
+
+
+def produce():
+    R=base.RUNDIR
+    a=next(f for f in json.loads((R/'two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json').read_text())['fixtures']if f['q']==3)
+    b=next(f for f in json.loads((R/'folded-fusion/SIMPLIFIED-FUSIONS.json').read_text())['fixtures']if f['q']==3)
+    cut=next(i for i,e in enumerate(a['events'])if e['label']=='final independent a J query')
+    E=copy.deepcopy(a['events'][cut:]);Ei=copy.deepcopy(a['inverse_events'][:len(E)]);n,m=8,16;pool={}
+    for events in(E,Ei):
+        for e in events:
+            if e['kind']in('ADD','SCALE','BANK_SWAP'):continue
+            old=b['events'][e['source_event_ordinal']];g=qc.decode(old,m)
+            op=compile_literal(old['one_coordinate_literal_circuit'],m)
+            ep=tuple(old['phase_exponent']*(1-r)%4 for r in range(4))
+            if e['source_operator_is_adjoint']:g=g.inv();op=op.adjoint();ep=tuple(-x%4 for x in ep)
+            e['x_monomial']=g.data();actual=compile_literal(e['one_coordinate_literal_circuit'],m)
+            same(actual,op,'q3 actual source unary signed operator and Gaussian phase')
+            need(base.extra(e)==ep,'q3 all-f source phase')
+            if e['kind']=='NATIVE':
+                rec=a['native_recipe_pool'][e['native_recipe_id']];d=len(rec['one_coordinate_tableau'])//2
+                selected=compile_recipe(rec['selected_native_recipe'],d)
+                full=compile_literal(embedding_circuit(selected.circuit,e['recipe_embedding'],m),m)
+                same(full,actual,'q3 current forward/inverse selected recipe')
+                need(tuple(rec['extra_global_phase_exponent_by_f_mod4'])==ep,'q3 selected recipe all-f phase')
+                pool[e['native_recipe_id']]=rec
+    M=qc.replay(E,n,m);Mi=qc.replay(Ei,n,m)
+    need(mm(M,Mi)==mm(Mi,M)==eye(n,m),'q3 serialized entire local inverse bothorders')
+    reverse=[e for e in E if e['label'].startswith('w reverse')and e['kind']!='ADD' or e['label']=='final extraction D_final inverse sign']
+    W=next(e for e in E if e['label']=='dual Q1 recovery');Rop=qc.identity(m)
+    C=ce.ident(m);phase=[0]*4
+    for e in reverse+[W]:
+        C=C.then(compile_literal(e['one_coordinate_literal_circuit'],m));phase=[(x+y)%4 for x,y in zip(phase,base.extra(e))]
+    for e in reverse:Rop=qc.decode(e,m)@Rop
+    need(M[1][3]==mono(qc.decode(W,m)@Rop),'q3 exact single WR incoming3/output1 coefficient')
+    need(len(M[1][3])==1 and ce.rank(x for x,z,p in C.tab[m:])==8,'q3 native arity8 entry')
+    rec,compiled=ce.lower_child(C);same(compiled,C,'q3 support witness exact Gaussian lowering');same(compile_recipe(rec,m),C,'q3 support recipe recompilation')
+    need(rec['rank']==8,'q3 support witness Fourier rank')
+    local=sum(e['rank_per_f']for e in E if e['kind']=='NATIVE');before=a['native_mass']-local
+    need((cut,local,before,a['stock'])==(119,12,120,128),'q3 exact local/full invoice')
+    return dict(status='PASS_Q3_COUPLED_SUFFIX_SUPPORT_GATE',no_new_kappa=True,producer_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+                q=3,banks=n,ambient_arity=m,cut_event_ordinal=cut,unchanged_prefix_native_mass=before,local_native_mass=local,whole_native_mass=132,stock=128,
+                events=E,inverse_events=Ei,native_recipe_pool=pool,complete_local_matrix=sm(M),complete_local_inverse=sm(Mi),
+                unavoidable_entry=dict(row=1,column=3,operator=serial(M[1][3]),native_arity_per_f=8,one_coordinate_tableau=C.tab,
+                                      one_coordinate_literal_circuit=C.circuit,extra_global_phase_exponent_by_f_mod4=phase,support_witness_recipe=rec),
+                support_inequality='R_f+S_f>=8f; fixed120f prefix prevents total<128f for bounded-in-f ADD scans.',
+                source_pins=[dict(path=str(R/p),sha256=h)for p,h in base.PINS.items()],base_producer_sha256=hashlib.sha256(Path(base.__file__).read_bytes()).hexdigest(),
+                scope='Exact q3 local suffix on all8 arbitrary incoming banks and both serialized inverse orders; conditional all-q tail lemma is separate, not an all-q complete caller.')
+
+
+def main():
+    p=argparse.ArgumentParser();p.add_argument('--write',action='store_true');a=p.parse_args();out=json.loads(json.dumps(produce()));target=HERE/'Q3-LOCAL-BLOCK.json'
+    if a.write:target.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n')
+    else:need(json.loads(target.read_text())==out,'saved q3 local suffix')
+    print(out['status'],'prefix120/local12/entry8/stock128')
+
+
+if __name__=='__main__':main()
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-independent-review/AUDIT.json b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/AUDIT.json
new file mode 100644
index 0000000000..0df2fbffb2
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/AUDIT.json
@@ -0,0 +1,95 @@
+{
+  "cases": [
+    {
+      "all_current_columns": 6,
+      "banks": 6,
+      "controls": [
+        "actual reverse-query omission rejected",
+        "f2-only native phase mutant rejected"
+      ],
+      "cut": 69,
+      "literal_inverse_orders": 2,
+      "local_histogram": {
+        "2": 3,
+        "4": 1
+      },
+      "local_native_mass": 10,
+      "prefix_native_histogram": {
+        "2": 33
+      },
+      "prefix_native_mass": 66,
+      "q": 2,
+      "single_entry_arity": 6,
+      "single_entry_row_support": "2^(6f) in every row; exact Bruhat factors are monomial/native/monomial",
+      "stock": 72,
+      "used_native_recipes": 8,
+      "whole_native_mass": 76
+    },
+    {
+      "all_current_columns": 8,
+      "banks": 8,
+      "controls": [
+        "actual reverse-query omission rejected",
+        "f2-only native phase mutant rejected"
+      ],
+      "cut": 119,
+      "literal_inverse_orders": 2,
+      "local_histogram": {
+        "2": 4,
+        "4": 1
+      },
+      "local_native_mass": 12,
+      "prefix_native_histogram": {
+        "2": 60
+      },
+      "prefix_native_mass": 120,
+      "q": 3,
+      "single_entry_arity": 8,
+      "single_entry_row_support": "2^(8f) in every row; exact Bruhat factors are monomial/native/monomial",
+      "stock": 128,
+      "used_native_recipes": 8,
+      "whole_native_mass": 132
+    }
+  ],
+  "conditional_tail_rank_grid": [
+    {
+      "coefficient_rank": 6,
+      "q": 2
+    },
+    {
+      "coefficient_rank": 8,
+      "q": 3
+    },
+    {
+      "coefficient_rank": 10,
+      "q": 4
+    },
+    {
+      "coefficient_rank": 12,
+      "q": 5
+    },
+    {
+      "coefficient_rank": 14,
+      "q": 6
+    },
+    {
+      "coefficient_rank": 16,
+      "q": 7
+    },
+    {
+      "coefficient_rank": 18,
+      "q": 8
+    },
+    {
+      "coefficient_rank": 20,
+      "q": 9
+    },
+    {
+      "coefficient_rank": 22,
+      "q": 10
+    }
+  ],
+  "no_new_kappa": true,
+  "scope": "Exact q2/q3 current-input suffixes, all-f phases; conditional all-q tail pattern only. Support inequality charges every elementary binary ADD and same-volume full-bank native macro. No pointwise native-only floor or partial-volume claim.",
+  "status": "PASS_INDEPENDENT_COUPLED_TAIL_ENTRY_PHASE_INVOICE_AND_SUPPORT_REVIEW"
+}
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-independent-review/HANDOFF.md b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/HANDOFF.md
new file mode 100644
index 0000000000..55a18eba18
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/HANDOFF.md
@@ -0,0 +1,38 @@
+# Coupled-tail independent audit
+
+No defect found in the covered exact q2/q3 suffixes, support lemma or
+conditional full-scan bridge. See `REVIEW.md` and `AUDIT.json`.
+
+The independent literal replay verifies all current-input columns, both
+serialized inverse orders, native recipes/embeddings, Gaussian f residues,
+the complete q2 symbolic matrix and explicit inverse, and exact WR entry.
+The q2 entrance is cut69: prefix66/local10/entry6/stock72. The q3 entrance
+is cut119: prefix120/local12/entry8/stock128. Source slices are bound to the
+frozen admitted full word. The previous complete-prefix semantic audit is
+retained; its native invoice is recounted here.
+
+The precise local bound is R_f+S_f>=6f/8f with EVERY binary full-bank
+ADD/COPY accumulation counted. It is not a pointwise pure-native floor.
+Arbitrary restored dirty banks are allowed. The support-only child recipe
+is not counted as an executed new query. Omitting a reverse native query
+and mutating only the f2 phase residue are rejecting controls.
+
+The full-scan corollary assumes actual work>=c V_f S_f and total available
+budget o(V_f f), or O(V_f f^lambda P(f)) with P=o(f^(1-lambda)). Under
+equal-volume full-bank normalization the resulting limiting moment also
+fails strictly for every positive b. No unrestricted precision factor,
+partial-volume primitive or free fused scan is inferred. The all-q tail
+extension is conditional; complete exact suffix fixtures remain q2/q3.
+
+Reproduce from this directory:
+
+```
+python3.12 -B audit_tail.py
+python3.12 -B -O audit_tail.py
+python3.12 -B validate_review.py
+python3.12 -B -O validate_review.py
+```
+
+Owned/source hashes are in MANIFEST.json and SOURCE-PINS.json. All previous
+reviews, producer inputs, primary checkout and publication/BIT resources
+remain untouched. No new supplier, global obstruction or kappa is claimed.
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-independent-review/MANIFEST.json b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/MANIFEST.json
new file mode 100644
index 0000000000..ac4d4abc42
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/MANIFEST.json
@@ -0,0 +1,42 @@
+{
+  "files": [
+    {
+      "bytes": 2255,
+      "path": "AUDIT.json",
+      "sha256": "c1b850bfdab5328a1ecaabf36400b4d49830131cb8eb6e0ed5c74ff5d975efe0"
+    },
+    {
+      "bytes": 1844,
+      "path": "HANDOFF.md",
+      "sha256": "fec073544043700346cd4601d646e2b68a07eeac6ee7d053f416e0a69527b9ba"
+    },
+    {
+      "bytes": 8008,
+      "path": "REVIEW.md",
+      "sha256": "dc3d42299d482d71bb06cb0d668ae6bfbc7bf3c6ba1068f840e706858b67123a"
+    },
+    {
+      "bytes": 8551,
+      "path": "SOURCE-PINS.json",
+      "sha256": "e86465b4fb10b3597cc6ec59ce8f24e828301683a5e7f8e1b51d646ae83dabc8"
+    },
+    {
+      "bytes": 695,
+      "path": "VALIDATION.json",
+      "sha256": "3b56a7d435fb88054ef73c4a1f26701cda45f7129e25d745323cceb35480467b"
+    },
+    {
+      "bytes": 9836,
+      "path": "audit_tail.py",
+      "sha256": "18f72f8e4e69595484304e1bacdb3d8f8bfc3f9bfad71aa1038adfb1808f955d"
+    },
+    {
+      "bytes": 882,
+      "path": "validate_review.py",
+      "sha256": "51c079b41571d73af9548fb23502117112d1ac3ac8f64a7149c6d997c1e6033f"
+    }
+  ],
+  "no_new_kappa": true,
+  "scope": "Independent exact q2/q3 coupled-tail entry/inverse/native phase review, conditional support/full-scan bridge; no all-q complete caller.",
+  "source_count": 33
+}
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-independent-review/REVIEW.md b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/REVIEW.md
new file mode 100644
index 0000000000..8a7212f5a4
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/REVIEW.md
@@ -0,0 +1,149 @@
+# Independent coupled-tail review
+
+No correctness defect was found within the declared current-input/full-bank
+macro interface. All source and prior review directories remain unchanged.
+This review covers the frozen `../coupled-tail-escape/` package and the
+conditional full-scan bridge in section4 of
+`../joint-threshold-screen/PROOF.md`; it does not independently review that
+screen's upstream candidate, selected-record or numerical planning claims.
+
+## Exact suffix and coefficient
+
+The local words are exact contiguous slices of the previously admitted
+complete source, including their serialized inverse slices. The q2 cut is
+event69, just before the final independent-a query; q3 is event119. Since
+the unchanged complete prefix is reversible on arbitrary fields, the local
+entrance fields are independent. No zero or correlation promise may be
+used by a replacement required to implement this full local interface.
+
+An independent literal Gaussian/tensor-family replay checks the entire
+local matrix, the saved inverse and both product orders. It also checks
+every actual native forward/inverse recipe, coordinate embedding, literal
+definition, signed tableau and four-residue phase correction; the recipe
+pool is used-only. The newly introduced symbolic `x_monomial` shadows are
+compared to the actual literal operators rather than used as unchecked
+replacements. The complete q2 six-row matrix in the source proof agrees,
+including bank2's public-isolation change and arbitrary retained banks4/5.
+The explicit prose inverse was independently assembled and agrees too.
+
+Let A=FJF^-1, W=FQ^-1F^-1 and R be the ordered reverse-current product.
+For both fixtures the output1/input3 block is exactly the single operator
+WR, with its actual Gaussian sign and tensor residues. In q2,
+`R=-N5 P5`; its order is the chronological P5, N5, then minus sign.
+Because W is confined to planes0/1 and has native rank4, the disjoint
+fresh N5 contributes2. Thus WR has rank6. The actual q3 reverse product
+contributes the two disjoint fresh planes5/7 and gives rank8. The literal
+support-witness recipes recompile to the coefficient with the exact
+Gaussian phase. They certify support; they are not added to the executed
+invoice as a new cleanup call.
+
+All native invoices are recounted from the actual complete source events:
+
+| q | Cut | Prefix | Local histogram | Local bill | Whole | Stock | Entry arity |
+| --- | ---: | ---: | --- | ---: | ---: | ---: | ---: |
+| 2 | 69 | 66 | H2=3,H4=1 | 10 | 76 | 72 | 6 |
+| 3 | 119 | 120 | H2=4,H4=1 | 12 | 132 | 128 | 8 |
+
+Every figure is multiplied by f. The unchanged prefix's complete operator
+admission is inherited from the pinned previous independent audit; this
+review recounts its actual invoice and independently verifies the entire
+local current-input operator. Omitting one actual reverse-current native
+query changes the local matrix and spuriously lowers the entry rank by2.
+An f=2-only phase mutation is also rejected. These are all-input controls,
+not clean-state tests.
+
+## Support inequality and arbitrary dirty banks
+
+Let h be the maximum row support of the cumulative coefficient matrix on
+all current original and auxiliary bank/address coordinates. Initially
+h=1 on identity rows (zero rows, if separately permitted, do not hurt).
+An address/phase monomial, scalar multiplication or bank permutation does
+not increase h. A native rank-r macro has exactly2^r entries per row, so
+its output row is a sum of at most2^r prior rows and h increases by at
+most that factor. A counted binary ADD or target accumulation combines
+two previous rows and increases h by at most2. Arbitrary coefficients or
+cancellation only reduce support relative to this union bound.
+
+Thus every output row of any proposed replacement has support at most
+`2^(R_f+S_f)`, where R_f is the sum of actual native macroarities and S_f
+counts every elementary binary ADD/COPY accumulation. The required WR
+block has exactly `2^(6f)` or `2^(8f)` entries in every row: its exact
+native/monomial/native-adapter witness preserves row support. Inputs of
+other banks occupy disjoint coefficient columns, so they cannot cancel
+this required independent-input block. Additional arbitrary dirty banks
+only add initial identity columns; restoring them cannot remove the old
+input3 coefficient. Hence
+
+    q2: R_f+S_f>=6f,       q3: R_f+S_f>=8f.
+
+This permits arbitrary new scalar/monomial coupling topology inside this
+fixed local block. It does not fix the old ADD graph or confine edits to
+one row. It assumes the declared linear macro alphabet; arbitrary nonlinear
+value gates or support-growing primitives with an omitted charge are not
+licensed by the proof.
+
+The exact finite-f bound is `R_f>=nf-S_f`, n=6/8, not a native-only
+pointwise `R_f>=nf`. Bounded or sublinear S_f gives only
+`liminf R_f/f>=n`. Together with the fixed prefixes66f/120f, that excludes
+a fixed asymptotic below-stock native deficit at these entrances. It does
+not prove the local optimum is6/8 or10/12.
+
+The support count uses the SAME-VOLUME FULL-BANK native query macro tariff.
+It does not identify unweighted macroarity with the cost of arbitrary
+striped or partial-volume primitive queries. Such queries need their own
+weighted invoice and implementation analysis. COPY is not a free fan-in
+primitive; every binary target accumulation must be counted.
+
+## Conditional all-q tail pattern
+
+For the stated repeating tail, R_q is a scalar unit times the ordered
+product of reverse-current native/permutation factors on odd planes5..k.
+Each P_s commutes with N_t for distinct fresh s,t, so those N factors can
+be grouped on the left without moving them through W. W remains supported
+on planes0/1. The remaining ADDRESS product is a right monomial, and
+
+    nu(W R_q)=4+2(q-1)=2q+2.
+
+The independent q2..10 arity grid corroborates this disjoint-support proof.
+The exact complete suffix fixtures are only q2/q3. The all-q cost statement
+is conditional on the declared tail event pattern, unchanged boundary,
+and stock+4 complete profile; it is not a newly compiled all-q supplier.
+The scalar phase epsilon_q must be retained for operator equality although
+it does not affect the support bound.
+
+## Full-scan bridge
+
+Section4 of the threshold note is correct under its explicit cost premises:
+the counted operations must incur actual work
+`T_scan(f)>=c V_f S_f` for fixed c>0, and the complete available overhead
+must be `o(V_f f)`. Merely writing down a sequence of formal full-field
+ADDs is not a lower bound for a different fused or partial-volume primitive
+implementation. Here S_f counts actual elementary binary operations in the
+declared macro model, with all required per-record work charged.
+
+A fixed native shortfall `R_f<=(n-delta)f` forces `S_f>=delta f`, giving
+`T_scan=Omega(V_f f)`. It cannot fit a budget
+`O(V_f f^lambda P(f))` with lambda<1 and
+`P(f)=o(f^(1-lambda))`. An unrestricted precision/field/controller multiplier
+cannot be dropped. The threshold note explicitly leaves the changed
+caller/source/precision linkage unproved; this review does too.
+
+Under that sublinear full-scan budget S_f=o(f). For equal-volume full-bank
+child normalization and p=1-b in(0,1), subadditivity gives
+`sum x_i^p >= (sum x_i)^p`. The limiting cleanup moment is therefore at
+least `(n/m)^p=(1/2)^p`. The actual fixed prefixes give respectively
+
+    33(1/6)^p+(1/2)^p > 6,
+    60(1/8)^p+(1/2)^p > 8.
+
+These strict inequalities follow because at p=1 the sums are exactly
+stock and every displayed fraction is below1. They exclude a favorable
+native component moment for these fixed cuts under that normalization
+and scan budget. They do not themselves prove a new multiplication
+recurrence or a precision/tape theorem.
+
+Changed earlier cuts, output or entrance gauges, owner contracts, native
+alphabet, physical volumes, helper interactions outside this block or
+partial/fused machine primitives reopen a premise. No local minimum,
+global caller lower bound, formal-kernel certificate, BIT result or kappa
+claim is made.
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-independent-review/SOURCE-PINS.json b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/SOURCE-PINS.json
new file mode 100644
index 0000000000..104ecdec8e
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/SOURCE-PINS.json
@@ -0,0 +1,171 @@
+{
+  "files": [
+    {
+      "bytes": 17392,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/stabilizer-escape/full_stabilizer_bound.py",
+      "sha256": "f073a00ad4831616e873eb110fd33ad7226010a7c2f6cfa6a6b63167bf58ef75"
+    },
+    {
+      "bytes": 2125,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/free_ops.py",
+      "sha256": "5806fe91b9fda162d5986b12e085b14eb3df9a4703f749f61c1f10363138ca77"
+    },
+    {
+      "bytes": 9769,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_family.py",
+      "sha256": "88f425d12baf8a4f849cccd24605f21680eb8ce8d199054db4b4e7734eca72b6"
+    },
+    {
+      "bytes": 4005,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_prefix.py",
+      "sha256": "9ec10cb0243c0c829475ad7290f4953cdff27cb0f90f70b687c4bbee98af676b"
+    },
+    {
+      "bytes": 3919,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/pivot_plane_probe.py",
+      "sha256": "fcd0a4a0a301c4fddfb8b132894e8b5b751b08cacdb0e5ed41e80b0d4903d499"
+    },
+    {
+      "bytes": 7160,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py",
+      "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f"
+    },
+    {
+      "bytes": 10638,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/even_parity_source.py",
+      "sha256": "961f136e4bc1b5da930bdd4ba9bbb594892b9e27f7ab44749d747d4fe16b4cb3"
+    },
+    {
+      "bytes": 6086,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/lifted_algebra.py",
+      "sha256": "3b9a58a2048a762ab520ac7fdbb28cbfeb7b30345aaeb777d8dabdd9fb1034d9"
+    },
+    {
+      "bytes": 3533,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py",
+      "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3"
+    },
+    {
+      "bytes": 11641,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/orthogonal_source_normalizer.py",
+      "sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa"
+    },
+    {
+      "bytes": 11772,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-chronology/quadratic_charts.py",
+      "sha256": "de2a36f6a6b567360c90477b58da44e2f1b618fd006d058ab1ea04e983952c3f"
+    },
+    {
+      "bytes": 5327,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/caller-joint/joint_algebra.py",
+      "sha256": "5782033e347c9b10ad47c01ed12a0a52ea07e901fa9e8f7aa9d3a2a928327232"
+    },
+    {
+      "bytes": 2030,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/completed-gates-review/MANIFEST.json",
+      "sha256": "ef3697eece91ee6d52ae3f5e88b95028091829d6961118052dff1e25df212ba3"
+    },
+    {
+      "bytes": 17680,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/completed-gates-review/audit_gates.py",
+      "sha256": "051ba51e02e9f143b8a8bea0b91d69e7e1e32edf0f98d2d40db290f02043d460"
+    },
+    {
+      "bytes": 2424,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/ALL-Q-TAIL-LEMMA.md",
+      "sha256": "f3b8c42c0fe7d5c5a542e38fe0b3d14601c170959e18a45b60f26128703560b2"
+    },
+    {
+      "bytes": 3049,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/HANDOFF.md",
+      "sha256": "25aa7a2e7408cca9402e34ba809bb8a487c79a4d012d5b8c4700dc81502741aa"
+    },
+    {
+      "bytes": 178927,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/LOCAL-BLOCK.json",
+      "sha256": "aad2ee156a1f1e028b4e0329b4af1c38285f0be90c27da720d4bb71885c29294"
+    },
+    {
+      "bytes": 1301,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/MANIFEST.json",
+      "sha256": "f3c5b9829e61866988b0843e5bcb637fb0ae37434e2f8e6ef74bdeef079e126e"
+    },
+    {
+      "bytes": 7537,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/PROOF.md",
+      "sha256": "5b4300fb15364dbdb17974d6d0bb7d387a189ff814fd0293057ea2a47ac58587"
+    },
+    {
+      "bytes": 275744,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/Q3-LOCAL-BLOCK.json",
+      "sha256": "3ad4d1bb498cd67588af0c0558c32b441b35dac56b9f3bb7001ae317fadc28fa"
+    },
+    {
+      "bytes": 1947,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/VALIDATION.json",
+      "sha256": "e1b6ccf248fa65973645d41b34a7119f07df5d70e73dcfb36cf335ff2ec45e31"
+    },
+    {
+      "bytes": 11678,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/local_block.py",
+      "sha256": "ac8abc744c616e60a221e8fadf1b590f2248f953bafcb2f61675d1c2541f7fe1"
+    },
+    {
+      "bytes": 4952,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/q3_tail.py",
+      "sha256": "8fac76761684d17231ae4d766b7d9464a4ff5675e99038dfbd839bb8cf0d1082"
+    },
+    {
+      "bytes": 16507,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/fusion-audit/audit_fusions.py",
+      "sha256": "26c35f6d61ad6568da1c650a343b82caea174330ff8054c4cdab1fe183ad2173"
+    },
+    {
+      "bytes": 11890,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-native/joint_coefficient_gate.py",
+      "sha256": "43bc5229a10e7ed6af3d5bff057c61cfd6d37a222cc0a2eb2e88cbe0ac410d07"
+    },
+    {
+      "bytes": 9394,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-native/literal_inverse_binding.py",
+      "sha256": "74bdbc9c35db4153e00ed15c8d9df27b63e1c50cd76fcd33f987f3f97d412d96"
+    },
+    {
+      "bytes": 692,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-threshold-screen/MANIFEST.json",
+      "sha256": "e90d8163c1e5c9797534dd3ed7d6279d1095ff001d84b20dd5c33f8d70d68c6c"
+    },
+    {
+      "bytes": 15067,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-threshold-screen/PROOF.md",
+      "sha256": "0eb564effb343e2a20af79445b6a319b719621965b2dc82a303bc6541e34d232"
+    },
+    {
+      "bytes": 2438797,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json",
+      "sha256": "30d3f569d91304856118796f0c586176d0ad961eff70b09c78fce7532392101f"
+    },
+    {
+      "bytes": 3949,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/MANIFEST.json",
+      "sha256": "44f1e264b3087ab8fdb08b4cd6e27befefbba380852b0119321724b7bc41b5da"
+    },
+    {
+      "bytes": 9496,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-independent-audit/AUDIT.json",
+      "sha256": "e3333eb9c0166a2b66bec2599e8c837a5fd6459e560abcb190c792653bca2ed7"
+    },
+    {
+      "bytes": 9188,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-independent-audit/MANIFEST.json",
+      "sha256": "4e52d2469b648d73c2af67615116c994b434fdcca2cd0aa573debe98db87324e"
+    },
+    {
+      "bytes": 6824,
+      "path": "/Users/ross/git/math/integer-mult-bounds/research/kernel92-frame-composition/vendor/pr531/vendor/clifford/clifford_exact.py",
+      "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962"
+    }
+  ],
+  "scientific_main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "threshold_review_scope": "Section4 conditional scan/moment argument only, not its upstream candidate or numerical planning claims."
+}
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-independent-review/VALIDATION.json b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/VALIDATION.json
new file mode 100644
index 0000000000..21f9ee3afd
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/VALIDATION.json
@@ -0,0 +1,20 @@
+{
+  "arbitrary_current_columns": [
+    6,
+    8
+  ],
+  "commands": [
+    "python3.12 -B audit_tail.py",
+    "python3.12 -B -O audit_tail.py"
+  ],
+  "conditional_tail_rank_grid_q": "2..10",
+  "exact_local_cases": 2,
+  "inverse_orders_each": 2,
+  "negative_controls": [
+    "omitted reverse native query changes matrix and lowers witness rank spuriously",
+    "f2-only native phase residue rejected"
+  ],
+  "no_new_kappa": true,
+  "scope": "Selected actual suffix recipes/phases, source slices and complete native invoices; support-only witness not charged as new query. Conditional same-volume/full-bank scan and precision-budget assumptions explicit.",
+  "status": "PASS_NORMAL_AND_OPTIMIZED"
+}
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-independent-review/audit_tail.py b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/audit_tail.py
new file mode 100644
index 0000000000..1b67e0b4c4
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/audit_tail.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Independent exact current-input suffix, native and support witness audit.
+Apache-2.0; substantial OpenAI Codex assistance. No new supplier claim.
+"""
+from pathlib import Path
+from fractions import Fraction
+from collections import Counter
+import argparse,copy,hashlib,json,sys,types
+sys.dont_write_bytecode=True
+HERE=Path(__file__).resolve().parent;R=HERE.parent;SOURCE=R/'coupled-tail-escape'
+p=R/'completed-gates-review/audit_gates.py';a=types.ModuleType('frozen_review_algebra');a.__file__=str(p)
+exec(compile(p.read_bytes(),str(p),'exec',dont_inherit=True,optimize=0),a.__dict__)
+ind=a.independent;ja,qc=a.ja,a.qc
+def unary(e,m):
+    clean={k:v for k,v in e.items()if k!='x_monomial'};op=ind.event_op(clean,m)
+    family=ind.from_circuit(op,0);ex=e['extra_global_phase_exponent_by_f_mod4'];units=ind.UNITS
+    family={k:tuple(c*units[ex[r]%4]for r,c in enumerate(v))for k,v in family.items()}
+    symbolic=ind.old.serialized_family([dict(x_monomial=e['x_monomial'],coefficients_by_f_mod4=[['1','0']for _ in range(4)])])
+    a.need(family==symbolic,'literal unary and symbolic source all-f phases agree')
+    return family
+def replay(E,n,m):
+    M=ind.identity(n,m)
+    for e in E:
+        if e['kind']=='ADD':
+            d,s=e['dst'],e['src'];M[d]=[ind.add(x,ind.scale(y,Fraction(e['coefficient'])))for x,y in zip(M[d],M[s])]
+        elif e['kind']=='SCALE':M[e['bank']]=[ind.scale(x,Fraction(e['coefficient']))for x in M[e['bank']]]
+        elif e['kind']=='BANK_SWAP':i,j=e['banks'];M[i],M[j]=M[j],M[i]
+        else:
+            U=unary(e,m);M[e['bank']]=[ind.product(U,x)for x in M[e['bank']]]
+    return M
+def family_entry(entry,m):
+    op=ind.op_of(json.dumps(entry['one_coordinate_literal_circuit']),m);E=ind.from_circuit(op,0);ex=entry['extra_global_phase_exponent_by_f_mod4']
+    return op,{k:tuple(c*ind.UNITS[ex[r]%4]for r,c in enumerate(v))for k,v in E.items()}
+def check(f,admitted):
+    q=f['q'];n,m=f['banks'],f['ambient_arity'];cut=f['cut_event_ordinal'];E=f['events'];Ei=f['inverse_events'];pool=f['native_recipe_pool'];cache={}
+    source=next(x for x in admitted['fixtures']if x['q']==q)
+    a.need(cut==({2:69,3:119}[q])and source['events'][cut]['label']=='final independent a J query','actual cut before final independent a query')
+    a.need([{k:v for k,v in e.items()if k!='x_monomial'}for e in E]==source['events'][cut:],'entire local word exact admitted-source slice')
+    a.need([{k:v for k,v in e.items()if k!='x_monomial'}for e in Ei]==source['inverse_events'][:len(E)],'entire serialized inverse exact source slice')
+    used=set()
+    for e in E+Ei:
+        if e['kind']in('ADD','SCALE','BANK_SWAP'):continue
+        clean={k:v for k,v in e.items()if k!='x_monomial'};ind.native_check(clean,pool,m,cache);unary(e,m)
+        if e['kind']=='NATIVE':used.add(e['native_recipe_id'])
+    a.need(used==set(pool),'native pool is used-only in forward/inverse')
+    M,Mi=replay(E,n,m),replay(Ei,n,m)
+    a.need(ind.mm(M,Mi)==ind.identity(n,m)==ind.mm(Mi,M),'both full arbitrary-current-input inverse orders')
+    a.need(M==[[ind.old.serialized_family(x)for x in row]for row in f['complete_local_matrix']],'saved complete local matrix')
+    a.need(Mi==[[ind.old.serialized_family(x)for x in row]for row in f['complete_local_inverse']],'saved complete local inverse')
+    F=a.F(m,2*q+1);J=ja.j_operator(m);Q=J.inv()@a.P(m,1)@a.N(m,0).inv()@J@J;A=F@J@F.inv();W=F@Q.inv()@F.inv()
+    reverse=[e for e in E if (e['label'].startswith('w reverse')and e['kind']not in('ADD','SCALE','BANK_SWAP'))or e['label']=='final extraction D_final inverse sign']
+    RR=qc.identity(m)
+    for e in reverse:RR=qc.decode(e,m)@RR
+    expected=a.oldexpr(W@RR);a.need(M[1][3]==expected,'single exact input3/output1 WR coefficient all-f phase')
+    entry=f['unavoidable_entry'];op,fam=family_entry(entry,m)
+    a.need(fam==expected==ind.old.serialized_family(entry['operator']),'literal support witness and current-input coefficient coincide')
+    rank=a.rank(x for x,z,p in op.tab[m:]);a.need(rank==2*q+2==entry['native_arity_per_f'],'actual coefficient native B-rank')
+    recipe=entry.get('support_witness_selected_native_recipe',entry.get('support_witness_recipe'))
+    lowered=ind.old.compile_recipe(recipe,m);a.need(recipe['rank']==rank and ind.equal_op(lowered,op),'support-only Bruhat recipe actual Gaussian phase')
+    a.need(a.eq(W,a.N(m,1)@Q.inv()@a.N(m,1).inv()),'W support is confined to original planes0/1')
+    if q==2:
+        I=a.oldexpr(qc.identity(m));AA,WW,RRR=a.oldexpr(A),a.oldexpr(W),a.oldexpr(RR);IW=ind.add(I,ind.scale(WW,-1));target=[[{}for _ in range(n)]for _ in range(n)]
+        target[0][0]=AA;target[1][0]=ind.scale(ind.product(WW,AA),-1);target[1][2]=IW;target[1][3]=expected;target[1][4]=IW
+        target[2][0]=ind.scale(AA,-1);target[2][2]=I
+        target[3][0]=ind.scale(ind.product(AA,ind.product(WW,AA)),-1);target[3][1]=AA;target[3][2]=ind.product(AA,IW);target[3][3]=ind.product(AA,ind.product(ind.scale(IW,-1),RRR));target[3][4]=ind.scale(ind.product(AA,WW),-1)
+        target[4][4]=I;target[5][5]=I;a.need(M==target,'entire independent q2 six-row symbolic matrix')
+        # Independently assemble the prose inverse from its y-coordinate
+        # equations, rather than merely multiplying the saved inverse.
+        e0=[I if j==0 else{}for j in range(n)];e1=[I if j==1 else{}for j in range(n)];e2=[I if j==2 else{}for j in range(n)];e3=[I if j==3 else{}for j in range(n)];e4=[I if j==4 else{}for j in range(n)];e5=[I if j==5 else{}for j in range(n)]
+        x0=[ind.product(a.oldexpr(A.inv()),x)for x in e0];x2=[ind.add(x,y)for x,y in zip(e2,e0)];x4=e4
+        z=[ind.add(ind.product(a.oldexpr(W.inv()),ind.add(ind.add(y,ind.scale(b,-1)),ind.scale(c,-1))),ind.add(ind.add(d,b),c))for y,b,c,d in zip(e1,x2,x4,e0)]
+        x3=[ind.product(a.oldexpr(RR.inv()),x)for x in z]
+        x1=[ind.add(ind.add(ind.product(a.oldexpr(A.inv()),d),zj),ind.add(ind.scale(y,-1),c))for d,zj,y,c in zip(e3,z,e1,x4)]
+        a.need(Mi==[x0,x1,x2,x3,x4,e5],'explicit q2 inverse formulas every current column')
+    hist=Counter(e['rank_per_f']for e in E if e['kind']=='NATIVE');local=sum(r*c for r,c in hist.items());prefix=sum(e['rank_per_f']for e in source['events'][:cut]if e['kind']=='NATIVE')
+    prefix_hist=Counter(e['rank_per_f']for e in source['events'][:cut]if e['kind']=='NATIVE');a.need(prefix_hist=={2:{2:33,3:60}[q]},'actual fixed-prefix rank2 profile for moment bridge')
+    a.need((prefix,local)==({2:(66,10),3:(120,12)}[q])and prefix==f['unchanged_prefix_native_mass']and local==f['local_native_mass'],'complete prefix and suffix invoice from actual native events')
+    a.need(prefix+local==source['native_mass']and source['stock']-prefix==rank,'exact stock deficit threshold')
+    # Controls operate on the actual local word, never a clean-state promise.
+    bad=[e for e in E if e['label']!=('w reverse2 selected native2')];MB=replay(bad,n,m)
+    a.need(MB!=M and MB[1][3]!=expected,'omitted actual reverse query changes required coefficient')
+    a.need(len(MB[1][3])==1,'omitted-query control retains a single ray')
+    key=next(iter(MB[1][3]));a.need(a.native(qc.Mono(key[0],key[1],key[2],key[3]))==2*q,'omitted-query spuriously drops support rank by2')
+    modified=copy.deepcopy(E);u=next(e for e in modified if e['kind']=='NATIVE');u['extra_global_phase_exponent_by_f_mod4'][2]^=1
+    try:replay(modified,n,m)
+    except ValueError as ex:a.need('phases agree'in str(ex),'specific all-f phase mutation rejection')
+    else:raise ValueError('f2-only phase mutation accepted')
+    return dict(q=q,cut=cut,banks=n,all_current_columns=n,literal_inverse_orders=2,used_native_recipes=len(used),prefix_native_histogram=dict(prefix_hist),prefix_native_mass=prefix,local_histogram=dict(hist),local_native_mass=local,whole_native_mass=prefix+local,stock=source['stock'],single_entry_arity=rank,controls=['actual reverse-query omission rejected','f2-only native phase mutant rejected'],single_entry_row_support='2^('+str(rank)+'f) in every row; exact Bruhat factors are monomial/native/monomial')
+def run():
+    a.need(a.sha(SOURCE/'MANIFEST.json')=='f3c5b9829e61866988b0843e5bcb637fb0ae37434e2f8e6ef74bdeef079e126e','assigned frozen manifest')
+    for x in json.loads((SOURCE/'MANIFEST.json').read_text())['files']:a.need(a.sha(SOURCE/x['path'])==x['sha256'],'frozen source file '+x['path'])
+    admitted=json.loads((R/'two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json').read_text());cases=[check(json.loads((SOURCE/p).read_text()),admitted)for p in('LOCAL-BLOCK.json','Q3-LOCAL-BLOCK.json')]
+    grid=[]
+    for q in range(2,11):
+        m=4*q+4;k=2*q+1;F=a.F(m,k);J=ja.j_operator(m);Q=J.inv()@a.P(m,1)@a.N(m,0).inv()@J@J;W=F@Q.inv()@F.inv();Ns=qc.identity(m);Ps=qc.identity(m)
+        for s in range(5,k+1,2):Ns=Ns@a.N(m,s);Ps=Ps@a.P(m,s)
+        a.need(a.native(W)==4 and a.native(W@Ns@Ps)==2*q+2,'disjoint-support conditional tail arity')
+        grid.append(dict(q=q,coefficient_rank=2*q+2))
+    return dict(status='PASS_INDEPENDENT_COUPLED_TAIL_ENTRY_PHASE_INVOICE_AND_SUPPORT_REVIEW',cases=cases,conditional_tail_rank_grid=grid,no_new_kappa=True,scope='Exact q2/q3 current-input suffixes, all-f phases; conditional all-q tail pattern only. Support inequality charges every elementary binary ADD and same-volume full-bank native macro. No pointwise native-only floor or partial-volume claim.')
+if __name__=='__main__':
+    p=argparse.ArgumentParser();p.add_argument('--write',action='store_true');args=p.parse_args();out=json.loads(json.dumps(run()));dest=HERE/'AUDIT.json'
+    if args.write:dest.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n')
+    else:a.need(json.loads(dest.read_text())==out,'saved independent audit')
+    print(out['status']);print([(x['q'],x['prefix_native_mass'],x['local_native_mass'],x['single_entry_arity'])for x in out['cases']])
diff --git a/research/coupled-tail-support-floor/source/coupled-tail-independent-review/validate_review.py b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/validate_review.py
new file mode 100644
index 0000000000..a0fae517ea
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/coupled-tail-independent-review/validate_review.py
@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+"""Read-only fail-closed validation of the coupled-tail audit freeze.
+Apache-2.0; substantial OpenAI Codex assistance.
+"""
+from pathlib import Path
+import hashlib,json,sys
+sys.dont_write_bytecode=True
+HERE=Path(__file__).resolve().parent
+def need(c,m):
+    if not c:raise ValueError(m)
+def check(p,x):
+    raw=p.read_bytes();need(hashlib.sha256(raw).hexdigest()==x['sha256'] and len(raw)==x['bytes'],'source/file mismatch '+str(p))
+def main():
+    m=json.loads((HERE/'MANIFEST.json').read_text());pins=json.loads((HERE/'SOURCE-PINS.json').read_text())
+    for x in m['files']:check(HERE/x['path'],x)
+    for x in pins['files']:check(Path(x['path']),x)
+    need(m['no_new_kappa'] is True,'claim scope')
+    print('PASS_FROZEN_COUPLED_TAIL_INDEPENDENT_REVIEW',len(m['files']),'owned files',len(pins['files']),'read-only sources')
+if __name__=='__main__':main()
diff --git a/research/coupled-tail-support-floor/source/early-cut58-independent-review/AUDIT.json b/research/coupled-tail-support-floor/source/early-cut58-independent-review/AUDIT.json
new file mode 100644
index 0000000000..0309d8f2b4
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/early-cut58-independent-review/AUDIT.json
@@ -0,0 +1,24 @@
+{
+  "all_current_input_columns": 6,
+  "ambient_arity": 12,
+  "banks": 6,
+  "controls": [
+    "actual odd b accumulator omission",
+    "lost RP=-T sign"
+  ],
+  "limits": "Planning-only. Neutral serialized schema is operator-verified, not independently selected-native admitted. No cost16 suffix, all-q compiler, native saving or kappa claim.",
+  "literal_inverse_orders": 2,
+  "neutral_factorization_mass": 22,
+  "phase_scope": "All positive f by exact four-residue tensor-family Gaussian algebra",
+  "prefix_native_mass": 54,
+  "q": 2,
+  "status": "PASS_INDEPENDENT_CUT58_PLANNING_MATRIX",
+  "stock": 72,
+  "suffix_native_histogram": {
+    "2": 9,
+    "4": 1
+  },
+  "suffix_native_mass": 22,
+  "used_selected_source_recipes": 8,
+  "whole_native_mass": 76
+}
diff --git a/research/coupled-tail-support-floor/source/early-cut58-independent-review/HANDOFF.md b/research/coupled-tail-support-floor/source/early-cut58-independent-review/HANDOFF.md
new file mode 100644
index 0000000000..7500a2159c
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/early-cut58-independent-review/HANDOFF.md
@@ -0,0 +1,5 @@
+# Frozen review handoff
+
+Independent review PASS for the pinned cut58 planning matrix, all current inputs, both literal inverse orders, source native/phase bindings, RP=-T and the rank-neutral rewrite. Prefix54 plus suffix22 remains mass76/stock72. The target suffix<=16 is OPEN. No selected-native admission of the simplified full schema, native saving or kappa claim.
+
+Read REVIEW.md and AUDIT.json. Both normal and optimized verification pass. This optional review does not enlarge the completed odd-kernel publication claim.
diff --git a/research/coupled-tail-support-floor/source/early-cut58-independent-review/MANIFEST.json b/research/coupled-tail-support-floor/source/early-cut58-independent-review/MANIFEST.json
new file mode 100644
index 0000000000..a0736d96f6
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/early-cut58-independent-review/MANIFEST.json
@@ -0,0 +1,41 @@
+{
+  "files": [
+    {
+      "bytes": 757,
+      "path": "AUDIT.json",
+      "sha256": "8167d024e84d6b3b3763a20fd8a2730ea572f6c331ad71b8c3cfeb4acc6984b5"
+    },
+    {
+      "bytes": 529,
+      "path": "HANDOFF.md",
+      "sha256": "ca6ad58a72f80d86705e6f18ad57a5c7e1aa8e66c761bfbe4a78b367b7ea570a"
+    },
+    {
+      "bytes": 2045,
+      "path": "REVIEW.md",
+      "sha256": "2890cbaa950c9bed28dfb7f375e9fe3d0c300a81eb337be43bb5488f3d822b55"
+    },
+    {
+      "bytes": 10629,
+      "path": "SOURCE-PINS.json",
+      "sha256": "d5187158f6d6016e39b338b5ac4df616275bbf264672d5611f9b0ced76d670d3"
+    },
+    {
+      "bytes": 216,
+      "path": "VALIDATION.json",
+      "sha256": "68730984544922ed03b17377219f355a7f4fb3361ab649c64ec07542996d86d5"
+    },
+    {
+      "bytes": 5077,
+      "path": "audit_cut58.py",
+      "sha256": "dded71129aa71f5133e3410df76c088ff478312d903b1baa817aad79541b32b6"
+    },
+    {
+      "bytes": 391,
+      "path": "validate_review.py",
+      "sha256": "36dbef6426fc9a60eb9f22eb9367feb6fdbf38cd463aef04079c4877026d121e"
+    }
+  ],
+  "no_new_kappa": true,
+  "status": "FROZEN_INDEPENDENT_PLANNING_ONLY_REVIEW"
+}
diff --git a/research/coupled-tail-support-floor/source/early-cut58-independent-review/REVIEW.md b/research/coupled-tail-support-floor/source/early-cut58-independent-review/REVIEW.md
new file mode 100644
index 0000000000..b849f01825
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/early-cut58-independent-review/REVIEW.md
@@ -0,0 +1,13 @@
+# Independent cut58 planning review
+
+PASS for the exact finite q2 interface and the rank-neutral factorization. This is a planning appendix, not a native saving or a completed supplier.
+
+The independently assembled six-bank matrix matches every arbitrary current input column. Literal forward and inverse source slices compose to identity in both orders. Every used source unary is reconstructed from its signed circuit and all four Gaussian phase residues; source selected-native recipes and embeddings are checked in both directions. The source pool is used-only. The exact identities RP=-T and [K,T]=[W,T]=0 hold as operators including global phase.
+
+The review rebuilds all 36 matrix entries directly from the prose operators rather than treating the saved matrix as its oracle. It separately replays the simplified event sequence in the tensor-family operator algebra. Both give the same map. Omitting the actual source b-accumulator or replacing the -T entry by +T changes this arbitrary-input map.
+
+The actual prefix costs54 and the suffix costs22, with suffix profile9H2+H4. The simplified factorization has the same invoice22, so the full source remains76 against stock72. A suffix costing16 would yield70; none is constructed or excluded. This review does not turn the simplified serialization into a new selected-native admission. Its unary operators are the admitted source operators, but a complete new schema/compiler link remains distinct.
+
+The all-f claim uses exact tensor-family Gaussian algebra, not f1 tableau equality. It covers all positive f for this pinned q2 word. It gives no all-q caller, cost16 lower bound, heterogeneous or partial-volume invoice, owner interface, controller, precision, storage or kappa result. The largest-entry support gate alone does not settle the cost16 target.
+
+Reproduce from this directory with `python3 -B audit_cut58.py` and `python3 -B -O audit_cut58.py`. The source manifest and transitive independent algebra dependencies are frozen in SOURCE-PINS.json. No author source was modified.
diff --git a/research/coupled-tail-support-floor/source/early-cut58-independent-review/SOURCE-PINS.json b/research/coupled-tail-support-floor/source/early-cut58-independent-review/SOURCE-PINS.json
new file mode 100644
index 0000000000..bf81d3abd7
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/early-cut58-independent-review/SOURCE-PINS.json
@@ -0,0 +1,214 @@
+{
+  "files": [
+    {
+      "bytes": 17392,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/stabilizer-escape/full_stabilizer_bound.py",
+      "sha256": "f073a00ad4831616e873eb110fd33ad7226010a7c2f6cfa6a6b63167bf58ef75"
+    },
+    {
+      "bytes": 2125,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/free_ops.py",
+      "sha256": "5806fe91b9fda162d5986b12e085b14eb3df9a4703f749f61c1f10363138ca77"
+    },
+    {
+      "bytes": 9769,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_family.py",
+      "sha256": "88f425d12baf8a4f849cccd24605f21680eb8ce8d199054db4b4e7734eca72b6"
+    },
+    {
+      "bytes": 4005,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/nested_prefix.py",
+      "sha256": "9ec10cb0243c0c829475ad7290f4953cdff27cb0f90f70b687c4bbee98af676b"
+    },
+    {
+      "bytes": 3919,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/caller/pivot_plane_probe.py",
+      "sha256": "fcd0a4a0a301c4fddfb8b132894e8b5b751b08cacdb0e5ed41e80b0d4903d499"
+    },
+    {
+      "bytes": 7160,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py",
+      "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f"
+    },
+    {
+      "bytes": 10638,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/even_parity_source.py",
+      "sha256": "961f136e4bc1b5da930bdd4ba9bbb594892b9e27f7ab44749d747d4fe16b4cb3"
+    },
+    {
+      "bytes": 6086,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/lifted_algebra.py",
+      "sha256": "3b9a58a2048a762ab520ac7fdbb28cbfeb7b30345aaeb777d8dabdd9fb1034d9"
+    },
+    {
+      "bytes": 3533,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py",
+      "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3"
+    },
+    {
+      "bytes": 11641,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/orthogonal_source_normalizer.py",
+      "sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa"
+    },
+    {
+      "bytes": 11772,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-chronology/quadratic_charts.py",
+      "sha256": "de2a36f6a6b567360c90477b58da44e2f1b618fd006d058ab1ea04e983952c3f"
+    },
+    {
+      "bytes": 5327,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/caller-joint/joint_algebra.py",
+      "sha256": "5782033e347c9b10ad47c01ed12a0a52ea07e901fa9e8f7aa9d3a2a928327232"
+    },
+    {
+      "bytes": 2030,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/completed-gates-review/MANIFEST.json",
+      "sha256": "ef3697eece91ee6d52ae3f5e88b95028091829d6961118052dff1e25df212ba3"
+    },
+    {
+      "bytes": 17680,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/completed-gates-review/audit_gates.py",
+      "sha256": "051ba51e02e9f143b8a8bea0b91d69e7e1e32edf0f98d2d40db290f02043d460"
+    },
+    {
+      "bytes": 2424,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/ALL-Q-TAIL-LEMMA.md",
+      "sha256": "f3b8c42c0fe7d5c5a542e38fe0b3d14601c170959e18a45b60f26128703560b2"
+    },
+    {
+      "bytes": 3049,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/HANDOFF.md",
+      "sha256": "25aa7a2e7408cca9402e34ba809bb8a487c79a4d012d5b8c4700dc81502741aa"
+    },
+    {
+      "bytes": 178927,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/LOCAL-BLOCK.json",
+      "sha256": "aad2ee156a1f1e028b4e0329b4af1c38285f0be90c27da720d4bb71885c29294"
+    },
+    {
+      "bytes": 1301,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/MANIFEST.json",
+      "sha256": "f3c5b9829e61866988b0843e5bcb637fb0ae37434e2f8e6ef74bdeef079e126e"
+    },
+    {
+      "bytes": 7537,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/PROOF.md",
+      "sha256": "5b4300fb15364dbdb17974d6d0bb7d387a189ff814fd0293057ea2a47ac58587"
+    },
+    {
+      "bytes": 275744,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/Q3-LOCAL-BLOCK.json",
+      "sha256": "3ad4d1bb498cd67588af0c0558c32b441b35dac56b9f3bb7001ae317fadc28fa"
+    },
+    {
+      "bytes": 1947,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/VALIDATION.json",
+      "sha256": "e1b6ccf248fa65973645d41b34a7119f07df5d70e73dcfb36cf335ff2ec45e31"
+    },
+    {
+      "bytes": 11678,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/local_block.py",
+      "sha256": "ac8abc744c616e60a221e8fadf1b590f2248f953bafcb2f61675d1c2541f7fe1"
+    },
+    {
+      "bytes": 4952,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-escape/q3_tail.py",
+      "sha256": "8fac76761684d17231ae4d766b7d9464a4ff5675e99038dfbd839bb8cf0d1082"
+    },
+    {
+      "bytes": 1250,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-independent-review/MANIFEST.json",
+      "sha256": "db91e3ac03e43cb848b7ca6fb6ca314755573142227e330f2f0293011501f8dd"
+    },
+    {
+      "bytes": 8551,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-independent-review/SOURCE-PINS.json",
+      "sha256": "e86465b4fb10b3597cc6ec59ce8f24e828301683a5e7f8e1b51d646ae83dabc8"
+    },
+    {
+      "bytes": 9836,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/coupled-tail-independent-review/audit_tail.py",
+      "sha256": "18f72f8e4e69595484304e1bacdb3d8f8bfc3f9bfad71aa1038adfb1808f955d"
+    },
+    {
+      "bytes": 237184,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/CUT58.json",
+      "sha256": "7553ec4f63272cd4b8efb16b2ec01183240be248e36a5dc45df32f9ebd24de58"
+    },
+    {
+      "bytes": 1338,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/HANDOFF.md",
+      "sha256": "31da85394448775676ded8fabbf6ce2c894da9eb0d0e799129e42710ca91d29c"
+    },
+    {
+      "bytes": 805,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/MANIFEST.json",
+      "sha256": "2b5df5dc85e4799116177fac51ffc801357c243189b80563891cb534d1ce6a12"
+    },
+    {
+      "bytes": 4503,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/PROOF.md",
+      "sha256": "96372d990703d9775eda33d6b9d47c915f8c5b94b7c3d5c4fd82278fd0ecf2f3"
+    },
+    {
+      "bytes": 837,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/VALIDATION.md",
+      "sha256": "2d33306afb4fcac0d7af57e492f89ccf33fea74d022d1788970cd116130080aa"
+    },
+    {
+      "bytes": 7865,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/early-cut58-planning/cut58.py",
+      "sha256": "0df94525632944ef6b4441159d481317fa7f4bcaf9c8b121d73ae06c545b0b02"
+    },
+    {
+      "bytes": 16507,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/fusion-audit/audit_fusions.py",
+      "sha256": "26c35f6d61ad6568da1c650a343b82caea174330ff8054c4cdab1fe183ad2173"
+    },
+    {
+      "bytes": 11890,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-native/joint_coefficient_gate.py",
+      "sha256": "43bc5229a10e7ed6af3d5bff057c61cfd6d37a222cc0a2eb2e88cbe0ac410d07"
+    },
+    {
+      "bytes": 9394,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-native/literal_inverse_binding.py",
+      "sha256": "74bdbc9c35db4153e00ed15c8d9df27b63e1c50cd76fcd33f987f3f97d412d96"
+    },
+    {
+      "bytes": 692,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-threshold-screen/MANIFEST.json",
+      "sha256": "e90d8163c1e5c9797534dd3ed7d6279d1095ff001d84b20dd5c33f8d70d68c6c"
+    },
+    {
+      "bytes": 15067,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/joint-threshold-screen/PROOF.md",
+      "sha256": "0eb564effb343e2a20af79445b6a319b719621965b2dc82a303bc6541e34d232"
+    },
+    {
+      "bytes": 2438797,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json",
+      "sha256": "30d3f569d91304856118796f0c586176d0ad961eff70b09c78fce7532392101f"
+    },
+    {
+      "bytes": 3949,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-continuation/MANIFEST.json",
+      "sha256": "44f1e264b3087ab8fdb08b4cd6e27befefbba380852b0119321724b7bc41b5da"
+    },
+    {
+      "bytes": 9496,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-independent-audit/AUDIT.json",
+      "sha256": "e3333eb9c0166a2b66bec2599e8c837a5fd6459e560abcb190c792653bca2ed7"
+    },
+    {
+      "bytes": 9188,
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-joint-cleanup-20261019T1133Z/two-site-independent-audit/MANIFEST.json",
+      "sha256": "4e52d2469b648d73c2af67615116c994b434fdcca2cd0aa573debe98db87324e"
+    },
+    {
+      "bytes": 6824,
+      "path": "/Users/ross/git/math/integer-mult-bounds/research/kernel92-frame-composition/vendor/pr531/vendor/clifford/clifford_exact.py",
+      "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962"
+    }
+  ]
+}
diff --git a/research/coupled-tail-support-floor/source/early-cut58-independent-review/VALIDATION.json b/research/coupled-tail-support-floor/source/early-cut58-independent-review/VALIDATION.json
new file mode 100644
index 0000000000..609c80e44e
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/early-cut58-independent-review/VALIDATION.json
@@ -0,0 +1,10 @@
+{
+  "negative_controls": [
+    "actual source accumulator omission changes matrix",
+    "lost RP=-T sign changes matrix"
+  ],
+  "no_new_kappa": true,
+  "normal": "PASS",
+  "optimized": "PASS",
+  "source_files": 42
+}
diff --git a/research/coupled-tail-support-floor/source/early-cut58-independent-review/audit_cut58.py b/research/coupled-tail-support-floor/source/early-cut58-independent-review/audit_cut58.py
new file mode 100644
index 0000000000..b6902b9ed2
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/early-cut58-independent-review/audit_cut58.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""Independent cut58 planning matrix audit; no supplier improvement. Apache-2.0."""
+from pathlib import Path
+from collections import Counter
+from fractions import Fraction
+import json,sys,types,hashlib,argparse
+sys.dont_write_bytecode=True
+HERE=Path(__file__).resolve().parent;R=HERE.parent;S=R/'early-cut58-planning'
+p=R/'coupled-tail-independent-review/audit_tail.py';h=types.ModuleType('frozen_tail_review');h.__file__=str(p);exec(compile(p.read_bytes(),str(p),'exec',optimize=0),h.__dict__)
+a=h.a;ind=h.ind;qc=h.qc
+def need(v,s):
+ if not v:raise ValueError(s)
+def shadow(E,n,m):
+ M=ind.identity(n,m)
+ for e in E:
+  if e['kind']=='ADD':M[e['dst']]=[ind.add(x,ind.scale(y,Fraction(e['coefficient'])))for x,y in zip(M[e['dst']],M[e['src']])]
+  elif e['kind']=='SCALE':M[e['bank']]=[ind.scale(x,Fraction(e['coefficient']))for x in M[e['bank']]]
+  elif e['kind']=='BANK_SWAP':i,j=e['banks'];M[i],M[j]=M[j],M[i]
+  else:
+   U=a.oldexpr(qc.decode(e,m));M[e['bank']]=[ind.product(U,x)for x in M[e['bank']]]
+ return M
+def run():
+ need(a.sha(S/'MANIFEST.json')=='2b5df5dc85e4799116177fac51ffc801357c243189b80563891cb534d1ce6a12','assigned manifest')
+ for x in json.loads((S/'MANIFEST.json').read_text())['files']:need(a.sha(S/x['path'])==x['sha256'],'source pin '+x['path'])
+ f=json.loads((S/'CUT58.json').read_text());n,m=6,12;E,Ei=f['events'],f['inverse_events'];ad=json.loads((R/'two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json').read_text())['fixtures'][0]
+ clean=lambda es:[{k:v for k,v in e.items()if k!='x_monomial'}for e in es]
+ need(ad['q']==2 and clean(E)==ad['events'][58:] and clean(Ei)==ad['inverse_events'][:len(E)],'complete actual admitted source forward/inverse slices')
+ used=set();cache={}
+ for e in E+Ei:
+  if e['kind']in('ADD','SCALE','BANK_SWAP'):continue
+  h.unary(e,m);ind.native_check({k:v for k,v in e.items()if k!='x_monomial'},f['native_recipe_pool'],m,cache)
+  if e['kind']=='NATIVE':used.add(e['native_recipe_id'])
+ need(used==set(f['native_recipe_pool']),'used-only selected source recipes')
+ M,Mi=h.replay(E,n,m),h.replay(Ei,n,m);I=ind.identity(n,m)
+ need(ind.mm(M,Mi)==I==ind.mm(Mi,M),'both arbitrary-current-input inverse orders')
+ need(M==[[ind.old.serialized_family(x)for x in row]for row in f['complete_local_matrix']],'saved matrix')
+ need(Mi==[[ind.old.serialized_family(x)for x in row]for row in f['complete_local_inverse']],'saved inverse')
+ ops={k:qc.decode(dict(x_monomial=v),m)for k,v in f['operators'].items()};T,K,W,P,RR=[ops[k]for k in('T','K','W','P','reverse_current')]
+ need(a.oldexpr(RR@P)==ind.scale(a.oldexpr(T),-1) and a.eq(K@T,T@K)and a.eq(W@T,T@W),'RP=-T and exact commutation including global phase')
+ Z={};Id=a.oldexpr(qc.identity(m));expr=a.oldexpr
+ target=[[Z for j in range(n)]for i in range(n)]
+ target[0][0]=expr(K@T);target[1][0]=ind.scale(expr(W@K@T),-1);target[1][2]=ind.add(expr(T),ind.scale(expr(W@T),-1));target[1][3]=ind.scale(expr(T),-1);target[1][4]=ind.scale(expr(W@T@K),-1)
+ target[2][0]=ind.scale(expr(K@T),-1);target[2][2]=expr(T);target[2][3]=ind.scale(expr(T),-1);target[2][4]=ind.scale(expr(T@K),-1)
+ target[3][0]=ind.scale(expr(K@W@K@T),-1);target[3][1]=expr(K@T);target[3][2]=ind.add(expr(K@T),ind.scale(expr(K@W@T),-1));target[3][4]=ind.scale(expr(K@W@T@K),-1);target[4][4]=expr(T@K);target[5][5]=expr(T)
+ need(M==target,'all six independent matrix rows in prose')
+ simple=f['simplified_rank_neutral_events'];need(shadow(simple,n,m)==M,'rank-neutral operator factorization all-f phases')
+ hist=Counter(e['rank_per_f']for e in E if e['kind']=='NATIVE');shist=Counter(e['rank_per_f']for e in simple if e['kind']=='NATIVE');pre=sum(e['rank_per_f']for e in ad['events'][:58]if e['kind']=='NATIVE')
+ need(pre==54 and hist==shist=={2:9,4:1}and pre+sum(r*c for r,c in hist.items())==76,'actual prefix/suffix and neutral invoices')
+ mutant=[e for e in E if 'odd b accumulator'not in e['label']];need(len(mutant)<len(E)and h.replay(mutant,n,m)!=M,'actual accumulator omission rejected')
+ wrong=[row[:]for row in target];wrong[1][3]=expr(T);need(wrong!=M,'lost RP minus sign rejected')
+ return dict(status='PASS_INDEPENDENT_CUT58_PLANNING_MATRIX',q=2,banks=6,ambient_arity=12,all_current_input_columns=6,literal_inverse_orders=2,phase_scope='All positive f by exact four-residue tensor-family Gaussian algebra',prefix_native_mass=54,suffix_native_histogram=dict(hist),suffix_native_mass=22,whole_native_mass=76,stock=72,neutral_factorization_mass=22,used_selected_source_recipes=len(used),controls=['actual odd b accumulator omission','lost RP=-T sign'],limits='Planning-only. Neutral serialized schema is operator-verified, not independently selected-native admitted. No cost16 suffix, all-q compiler, native saving or kappa claim.')
+if __name__=='__main__':
+ p=argparse.ArgumentParser();p.add_argument('--write',action='store_true');args=p.parse_args();out=json.loads(json.dumps(run()));dest=HERE/'AUDIT.json'
+ if args.write:dest.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n')
+ else:need(json.loads(dest.read_text())==out,'saved independent result')
+ print(out['status'])
diff --git a/research/coupled-tail-support-floor/source/early-cut58-independent-review/validate_review.py b/research/coupled-tail-support-floor/source/early-cut58-independent-review/validate_review.py
new file mode 100644
index 0000000000..d2e67df83f
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/early-cut58-independent-review/validate_review.py
@@ -0,0 +1,9 @@
+#!/usr/bin/env python3
+from pathlib import Path
+import hashlib,json
+D=Path(__file__).resolve().parent
+for name in ('SOURCE-PINS.json','MANIFEST.json'):
+ for x in json.loads((D/name).read_text())['files']:
+  p=Path(x['path']);p=p if p.is_absolute() else D/p
+  if hashlib.sha256(p.read_bytes()).hexdigest()!=x['sha256']:raise ValueError(str(p))
+print('PASS_FROZEN_SOURCE_AND_REVIEW_MANIFEST')
diff --git a/research/coupled-tail-support-floor/source/early-cut58-planning/CUT58.json.gz b/research/coupled-tail-support-floor/source/early-cut58-planning/CUT58.json.gz
new file mode 100644
index 0000000000..d4f84ba72c
Binary files /dev/null and b/research/coupled-tail-support-floor/source/early-cut58-planning/CUT58.json.gz differ
diff --git a/research/coupled-tail-support-floor/source/early-cut58-planning/HANDOFF.md b/research/coupled-tail-support-floor/source/early-cut58-planning/HANDOFF.md
new file mode 100644
index 0000000000..bbad36b61b
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/early-cut58-planning/HANDOFF.md
@@ -0,0 +1,22 @@
+# Planning-only cut58 handoff
+
+The exact q2 six-bank suffix beginning at actual source query5 event58 is
+preserved. Prefix54 plus suffix22 gives76. A desired coupled suffix16 would
+give70 belowstock72, but remains open. `PROOF.md` displays every arbitrary
+current input coefficient, both pivot rows, physical source chronology,
+rank-neutral RP=-T cancellation and complete22 invoice. The script and
+receipt retain original selected native recipes, exact phases and literal
+inverse in both orders; no clean or correlated entrance is used.
+
+A neutral implementation removes ADDRESS/source-relocation overhead but
+still uses9H2+H4. It is not a native saving or a lower bound against other
+coupled factorizations. In particular freshT mass12 and maximal entryrank6
+are not promoted to a16 lowerbound. This is a precise future construction
+assignment only. No broad search, active process or publication mutation.
+All frozen predecessors, BIT and helper artifacts were read only.
+
+Reproduce with `python3 -B cut58.py` and `python3 -B -O cut58.py`.
+`CUT58.json` includes the entire local matrix, its inverse, forward and
+serialized inverse events, used selected pool, the rank-neutral scalar
+network, source pin and explicit negative controls. `MANIFEST.json` records
+all final package hashes. No complete compatible supplier or kappa claimed.
diff --git a/research/coupled-tail-support-floor/source/early-cut58-planning/MANIFEST.json b/research/coupled-tail-support-floor/source/early-cut58-planning/MANIFEST.json
new file mode 100644
index 0000000000..bd7eef4f6f
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/early-cut58-planning/MANIFEST.json
@@ -0,0 +1,31 @@
+{
+  "files": [
+    {
+      "bytes": 237184,
+      "path": "CUT58.json",
+      "sha256": "7553ec4f63272cd4b8efb16b2ec01183240be248e36a5dc45df32f9ebd24de58"
+    },
+    {
+      "bytes": 1338,
+      "path": "HANDOFF.md",
+      "sha256": "31da85394448775676ded8fabbf6ce2c894da9eb0d0e799129e42710ca91d29c"
+    },
+    {
+      "bytes": 4503,
+      "path": "PROOF.md",
+      "sha256": "96372d990703d9775eda33d6b9d47c915f8c5b94b7c3d5c4fd82278fd0ecf2f3"
+    },
+    {
+      "bytes": 837,
+      "path": "VALIDATION.md",
+      "sha256": "2d33306afb4fcac0d7af57e492f89ccf33fea74d022d1788970cd116130080aa"
+    },
+    {
+      "bytes": 7865,
+      "path": "cut58.py",
+      "sha256": "0df94525632944ef6b4441159d481317fa7f4bcaf9c8b121d73ae06c545b0b02"
+    }
+  ],
+  "no_new_kappa": true,
+  "status": "FROZEN_PLANNING_ONLY"
+}
diff --git a/research/coupled-tail-support-floor/source/early-cut58-planning/PROOF.md b/research/coupled-tail-support-floor/source/early-cut58-planning/PROOF.md
new file mode 100644
index 0000000000..ebc7f8a87b
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/early-cut58-planning/PROOF.md
@@ -0,0 +1,88 @@
+# Actual cut58 interface; no native saving established
+
+This package fixes the q2 admitted mass76 source at event58, the literal
+`query5 source J` on bank4. The unchanged prefix costs54 native rank units;
+the remaining word costs22. A hypothetical suffix of cost16 would give
+whole mass70 below stock72. No such suffix is constructed or excluded here.
+The result is an exact future construction target, not a positive supplier.
+
+All six current bank inputs are independent arbitrary fields because the
+preceding physical word is invertible. In order they are named
+(a,u,b,r,z,c). They are current physical rows, not virtual source coordinates.
+Let T=N5 be fresh-plane progress, K the actual physical source-J query,
+W the actual dual-Q recovery, P the source ADDRESS postwarp, and R the
+later reverse-current unary. The pinned source gives the exact identities
+
+    K = (later independent-a J),   R P = -T,
+    [K,T]=[W,T]=0.
+
+The minus sign is a literal Gaussian scalar phase; it is not discarded.
+
+## Complete arbitrary-input block
+
+With I the identity, the output vector is M(a,u,b,r,z,c), where
+
+    M = [ KT        0    0          0    0        0 ]
+        [-WKT       0   (I-W)T     -T   -WTK      0 ]
+        [-KT        0    T         -T   -TK       0 ]
+        [-KWKT      KT   K(I-W)T    0   -KWTK     0 ]
+        [ 0         0    0          0    TK       0 ]
+        [ 0         0    0          0    0        T ].
+
+Both pivot rows, every original current input column, source response and
+completed public rows remain in this matrix. Its complete inverse is saved
+as exact operator coefficients and as the literal reversed source events.
+Forward/inverse composition in both orders is checked on all six inputs.
+No inverse of an arbitrary nonunit sum is used as a free primitive.
+
+To derive it, the literal query5 source/delivery/SWAP/accumulator/postwarp,
+then five fresh queries and final source relocation, first give the six
+rows at cut69:
+
+    (Ta, Tu, T(b-r-Kz), P(r+Kz), TKz, Tc).
+
+Compose these with the exact late-cut block. Its source-dependent reverse
+reader R multiplies P on the left. Using RP=-T cancels the repeated Kz
+terms in the necessary rows and gives exactly the displayed matrix. This
+cancellation never deletes an independent dirty input.
+
+## Useful rank-neutral factorization
+
+A shorter scalar/address implementation of this matrix is obtained by:
+
+1. Apply K on bank4, ADD bank3+=bank4, ADD bank2-=bank3.
+2. Apply T separately to all six banks.
+3. Apply K on bank0; ADD bank2-=bank0.
+4. SCALE bank3 by -1; ADD bank3+=bank4.
+5. Run the source's final scalar/core segment beginning at its first
+   `dual p shared T reader`, including W, final pivot K and output BANK_SWAP.
+
+The exact executable sequence and inverse matrix are in `CUT58.json`.
+This jointly removes the old P/R pair and its intervening source relocations,
+but its native invoice is still three K queries of rank2, six T queries of
+rank2 and one W query of rank4: total22. All displayed ADD/SCALE/SWAP scans
+must be charged. The simplified sequence is an exact operator identity,
+not a new selected-native admission of its complete serialized event schema.
+
+The decomposition's fresh-T mass12 is a cost of this factorization, not a
+universal lower bound. The largest surviving single-entry native rank is6;
+that does not exclude a cost16 coupled realization of the entire matrix.
+Neither ADDRESS cancellation nor the scalar simplification proves any
+native saving. The open question is a full coupled factorization lowering
+22 to at most16, with every current input and both pivot outputs intact.
+
+## Validation and limits
+
+The source is pinned to the frozen admitted two-site receipt. Every used
+forward/inverse unary is rebound to its original source event, literal
+signed circuit, Gaussian phase residue, selected native recipe and embedding.
+The complete block and its literal inverse pass exact normal and optimized
+Python replay. Omitting the source b-accumulator changes the matrix, as does
+losing the RP=-T sign. These controls reject clean-input-only cancellations.
+
+This is finite q2, all positive f through the exact tensor-family phase
+algebra. The source's whole caller is unchanged. No broad optimizer ran,
+no native improvement or moment is claimed, and no BIT, owner, controller,
+precision, storage, partial-volume query or borrowed-axis gate is discharged.
+The rank tariff uses same-volume full-bank macros only; a heterogeneous or
+striped query model needs separate weighted accounting.
diff --git a/research/coupled-tail-support-floor/source/early-cut58-planning/VALIDATION.md b/research/coupled-tail-support-floor/source/early-cut58-planning/VALIDATION.md
new file mode 100644
index 0000000000..b3e1a387bb
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/early-cut58-planning/VALIDATION.md
@@ -0,0 +1,16 @@
+# Validation
+
+Commands, sequentially, in this owned directory:
+
+- `python3 -B cut58.py --write` — PASS.
+- `python3 -B cut58.py` — PASS exact saved receipt.
+- `python3 -B -O cut58.py` — PASS identical optimized result.
+
+Checks cover all six independent current input columns, both literal inverse
+orders, source unary signed circuits/Gaussian phases, selected recipe pool
+and physical embeddings in both directions, exact RP=-T and K=A identities,
+commutation with freshT, the displayed full6x6 matrix, a rank-neutral simpler
+network, both inverse orders for that network, native bill54+22=76, and the
+omitted-source-reader/wrong-minus controls. No enumeration or optimizer ran.
+The simpler network's complete selected-native serialized schema is not newly
+admitted; this is explicitly planning-only. No background process remains.
diff --git a/research/coupled-tail-support-floor/source/early-cut58-planning/cut58.py b/research/coupled-tail-support-floor/source/early-cut58-planning/cut58.py
new file mode 100644
index 0000000000..0f6b2917fd
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/early-cut58-planning/cut58.py
@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""Exact early cut58 block and a scan-simplifying, rank-neutral identity.
+Apache-2.0; substantial OpenAI Codex assistance. Planning only; no new kappa.
+"""
+from pathlib import Path
+from collections import Counter
+import argparse,copy,hashlib,json,sys
+sys.dont_write_bytecode=True
+HERE=Path(__file__).resolve().parent;R=HERE.parent
+PIN='30d3f569d91304856118796f0c586176d0ad961eff70b09c78fce7532392101f'
+needpath=R/'two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json'
+if hashlib.sha256(needpath.read_bytes()).hexdigest()!=PIN:raise ValueError('admitted frozen source pin')
+sys.path.insert(0,str(R/'coupled-tail-escape'))
+import local_block as late
+from joint_algebra import *
+from validate_recipe_links import compile_literal,compile_recipe,embedding_circuit
+
+def produce():
+ f=next(f for f in json.loads(needpath.read_text())['fixtures']if f['q']==2)
+ old=next(f for f in json.loads((R/'folded-fusion/SIMPLIFIED-FUSIONS.json').read_text())['fixtures']if f['q']==2)
+ n,m,cut=6,12,58;E=copy.deepcopy(f['events'][cut:]);Ei=copy.deepcopy(f['inverse_events'][:len(E)]);pool={}
+ need(E[0]['label']=='query5 source J','actual entrance is source query5, no virtual read')
+ for events in(E,Ei):
+  for e in events:
+   if e['kind']in('ADD','SCALE','BANK_SWAP'):continue
+   src=old['events'][e['source_event_ordinal']];g=qc.decode(src,m);op=compile_literal(src['one_coordinate_literal_circuit'],m)
+   ep=tuple(src['phase_exponent']*(1-r)%4 for r in range(4))
+   if e['source_operator_is_adjoint']:g=g.inv();op=op.adjoint();ep=tuple(-x%4 for x in ep)
+   e['x_monomial']=g.data();actual=compile_literal(e['one_coordinate_literal_circuit'],m)
+   same(actual,op,'cut58 source literal signed operator and Gaussian phase')
+   need(late.extra(e)==ep,'cut58 all-f global phase correction')
+   if e['kind']=='NATIVE':
+    rec=f['native_recipe_pool'][e['native_recipe_id']];d=len(rec['one_coordinate_tableau'])//2
+    selected=compile_recipe(rec['selected_native_recipe'],d)
+    full=compile_literal(embedding_circuit(selected.circuit,e['recipe_embedding'],m),m)
+    same(full,actual,'every cut58 forward/inverse selected recipe and embedding')
+    need(tuple(rec['extra_global_phase_exponent_by_f_mod4'])==ep,'cut58 selected recipe scalar family')
+    pool[e['native_recipe_id']]=rec
+ M=qc.replay(E,n,m);Mi=qc.replay(Ei,n,m)
+ need(mm(M,Mi)==mm(Mi,M)==eye(n,m),'all6 arbitrary current inputs, both literal inverse orders')
+ get=lambda label:qc.decode(next(e for e in E if e['label']==label),m)
+ K=get('query5 source J');A=get('final independent a J query');W=get('dual Q1 recovery');T=n_pair(m,5);P=get('query5 source swap')
+ RR=qc.identity(m)
+ for e in E:
+  if e['label']in('w reverse2 ADDRESS','w reverse2 selected native2','final extraction D_final inverse sign'):RR=qc.decode(e,m)@RR
+ I=mono(qc.identity(m));minus=qc.Mono(qc.identity(m).rows,0,(0,)*m,(0,)*m,0,2)
+ need(mono(K)==mono(A),'early source response equals later independent-a response')
+ need(mono(RR@P)==mono(minus@T),'reverse-current reader times source ADDRESS = -freshT')
+ for g in(K,W):need(mono(g@T)==mono(T@g),'old-support operator commutes actual freshT')
+ IW=add(I,scale(mono(W),-1));X=[[{}for _ in range(n)]for _ in range(n)]
+ X[0][0]=mono(K@T)
+ X[1][0]=scale(mono(W@K@T),-1);X[1][2]=product(IW,mono(T));X[1][3]=scale(mono(T),-1);X[1][4]=scale(mono(W@T@K),-1)
+ X[2][0]=scale(mono(K@T),-1);X[2][2]=mono(T);X[2][3]=scale(mono(T),-1);X[2][4]=scale(mono(T@K),-1)
+ X[3][0]=scale(mono(K@W@K@T),-1);X[3][1]=mono(K@T);X[3][2]=product(mono(K),product(IW,mono(T)));X[3][4]=scale(mono(K@W@T@K),-1)
+ X[4][4]=mono(T@K);X[5][5]=mono(T)
+ need(M==X,'complete displayed six-by-six early-block target')
+ # A constructive identity with the same native bill: eliminate P and R
+ # together, transport one common T across the old-support K/W operators.
+ w=Word(n,m);w.unary(4,K,'sourceK',True);w.add(3,4,1,'delivery');w.add(2,3,-1,'b accumulator')
+ for bank in range(n):w.unary(bank,T,'freshT',True)
+ w.unary(0,K,'aK',True);w.add(2,0,-1,'isolate b');
+ # SCALE is an actual full-field scan, never a free query or a discarded dirt.
+ w.M[3]=[scale(x,-1)for x in w.M[3]]
+ for row in w.Mi:row[3]=scale(row[3],-1)
+ w.events.append(dict(kind='SCALE',bank=3,coefficient='-1',label='RP=-T sign'))
+ w.add(3,4,1,'completed source reader')
+ # Copy only the final scalar/core segment, identified by its unique label.
+ start=next(i for i,e in enumerate(E)if e['label']=='dual p shared T reader')
+ for e in E[start:]:
+  if e['kind']=='ADD':w.add(e['dst'],e['src'],F(e['coefficient']),e['label'])
+  elif e['kind']=='BANK_SWAP':w.swap(*e['banks'],label=e['label'])
+  else:w.unary(e['bank'],qc.decode(e,m),e['label'],e['kind']=='NATIVE')
+ need(w.M==M and mm(w.M,w.Mi)==mm(w.Mi,w.M)==eye(n,m),'rank-neutral simplified network complete equality and inverse')
+ native=lambda ev:Counter(e['rank_per_f']for e in ev if e['kind']=='NATIVE')
+ prefixmass=sum(e['rank_per_f']for e in f['events'][:cut]if e['kind']=='NATIVE');hist=native(E)
+ need(prefixmass==54 and sum(r*c for r,c in hist.items())==22 and f['native_mass']==76,'exact original prefix54 suffix22 bill')
+ need(sum(r*c for r,c in native(w.events).items())==22,'simplified network fully charged at22')
+ no_reader=[e for e in E if e['label']!='odd b accumulator']
+ need(qc.replay(no_reader,n,m)!=M,'omitting actual arbitrary-source accumulator is rejected')
+ no_sign=copy.deepcopy(X);no_sign[1][3]=mono(T)
+ need(no_sign!=M,'losing RP minus sign changes arbitrary input3')
+ return dict(status='PASS_EXACT_EARLY_CUT58_BLOCK_PLANNING_ONLY',no_new_kappa=True,producer_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+  source_sha256=PIN,source_path=str(needpath),q=2,banks=n,ambient_arity=m,cut_event_ordinal=cut,cut_label=E[0]['label'],prefix_native_mass=54,suffix_native_mass=22,complete_mass=76,stock=72,
+  hypothetical_target_suffix_mass=16,hypothetical_complete_mass=70,target_is_not_achieved=True,
+  events=E,inverse_events=Ei,native_recipe_pool=pool,complete_local_matrix=sm(M),complete_local_inverse=sm(Mi),
+  operators=dict(T=T.data(),K=K.data(),W=W.data(),P=P.data(),reverse_current=RR.data()),
+  simplified_rank_neutral_events=w.events,simplified_native_histogram=dict(native(w.events)),original_native_histogram=dict(hist),
+  proof_scope='Exact finite q2 physical suffix on all6 independent arbitrary current banks, both inverse orders, exact all-f phase residues. The reduced scalar network is proved equal but is not separately selected-native-admitted.',
+  useful_identity='R*P=-T with actual minus phase; K=A and [K,T]=[W,T]=0. Source warp and reverse reader can be removed jointly, replacing them by one charged T and scalar sign. Native bill remains22.',
+  remaining_gap='A coupled replacement must lower22 to<=16 with the full displayed matrix unchanged. No such factorization or lower bound ruling it out is established. Entries alone only reach rank6 and do not exclude16.',
+  negative_controls=['Omitting odd source b-accumulator changes arbitrary-input matrix.','Replacing RP=-T by +T changes input3 column.'],
+  limits=['No broad enumeration or frame optimization.','No clean/correlated input promise or free copy/zero helper.','Same-volume full-bank arities only; partial/striped query costs need weighted accounting.','The neutral rewrite still pays three K rank2, six T rank2 and one W rank4 queries, plus every ADD/SCALE/SWAP scan.','No positive moment, BIT compatibility, owner/controller/precision/storage or kappa claim.'])
+
+def main():
+ a=argparse.ArgumentParser();a.add_argument('--write',action='store_true');args=a.parse_args();x=json.loads(json.dumps(produce()));p=HERE/'CUT58.json'
+ if args.write:p.write_text(json.dumps(x,indent=2,sort_keys=True)+'\n')
+ else:need(json.loads(p.read_text())==x,'saved early-cut58 receipt')
+ print(x['status'],'prefix54 suffix22; neutral rewrite22; target<=16 OPEN')
+if __name__=='__main__':main()
diff --git a/research/coupled-tail-support-floor/source/folded-fusion/SIMPLIFIED-FUSIONS.json.gz b/research/coupled-tail-support-floor/source/folded-fusion/SIMPLIFIED-FUSIONS.json.gz
new file mode 100644
index 0000000000..c97f00381c
Binary files /dev/null and b/research/coupled-tail-support-floor/source/folded-fusion/SIMPLIFIED-FUSIONS.json.gz differ
diff --git a/research/coupled-tail-support-floor/source/fusion-audit/audit_fusions.py b/research/coupled-tail-support-floor/source/fusion-audit/audit_fusions.py
new file mode 100644
index 0000000000..660be04182
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/fusion-audit/audit_fusions.py
@@ -0,0 +1,291 @@
+#!/usr/bin/env python3
+"""Independent literal circuit and metadata audit of the folded fusions.
+Apache-2.0; substantial OpenAI Codex assistance. No caller algebra import.
+"""
+from pathlib import Path
+from fractions import Fraction
+from functools import lru_cache
+from collections import Counter
+import argparse,hashlib,json,sys
+sys.dont_write_bytecode=True
+HERE=Path(__file__).resolve().parent
+FUSION=HERE.parent/'folded-fusion'
+sys.path.insert(0,str(HERE.parent/'joint-native'))
+from joint_coefficient_gate import Model,kernels,mul,phase,b,ce,need,PIN,left_gamma,f
+from literal_inverse_binding import from_circuit,circuit_op,product,sumexpr,scale,serial,act,qval
+from lifted_algebra import G
+
+
+@lru_cache(None)
+def definition(circuit,n):
+    return circuit_op(json.loads(circuit),n)
+
+
+def event_op(e,n):
+    op=definition(json.dumps(e['one_coordinate_literal_circuit']),n)
+    need(op.tab==tuple(tuple(t)for t in e['one_coordinate_tableau']),'recompiled event signed tableau')
+    need(b.native_rank(op)==e['rank_per_f'],'event actual rank differs from metadata')
+    record={'x_monomial':e['x_monomial'],'coefficients_by_f_mod4':[['1','0']for _ in range(4)]}
+    need(serialized_family([record])==from_circuit(op,e['phase_exponent']),
+         'event X-character metadata matches independent literal all-f phase')
+    return op
+
+
+@lru_cache(None)
+def family(circuit,n,exponent):
+    return from_circuit(definition(circuit,n),exponent)
+
+
+def replay(E,n,m):
+    I=from_circuit(ce.ident(m),0)
+    M=[[dict(I)if i==j else{}for j in range(n)]for i in range(n)]
+    for e in E:
+        typ=e['kind']
+        if typ=='ADD':
+            d,s=e['dst'],e['src'];M[d]=[sumexpr(x,scale(y,Fraction(e['coefficient'])))for x,y in zip(M[d],M[s])]
+        elif typ=='SCALE':M[e['bank']]=[scale(x,Fraction(e['coefficient']))for x in M[e['bank']]]
+        elif typ=='BANK_SWAP':
+            i,j=e['banks'];M[i],M[j]=M[j],M[i]
+        else:
+            event_op(e,m)
+            U=family(json.dumps(e['one_coordinate_literal_circuit']),m,e['phase_exponent'])
+            M[e['bank']]=[product(U,x)for x in M[e['bank']]]
+    return M
+
+
+def compile_monomial(rec,n):
+    return circuit_op([('D',rec['quadratic_rows'],rec['linear_Z4']),('P',rec['matrix_rows']),
+                       ('X',rec['offset']),('phase',rec['phase'])],n)
+
+
+def compile_recipe(rec,n):
+    L=compile_monomial(rec['left'],n)
+    return L if not rec['rank'] else compile_monomial(rec['right'],n).then(ce.fourier(n,range(rec['rank']))).then(L)
+
+
+def embedding(circuit,index,n):
+    d=len(index);need(len(set(index))==d and all(0<=x<n for x in index),'native embedding injective')
+    def bits(x):return sum(((x>>i)&1)<<index[i]for i in range(d))
+    out=[]
+    for e in circuit:
+        if e[0]=='P':
+            rows=[1<<i for i in range(n)]
+            for i,j in enumerate(index):rows[j]=bits(e[1][i])
+            out.append(('P',rows))
+        elif e[0]=='D':
+            rows=[0]*n;alpha=[0]*n
+            for i,j in enumerate(index):rows[j]=bits(e[1][i]);alpha[j]=e[2][i]
+            out.append(('D',rows,alpha))
+        elif e[0]in('C','X'):out.append((e[0],bits(e[1]),*e[2:]))
+        else:need(e[0]=='phase','covered embedded primitive');out.append(e)
+    return out
+
+
+def exact_recipe_phase(compiled,actual):
+    """One matrix element fixes the Gaussian ray after signed-tableau equality.
+
+    The selected recipe has only rank-many C gates, so its physical zero
+    column is sparse. The definition's matrix element is computed by an
+    exact Walsh sum of its independently derived X-character phase.
+    """
+    need(compiled.tab==actual.tab,'selected recipe tableau')
+    sparse,depth=b.sparse_column(compiled)
+    row=min(sparse);numerator=G(*sparse[row])
+    expr=from_circuit(actual,0);need(len(expr)==1,'native definition is X-character monomial')
+    (key,coeff),=expr.items();s=[0,0,0,0]
+    for w in range(1<<actual.n):s[(qval(key,w)+2*((act(key,w)&row).bit_count()&1))%4]+=1
+    total=G(Fraction(s[0]-s[2]),Fraction(s[1]-s[3]))*coeff[1]
+    need(total*G(Fraction(1<<depth))==numerator*G(Fraction(1<<actual.n)),
+         'selected recipe actual Gaussian phase, not just tableau')
+
+
+def check_recipes(fixture):
+    m=fixture['ambient_arity'];pool=fixture['native_recipe_pool'];done={};links=0
+    used={e['native_recipe_id']for e in fixture['events']+fixture['inverse_events']if e['kind']=='NATIVE'}
+    audited=used|{key for key in pool if key.startswith('fusion')}
+    for key in sorted(audited):
+        need(key in pool,'every forward/inverse native recipe pointer exists')
+        p=pool[key];n=len(p['one_coordinate_tableau'])//2
+        actual=definition(json.dumps(p['one_coordinate_definition_circuit']),n)
+        need(actual.tab==tuple(tuple(t)for t in p['one_coordinate_tableau']),'pool definition tableau')
+        need('selected_native_recipe'in p,'selected native lowering exists')
+        compiled=compile_recipe(p['selected_native_recipe'],n)
+        exact_recipe_phase(compiled,actual)
+        need(b.native_rank(actual)==p['selected_native_recipe']['rank'],'pool native arity')
+        done[key]=(p,actual)
+    for e in fixture['events']+fixture['inverse_events']:
+        if e['kind']!='NATIVE':continue
+        p,op=done[e['native_recipe_id']]
+        need(e['phase_exponent']==p['phase_exponent'],'event/pool all-f tensor unit')
+        need(len(e['recipe_embedding'])==op.n,'recipe embedding matches pool dimension')
+        embedded=embedding(op.circuit,e['recipe_embedding'],m)
+        actual=event_op(e,m)
+        need(from_circuit(circuit_op(embedded,m),e['phase_exponent'])==from_circuit(actual,e['phase_exponent']),
+             'embedded selected native definition equals event, including phase')
+        links+=1
+    return {'used_pool_entries':len(used),'audited_pool_entries':len(audited),'forward_inverse_recipe_links':links,
+            'new_recipe_keys':[x for x in sorted(audited)if x.startswith('fusion')]}
+
+
+def required(q):
+    z=Model(1,2*q+1);_,J=kernels(z);A=mul(z.N.adjoint(),J)
+    Q=mul(J.adjoint(),z.P[0],A,J);Dv=z.I
+    for r in range(2,q+1):Dv=mul(z.P[2*r],z.N,Dv)
+    Dv=mul(phase(z.n,2*(q-2)),Dv);F=z.prefix(2*q+1)
+    C=mul(F,Q.adjoint(),Dv.adjoint(),F.adjoint())
+    return z,J,F,C
+
+
+def inverse_owner_row(P,n,m,original=1):
+    I=from_circuit(ce.ident(m),0);row=[{}for _ in range(n)];row[original]=I
+    for e in P:
+        if e['kind']=='ADD':row[e['src']]=sumexpr(row[e['src']],scale(row[e['dst']],-Fraction(e['coefficient'])))
+        elif e['kind']=='SCALE':row[e['bank']]=scale(row[e['bank']],1/Fraction(e['coefficient']))
+        elif e['kind']=='BANK_SWAP':
+            i,j=e['banks'];row[i],row[j]=row[j],row[i]
+        else:
+            op=event_op(e,m)
+            row[e['bank']]=product(row[e['bank']],from_circuit(op.adjoint(),-e['phase_exponent']))
+    return row
+
+
+def serialized_family(records):
+    U=(G(Fraction(1)),G(Fraction(0),Fraction(1)),G(Fraction(-1)),G(Fraction(0),Fraction(-1)))
+    out={}
+    for record in records:
+        x=record['x_monomial'];key=(tuple(x['rows']),x['offset'],tuple(x['alpha']),tuple(x['quad']))
+        v=tuple(G(Fraction(a),Fraction(b))*U[(x.get('global_phase',0)+r*x.get('constant',0))%4]
+                for r,(a,b)in enumerate(record['coefficients_by_f_mod4']))
+        out=sumexpr(out,{key:v})
+    return out
+
+
+def formal_rewrites():
+    I,Z,J,Ji=f.I,f.Z,f.N,f.inv(f.N)
+    M0=[[I,Z],[J,I]];M1=[[J,Z],[f.neg(I),I]]
+    need(M1==f.mm(M0,[[J,Z],[Z,I]]),'all-parameter J^2 preload matrix identity')
+    Q,Du,Dv=f.mono((1,)),f.mono((2,)),f.mono((3,))
+    Qi,Ui,Vi=f.inv(Q),f.inv(Du),f.inv(Dv)
+    H=[[f.prod(Du,f.add(Q,f.neg(I)),J),Du],[f.prod(Dv,Q,J),Z]]
+    Hi=[[Z,f.prod(Ji,Qi,Vi)],[Ui,f.prod(f.add(Qi,f.neg(I)),Vi)]]
+    need(f.mm(H,Hi)==f.mm(Hi,H)==f.eye(2),'changed homogeneous endpoint inverse in both orders')
+    corrected=[[f.mul(J,x)for x in row]for row in Hi]
+    need(corrected[0]==[Z,f.prod(Qi,Vi)],'new t inverse coefficient omits old J')
+    # Every affine/public term is retained as an independent free word.
+    n,p=6,4;L=[[f.mono((20+4*i+j,))for j in range(p)]for i in range(2)]
+    M=f.eye(n)
+    for i in range(p):M[i][i]=J
+    for i in range(2):M[p+i]=L[i]+H[i]
+    W=f.eye(n)
+    for i in range(2):
+        for j in range(p):W[p+i][j]=f.neg(f.prod(J,f.summ(f.mul(Hi[i][r],L[r][j])for r in range(2)),Ji))
+        for j in range(2):W[p+i][p+j]=corrected[i][j]
+    need(f.mm(W,M)==[[J if i==j else Z for j in range(n)]for i in range(n)],
+         'unfactored joint inverse with all independent original owner/public columns')
+    U=f.mono((7,));uniform=[[U if i==j else Z for j in range(n)]for i in range(n)]
+    star=f.eye(n)
+    for i in(3,5):star[i][1]=f.neg(I)
+    need(f.mm(star,uniform)==f.mm(uniform,star),'uniform source/fresh operator commutes scalar star')
+    return {'preload_identity':'M1=M0 diag(J,I), using J^2=-I',
+            'generic_original_columns':n,'independent_public_couplings':8,
+            'changed_t_inverse_coefficient':'Q1^-1 Dv^-1 in retarded target gauge',
+            'full_homogeneous_inverse_both_orders':'PASS',
+            'uniform_stage_star_commutation':'PASS'}
+
+
+def check_fixture(name,f):
+    q,n,m=f['q'],f['banks'],f['ambient_arity'];z,J,F,C=required(q)
+    target=from_circuit(mul(F,J),2*q+2)
+    T=[[target if i==j else{}for j in range(n)]for i in range(n)]
+    A=replay(f['events'],n,m);need(A==T,'every original input reaches its actual FJ output')
+    inv=replay(f['inverse_events'],n,m)
+    Ti=from_circuit(mul(F,J).adjoint(),-2*q-2)
+    need(inv==[[Ti if i==j else{}for j in range(n)]for i in range(n)],
+         'serialized literal inverse restores every input; both orders follow')
+    need(f['events']==f['prefix_events']+f['tail_events']==f['full_events'],'current event partitions')
+    hist=dict(Counter(e['rank_per_f']for e in f['events']if e['kind']=='NATIVE'))
+    phist=dict(Counter(e['rank_per_f']for e in f['prefix_events']if e['kind']=='NATIVE'))
+    need(hist=={int(r):v for r,v in f['histogram'].items()},'current complete histogram')
+    mass=sum(r*v for r,v in hist.items());margin=n*m-sum(r*v for r,v in phist.items())
+    need(mass==n*m+8==f['native_mass'],'complete native charge')
+    row=inverse_owner_row(f['prefix_events'],n,m)
+    tv=product(target,row[3]);tu=product(target,row[1]);expected=from_circuit(C,5-3*q)
+    need(tv==expected and not tu,'current original-t inverse coefficient and phase')
+    need(b.native_rank(C)==2*q+2,'new inverse coefficient native arity')
+    metadata=[]
+    if f.get('prefix_D')!=margin:metadata.append({'field':'prefix_D','stored':f.get('prefix_D'),'actual':margin})
+    if f.get('prefix_histogram')!={str(r):v for r,v in phist.items()}:metadata.append({'field':'prefix_histogram','stored':f.get('prefix_histogram'),'actual':phist})
+    if f.get('original_t_current_V_arity_per_f')!=2*q+2:metadata.append({'field':'original_t_current_V_arity_per_f','stored':f.get('original_t_current_V_arity_per_f'),'actual':2*q+2})
+    if serialized_family(f.get('original_t_current_V_correction',[]))!=tv:metadata.append({'field':'original_t_current_V_correction','reason':'serialized operator differs from independent current inverse'})
+    inherited=['physical_prefix_matrix','physical_prefix_inverse','retarded_H','retarded_L','core_Knew','P2tilde','original_t_current_V_correction','reader_identity']
+    # These fields are inherited byte-for-byte from the old folded fixture,
+    # hence cannot be current after P2tilde=I and the right J preload.
+    old=json.loads((FUSION/'inputs/DUAL-CORE.json').read_text())
+    source=next(x for x in old['fixtures']if x['q']==q and x['name']=='folded-dual')
+    for field in inherited:
+        if f.get(field)==source.get(field):metadata.append({'field':field,'reason':'unchanged old-source field after changed core/input preload; not current evidence'})
+    if 'current_original_owner_inverse_coefficients'in f:
+        owner3=inverse_owner_row(f['prefix_events'],n,m,3)
+        for i,rw in((1,row),(3,owner3)):
+            for j in(1,3):
+                need(serialized_family(f['current_original_owner_inverse_coefficients'][str(i)][str(j)])==product(target,rw[j]),
+                     'fresh serialized original-owner inverse coefficient')
+        need(f['D']==n*m-mass and f['prefix_native_mass']==n*m-margin,'fresh mass fields')
+        need(f['tail_native_mass']==sum(e['rank_per_f']for e in f['tail_events']if e['kind']=='NATIVE'),'fresh tail bill')
+    negative=[]
+    for label in('fusion replace shared initial J by minus identity','fusion stage2 uniform fresh on former source'):
+        at=next(i for i,e in enumerate(f['events'])if e.get('label')==label)
+        wrong=f['events'][:at]+f['events'][at+1:]
+        need(replay(wrong,n,m)!=T,'actual changed-event omission negative control')
+        negative.append(label)
+    return {'artifact':name,'q':q,'all_original_columns':n,'all_positive_f':'literal circuits and exact tensor phase vectors',
+            'forward_endpoint_and_serialized_inverse':'PASS','actual_histogram':hist,'actual_mass':mass,'stock':n*m,
+            'actual_prefix_histogram':phist,'actual_prefix_margin':margin,'current_tV_arity_per_f':2*q+2,
+            'current_tV':serial(tv),'recipe_validation':check_recipes(f),'negative_controls':negative,
+            'stale_metadata_rejected':metadata,'metadata_admission':'REJECT_INHERITED_FIELDS_UNTIL_REGENERATED'if metadata else'PASS_REGENERATED_CURRENT_METADATA'}
+
+
+def run():
+    pins=json.loads((HERE/'SOURCE-PINS.json').read_text())['source_pins']
+    for x in pins:need(hashlib.sha256(Path(x['path']).read_bytes()).hexdigest()==x['sha256'],'audit source pin '+x['path'])
+    manifest=json.loads((FUSION/'MANIFEST.json').read_text())
+    for x in manifest['files']:need(hashlib.sha256((FUSION/x['path']).read_bytes()).hexdigest()==x['sha256'],'contribution manifest '+x['path'])
+    input_pins=json.loads((FUSION/'INPUT-PINS.json').read_text())
+    for x in input_pins['files']:
+        need(hashlib.sha256(Path(x['frozen_copy']).read_bytes()).hexdigest()==x['sha256'],'copied immutable input '+x['frozen_copy'])
+    for x in input_pins['imported_dependency_pins']:
+        need(hashlib.sha256(Path(x['source']).read_bytes()).hexdigest()==x['sha256'],'predecessor import '+x['source'])
+    cases=[]
+    for name in('SIMPLIFIED-FUSIONS.json','THREE-FUSIONS.json'):
+        cases.extend(check_fixture(name,x)for x in json.loads((FUSION/name).read_text())['fixtures'])
+    ranks=[]
+    for q in range(2,17):
+        z,J,F,C=required(q);g=left_gamma(C)
+        expected=[0]*z.n
+        for h in(0,1):
+            expected[h]=(1<<h)|(1<<(2+h));expected[2+h]=1<<h
+            for s in range(5,2*q+2,2):expected[2*s+h]=1<<(2*s+h)
+        need(g==tuple(expected)and b.native_rank(C)==2*q+2,'all-q fixed core-plus-odd-diagonal formula')
+        A=mul(z.N.adjoint(),J);Q=mul(J.adjoint(),z.P[0],A,J)
+        Du=mul(z.P[2],z.N)
+        for r in range(2,q+1):Du=mul(z.P[2*r-1],A,Du)
+        Urec=mul(F,Du.adjoint(),F.adjoint());Qrec=mul(F,Q.adjoint(),F.adjoint())
+        Jrec=mul(F,J,F.adjoint());fused=mul(Urec,z.T[-1])
+        need([b.native_rank(op)for op in(Urec,Qrec,Jrec,fused)]==[6,4,2,8],
+             'native tail widths and optional disjoint fresh fusion for every checked q')
+        ranks.append({'q':q,'arity_per_f':2*q+2,'default_prefix_margin':2*q+2,
+                      'U_recovery':6,'Q1_recovery':4,'J_recovery':2,'U_fresh_fusion':8,
+                      'optional_prefix_margin':2*q-4})
+    return {'status':'PASS_LITERAL_FUSION_WORDS_WITH_STALE_METADATA_REJECTED'if any(x['stale_metadata_rejected']for x in cases)else'PASS_LITERAL_FUSION_WORDS_AND_CURRENT_METADATA',
+            'scientific_pin':PIN,'producer_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+            'source_pins':pins,'cases':cases,'all_q_coefficient_checks':ranks,
+            'formal_all_parameter_rewrites':formal_rewrites(),
+            'scope':'Independent actual event/phase/recipe/operator audit at q2/q3. Written all-q local identities and conditional source interface are assessed separately. Stale inherited fields are explicitly rejected, not repaired in the contribution.',
+            'no_new_kappa':True}
+
+
+if __name__=='__main__':
+    p=argparse.ArgumentParser();p.add_argument('--write',action='store_true');a=p.parse_args();out=json.loads(json.dumps(run()));file=HERE/'AUDIT.json'
+    if a.write:file.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n')
+    else:need(json.loads(file.read_text())==out,'saved independent audit differs')
+    print(out['status'])
diff --git a/research/coupled-tail-support-floor/source/joint-native/joint_coefficient_gate.py b/research/coupled-tail-support-floor/source/joint-native/joint_coefficient_gate.py
new file mode 100644
index 0000000000..84ab2e09d8
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/joint-native/joint_coefficient_gate.py
@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""A single original-column coefficient constrains the unfactored J cleanup.
+
+Apache-2.0; substantial OpenAI Codex assistance. This is a scoped exact
+coefficient/support gate, not a complete supplier or a new exponent.
+"""
+from pathlib import Path
+from fractions import Fraction
+import argparse
+import hashlib
+import importlib.util
+import json
+import sys
+
+sys.dont_write_bytecode = True
+HERE = Path(__file__).resolve().parent
+FROZEN = HERE.parent
+NATIVE = FROZEN / 'native-frames'
+PINS = {
+    NATIVE / 'native_model.py': 'b4291b2868f91f6e77058e58e936b2efe965a9d9ae58095745fa2dad8c1d5c68',
+    NATIVE / 'even_parity_source.py': '961f136e4bc1b5da930bdd4ba9bbb594892b9e27f7ab44749d747d4fe16b4cb3',
+    NATIVE / 'EVEN-PARITY-SOURCE.json': 'dbeea9cb1abe6fff72cc98e98d9f70eed578d5094cf5f310ed7c500e26af3f3c',
+    FROZEN / 'caller' / 'free_ops.py': '5806fe91b9fda162d5986b12e085b14eb3df9a4703f749f61c1f10363138ca77',
+}
+for path, digest in PINS.items():
+    if hashlib.sha256(path.read_bytes()).hexdigest() != digest:
+        raise ValueError('frozen source pin differs: ' + str(path))
+sys.path.insert(0, str(NATIVE))
+from native_model import Model, PIN, b, ce, mul, need, phase, same
+from even_parity_source import kernels
+from lifted_algebra import Algebra
+
+spec = importlib.util.spec_from_file_location('joint_gate_free_ops', FROZEN / 'caller' / 'free_ops.py')
+f = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(f)
+
+
+def formal_core():
+    """Independent inverse formula over arbitrary noncommuting Q1/B2."""
+    Q, B2 = f.mono((1,)), f.mono((2,))
+    Qi, Bi = f.inv(Q), f.inv(B2)
+    K = [[f.add(f.add(B2, Q), f.neg(f.I)), f.add(f.I, f.neg(B2))],
+         [f.add(Q, f.neg(f.I)), f.I]]
+    Kinv = [[f.prod(Qi, Bi), f.prod(Qi, f.add(f.I, f.neg(Bi)))],
+            [f.prod(f.add(Qi, f.neg(f.I)), Bi),
+             f.add(Qi, f.prod(f.add(f.I, f.neg(Qi)), Bi))]]
+    need(f.mm(K, Kinv) == f.mm(Kinv, K) == f.eye(2),
+         'independent arbitrary-Q1/B2 core inverse both orders')
+
+    # Four public inputs and two arbitrary pivot inputs. Public coupling L
+    # has eight independent noncommuting coefficients; it is not set zero.
+    n, p = 6, 4
+    Du, Dv = f.mono((3,)), f.mono((4,))
+    H = [[f.mul(Du, x) for x in K[1]], [f.mul(Dv, x) for x in K[0]]]
+    Hinv = f.mm(Kinv, [[f.Z, f.inv(Dv)], [f.inv(Du), f.Z]])
+    need(f.mm(H, Hinv) == f.mm(Hinv, H) == f.eye(2), 'whole pivot inverse')
+    L = [[f.mono((10 + 4 * i + j,)) for j in range(p)] for i in range(2)]
+    M = f.eye(n)
+    for i in range(p):
+        M[i][i] = f.N
+    for i in range(2):
+        M[p + i] = L[i] + H[i]
+    W = f.eye(n)
+    for i in range(2):
+        for j in range(p):
+            W[p + i][j] = f.neg(f.prod(f.N, f.summ(f.mul(Hinv[i][k], L[k][j])
+                                                              for k in range(2)), f.inv(f.N)))
+        for j in range(2):
+            W[p + i][p + j] = f.prod(f.N, Hinv[i][j])
+    target = [[f.N if i == j else f.Z for j in range(n)] for i in range(n)]
+    need(f.mm(W, M) == target, 'joint correction all six original columns including public L')
+    Minv = f.eye(n)
+    for i in range(p):
+        Minv[i][i] = f.inv(f.N)
+    for i in range(2):
+        for j in range(p):
+            Minv[p + i][j] = f.neg(f.prod(f.summ(f.mul(Hinv[i][k], L[k][j])
+                                                      for k in range(2)), f.inv(f.N)))
+        for j in range(2):
+            Minv[p + i][p + j] = Hinv[i][j]
+    need(f.mm(M, Minv) == f.mm(Minv, M) == f.eye(n), 'full prefix inverse with all coupling')
+    coefficient = f.prod(f.N, Qi, Bi, f.inv(Dv))
+    need(W[p][p + 1] == coefficient, 'single current V to original t coefficient independent of L')
+    mutant = [row[:] for row in W]
+    mutant[p][p + 1] = f.prod(f.N, Bi, Qi, f.inv(Dv))
+    need(f.mm(mutant, M) != target, 'reversed Schur inverse order defect rejected')
+    return {
+        'independent_original_columns': n,
+        'independent_public_coupling_coefficients': 8,
+        'K': f.sm(K), 'K_inverse': f.sm(Kinv),
+        'H_row_order': ['Du * K_row2', 'Dv * K_row1'],
+        'required_retarded_coefficient': 'J Q1^-1 B2^-1 Dv^-1',
+        'coefficient_free_word': f.serial(coefficient),
+        'public_L_cannot_change_coefficient': True,
+        'defect_control': 'reverse Q1^-1 and B2^-1, rejected on original columns',
+    }
+
+
+def operators(q, fsize):
+    z = Model(fsize, 2 * q + 1)
+    _, J = kernels(z)
+    A = mul(z.N.adjoint(), J)
+    B1, B2 = mul(z.P[0], A), mul(z.P[1], A)
+    Q1 = mul(J.adjoint(), B1, J)
+    Dv = z.I
+    for r in range(2, q + 1):
+        Dv = mul(z.P[2 * r], z.N, Dv)
+    Dv = mul(phase(z.n, 2 * (q - 2)), Dv)
+    F = z.prefix(2 * q + 1)
+    C = mul(F, J, Q1.adjoint(), B2.adjoint(), Dv.adjoint(), F.adjoint())
+    collapsed = mul(F, A.adjoint(), z.P[0].adjoint(), z.N,
+                    z.P[1].adjoint(), Dv.adjoint(), F.adjoint())
+    return z, J, A, B1, B2, Q1, Dv, F, C, collapsed
+
+
+def expected_gamma(q, fsize):
+    n = (4 * q + 4) * fsize
+    rows = [0] * n
+    for half in (0, 1):
+        for bit in range(fsize):
+            ix = lambda plane: (2 * plane + half) * fsize + bit
+            x, y = ix(0), ix(1)
+            rows[x] = (1 << x) | (1 << y)
+            rows[y] = 1 << x
+            for plane in [2] + list(range(5, 2 * q + 2, 2)):
+                rows[ix(plane)] = 1 << ix(plane)
+    return tuple(rows)
+
+
+def left_gamma(op):
+    # U has binary form S(Gamma) P. Recover Gamma=B P^-1 independently.
+    n = op.n
+    acols = tuple(x for x, zz, ph in op.tab[:n])
+    need(all(zz == 0 and x.bit_count() == 1 for x, zz, ph in op.tab[:n]),
+         'actual coefficient X image is a coordinate permutation')
+    arows = ce.transpose(acols, n)
+    ainv_cols = ce.transpose(ce.inv(arows, n), n)
+    bcols = tuple(x for x, zz, ph in op.tab[n:])
+    def apply_cols(cols, word):
+        out = 0
+        while word:
+            bit = word & -word
+            out ^= cols[bit.bit_length() - 1]
+            word ^= bit
+        return out
+    gamma_cols = tuple(apply_cols(bcols, x) for x in ainv_cols)
+    return ce.transpose(gamma_cols, n)
+
+
+def all_f_phase(q, C1):
+    a = Algebra(2 * q + 1)
+    _, j1 = kernels(a.model)
+    J = a.lift(j1, exponent=1)
+    A = a.product(a.adjoint(a.N), J)
+    B1, B2 = a.product(a.P[0], A), a.product(a.P[1], A)
+    Q1 = a.product(a.product(a.adjoint(J), B1), J)
+    Dv = a.one
+    for r in range(2, q + 1):
+        Dv = a.product(a.product(a.P[2 * r], a.N), Dv)
+    Dv = a.scale(Dv, (-1) ** (q - 2))
+    F = a.one
+    for t in a.T:
+        F = a.product(F, t)
+    C = F
+    for x in (J, a.adjoint(Q1), a.adjoint(B2), a.adjoint(Dv), a.adjoint(F)):
+        C = a.product(C, x)
+    exponent = 6 - 3 * q
+    need(C == a.lift(C1, exponent=exponent), 'complete all-f Gaussian tensor phase, all four residues')
+    return {'q': q, 'tensor_phase_exponent': exponent,
+            'identity': 'C_f=i^((6-3q)*(1-f)) C_1^tensor(f), after bit regrouping',
+            'all_four_f_mod4_residues': 'PASS'}
+
+
+def run():
+    core = formal_core()
+    rank_checks, row_checks, phase_checks = [], [], []
+    for q in range(2, 13):
+        for fs in (1, 2):
+            z, J, A, B1, B2, Q1, Dv, F, C, collapsed = operators(q, fs)
+            gamma = left_gamma(C)
+            need(gamma == expected_gamma(q, fs), 'exact all-q block-diagonal left Gamma formula')
+            need(b.native_rank(C) == (2 * q + 4) * fs,
+                 'unfactored original-column coefficient native arity')
+            need(C.tab == collapsed.tab, 'actual collapsed signed tableau')
+            if fs == 1 and q in (2, 3, 4):
+                same(C, collapsed, 'exact core collapse with mandatory global phases')
+                state, depth = b.sparse_column(C.adjoint())
+                need(len(state) == 1 << ((2 * q + 4) * fs), 'actual row support including all cancellations')
+                row_checks.append({'q': q, 'f': fs, 'row_nonzeros': len(state), 'Gaussian_depth': depth})
+                phase_checks.append(all_f_phase(q, C))
+            rank_checks.append({'q': q, 'f': fs, 'native_arity': b.native_rank(C),
+                                'native_margin_per_f': 2 * q,
+                                'Gamma_formula': 'two copies of [[1,1],[1,0]] on(0,1), plus diagonal2 andodd5..2q+1'})
+    return {
+        'status': 'PASS_UNFACTORED_JOINT_J_COEFFICIENT_SUPPORT_GATE',
+        'scientific_pin': PIN,
+        'producer_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+        'source_pins': [{'path': str(p), 'sha256': hashlib.sha256(p.read_bytes()).hexdigest()}
+                        for p in list(PINS) + [NATIVE / 'lifted_algebra.py']],
+        'formal_original_column_core': core,
+        'physical_coefficient': 'C_tV=F J Q1^-1 B2^-1 Dv^-1 F^-1, Q1=J^-1B1J, B_s=P_s N^-1J',
+        'exact_collapsed_operator': 'F (N^-1J)^-1 P1^-1 N P2^-1 Dv^-1 F^-1',
+        'Dv': '(-1)^(q-2) (P_(2q+1)N)...(P5N)',
+        'target_gauge': 'The actual isolated output on original t is F J t. Its outgoing left monomial gauge preserves the support bound. No arbitrary replacement of its input right gauge or desired target operator is made.',
+        'all_q_native_arity': '(2q+4)f for q>=2,f>=1',
+        'rank_checks': rank_checks,
+        'actual_row_support_checks': row_checks,
+        'all_f_phase_checks': phase_checks,
+        'support_tariff': 'For the complete bank-by-address linear tail, let r_j be each native query actual arity and S the number of binary bank-ADD primitives. Then sum_j r_j+S >= (2q+4)f. Monomial ADDRESS/bank routing, nonzero Gaussian pointwise scales and phases have row branching1; each ADD has branching<=2; a rank-r native Fourier child with monomial adapters has branching2^r. Arbitrary cancellations and extra dirty/restored banks cannot increase the upper bound.',
+        'bounded_word_corollary': 'If sum r_j=R*f and S=o(f), then R>=2q+4 asymptotically. In particular R<2q cannot provide positive native deficit in such a tail. This is an explicit model premise, not an assertion that bounded-in-f scans are a repository default.',
+        'growing_scan_requirement': 'If R<2q, S >= (2q+4-R)f >4f. A paid O(f) full/partial scan construction is not excluded by this combinatorial gate. Its outer-transfer allowance belongs to the root source-bound scan audit.',
+        'extra_dirty_banks': 'Any number of independent additional dirty banks may be used and restored exactly. The full required inverse is unique on all inputs, so its original-V/current-bank coefficient remains C_tV. Initial/final zero private cells do not improve the maximum-row-support induction either.',
+        'limits': ['The full actual all-q physical prefix and source-bound H/L binding are owned by the caller lane and are not inferred from the homogeneous factory formulas alone.',
+                   'A changed initial core, right input chart/target operator, coupled owner endpoint, nonlinear computation or scan alphabet outside the stated row-branching model is not covered.',
+                   'Any operator-valued ADD with multiple monomial terms must expose those primitive ADDs or charge its actual row branching; it is not a free scalar ADD.',
+                   'No kappa, all-size supplier, owner allocation, precision or fixed-tape claim is made.'],
+        'no_new_kappa': True,
+    }
+
+
+if __name__ == '__main__':
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--write', action='store_true')
+    args = ap.parse_args()
+    out = json.loads(json.dumps(run()))
+    path = HERE / 'JOINT-COEFFICIENT-GATE.json'
+    if args.write:
+        path.write_text(json.dumps(out, indent=2, sort_keys=True) + '\n')
+    else:
+        need(json.loads(path.read_text()) == out, 'saved joint coefficient gate differs')
+    print(out['status'])
+    print('native arity (2q+4)f; exact support tariff sum(r_j)+S >= (2q+4)f')
diff --git a/research/coupled-tail-support-floor/source/joint-native/literal_inverse_binding.py b/research/coupled-tail-support-floor/source/joint-native/literal_inverse_binding.py
new file mode 100644
index 0000000000..f6af31acbc
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/joint-native/literal_inverse_binding.py
@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""Independent literal-circuit audit of the original-t inverse coefficient.
+
+No caller X-character algebra is imported. Physical event circuits are
+recompiled with the frozen Gaussian Clifford implementation, then their
+X-character actions are derived directly gate by gate. Apache-2.0;
+substantial OpenAI Codex assistance. No new kappa claim.
+"""
+from pathlib import Path
+from fractions import Fraction
+from functools import lru_cache
+import argparse
+import hashlib
+import json
+import sys
+sys.dont_write_bytecode = True
+from joint_coefficient_gate import NATIVE, PIN, operators
+from native_model import ce, mul, need, phase, b
+from lifted_algebra import G, ONE, ZERO, UNITS
+
+HERE = Path(__file__).resolve().parent
+SOURCE = HERE.parent / 'caller-joint'
+SOURCE_PINS = {
+    'joint_algebra.py': '5782033e347c9b10ad47c01ed12a0a52ea07e901fa9e8f7aa9d3a2a928327232',
+    'joint_prefix.py': 'a4dcaa1ad05ef8dbba60ddd47b3ad44a3095ebb5fd31f6adfb935a7b1c46a2c7',
+    'JOINT-PREFIX.json': 'e6e574525a51299bae4fc876c02f0a767d7d927150b7a5fe0a814afd7ec93ebd',
+}
+
+
+def par(x):
+    return x.bit_count() & 1
+
+
+def mv(rows, x):
+    return sum(par(row & x) << j for j, row in enumerate(rows))
+
+
+def circuit_op(events, n):
+    out = ce.ident(n)
+    for event in events:
+        kind = event[0]
+        if kind == 'P':
+            gate = ce.perm(n, tuple(event[1]))
+        elif kind == 'D':
+            gate = ce.diag(n, tuple(event[1]), tuple(event[2]))
+        elif kind == 'C':
+            gate = ce.cgate(n, event[1], event[2])
+        elif kind == 'X':
+            gate = ce.xgate(n, event[1])
+        elif kind == 'phase':
+            gate = phase(n, event[1])
+        else:
+            raise ValueError('uncovered physical primitive ' + kind)
+        out = out.then(gate)
+    return out
+
+
+@lru_cache(None)
+def pinv_transpose(rows):
+    return ce.transpose(ce.inv(rows, len(rows)), len(rows))
+
+
+def x_action(events, n, x):
+    """Literal action on physical X eigencharacters, including global units."""
+    power = 0
+    for event in events:
+        kind = event[0]
+        if kind == 'P':
+            x = mv(pinv_transpose(tuple(event[1])), x)
+        elif kind == 'C':
+            power += event[2] * par(event[1] & x)
+        elif kind == 'X':
+            power += 2 * par(event[1] & x)
+        elif kind == 'D':
+            need(not any(event[1]) and all(a % 2 == 0 for a in event[2]),
+                 'current source literal D is a Pauli; no Fourier-monomial assumption hidden')
+            x ^= sum(((a // 2) & 1) << j for j, a in enumerate(event[2]))
+        elif kind == 'phase':
+            power += event[1]
+        else:
+            raise ValueError(kind)
+    return x, power % 4
+
+
+def make_key(n, act, qfun):
+    offset, c = act(0), qfun(0) % 4
+    columns = [act(1 << j) ^ offset for j in range(n)]
+    rows = tuple(sum(((columns[j] >> i) & 1) << j for j in range(n)) for i in range(n))
+    alpha = tuple((qfun(1 << j) - c) % 4 for j in range(n))
+    quad = []
+    for i in range(n):
+        row = 0
+        for j in range(i + 1, n):
+            v = (qfun((1 << i) | (1 << j)) - c - alpha[i] - alpha[j]) % 4
+            need(v % 2 == 0, 'literal phase is a Gaussian quadratic')
+            row |= (v // 2) << j
+        quad.append(row)
+    return (rows, offset, alpha, tuple(quad)), c
+
+
+def act(key, x):
+    return mv(key[0], x) ^ key[1]
+
+
+def qval(key, x):
+    return (sum(a for i, a in enumerate(key[2]) if x >> i & 1)
+            + 2 * sum(par(row & x) for i, row in enumerate(key[3]) if x >> i & 1)) % 4
+
+
+def units(fn):
+    return tuple(UNITS[fn(r) % 4] for r in range(4))
+
+
+def sumexpr(a, c):
+    out = dict(a)
+    for k, v in c.items():
+        w = tuple(x + y for x, y in zip(out.get(k, (ZERO,) * 4), v))
+        if any(w):
+            out[k] = w
+        else:
+            out.pop(k, None)
+    return out
+
+
+def scale(a, c):
+    return {k: tuple(x * G(Fraction(c)) for x in v) for k, v in a.items()} if c else {}
+
+
+@lru_cache(None)
+def key_product(a, c):
+    n = len(a[0])
+    return make_key(n, lambda x: act(a, act(c, x)), lambda x: qval(c, x) + qval(a, act(c, x)))
+
+
+def product(a, c):
+    out = {}
+    for ka, va in a.items():
+        for kc, vc in c.items():
+            k, constant = key_product(ka, kc)
+            value = tuple(x * y * u for x, y, u in zip(va, vc, units(lambda r: r * constant)))
+            out = sumexpr(out, {k: value})
+    return out
+
+
+def from_circuit(op, exponent):
+    key, c = make_key(op.n, lambda x: x_action(op.circuit, op.n, x)[0],
+                      lambda x: x_action(op.circuit, op.n, x)[1])
+    return {key: units(lambda r: exponent + (c - exponent) * r)}
+
+
+def serial(a):
+    return [{'X_character_rows': list(k[0]), 'offset': k[1], 'alpha': list(k[2]),
+             'quadratic_upper_rows': list(k[3]),
+             'coefficients_by_f_mod4': [x.encode() for x in v]}
+            for k, v in sorted(a.items())]
+
+
+def inverse_row(fixture, mutate=False):
+    q, n, m = fixture['q'], fixture['banks'], fixture['ambient_arity']
+    identity = from_circuit(ce.ident(m), 0)
+    row = [{} for _ in range(n)]
+    row[1] = identity
+    hist = {}
+    for event in fixture['events']:
+        kind = event['kind']
+        if kind == 'ADD':
+            d, s = event['dst'], event['src']
+            row[s] = sumexpr(row[s], scale(row[d], -Fraction(event['coefficient'])))
+        elif kind == 'BANK_SWAP':
+            i, j = event['banks']
+            row[i], row[j] = row[j], row[i]
+        else:
+            op = circuit_op(event['one_coordinate_literal_circuit'], m)
+            need(op.tab == tuple(tuple(x) for x in event['one_coordinate_tableau']),
+                 'independently recompiled physical event signed tableau')
+            rank = b.native_rank(op)
+            if kind == 'NATIVE':
+                need(rank == event['rank_per_f'], 'actual native event arity, not label')
+                hist[rank] = hist.get(rank, 0) + 1
+            else:
+                need(rank == 0, 'free physical event is actually monomial')
+            exponent = -event['phase_exponent']
+            value = from_circuit(op.adjoint(), exponent)
+            row[event['bank']] = product(row[event['bank']], value)
+    z, J, A, B1, B2, Q1, Dv, F, C, collapsed = operators(q, 1)
+    target = from_circuit(mul(F, J), 2 * q + 2 - int(mutate))
+    actual = product(target, row[3])
+    expected = from_circuit(C, 6 - 3 * q)
+    if mutate:
+        need(actual != expected, 'missing target-J f-dependent Gaussian unit rejected beyond f1')
+    else:
+        need(actual == expected and len(actual) == 1,
+             'literal all-f inverse-row coefficient equals independent Clifford formula')
+        need(hist == {2: n * (2 * q + 1) + q + 2}, 'source/query/idle/continuation profile bound')
+    return {'q': q, 'independent_original_input_row': 1, 'current_carrier_column': 3,
+            'physical_events': len(fixture['events']), 'native_histogram': hist,
+            'original_column_binding_all_f': 'PASS' if not mutate else 'MUTANT_REJECTED',
+            'actual_coefficient': serial(actual) if not mutate else None}
+
+
+def run():
+    for name, digest in SOURCE_PINS.items():
+        need(hashlib.sha256((SOURCE / name).read_bytes()).hexdigest() == digest, 'caller source pin ' + name)
+    source = json.loads((SOURCE / 'JOINT-PREFIX.json').read_text())
+    records = [inverse_row(x) for x in source['fixtures']]
+    inverse_row(source['fixtures'][0], True)
+    return {'status': 'PASS_INDEPENDENT_LITERAL_ORIGINAL_T_INVERSE_COEFFICIENT',
+            'scientific_pin': PIN, 'producer_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+            'source_pins': [{'path': str(SOURCE / n), 'sha256': h} for n, h in SOURCE_PINS.items()],
+            'fixtures': records,
+            'method': 'Derive X-character affine/quadratic action directly from each literal physical circuit; independently recompile every signed tableau; right-multiply the original-t inverse row by each forward primitive inverse. No caller joint_algebra/quadratic_charts module is imported.',
+            'all_f_phase': 'Each physical one-coordinate circuit O with exponent e represents i^(e*(1-f))*O^tensor(f). Exact Gaussian coefficient vectors retain every f mod4 residue; native J units are not inferred from f1.',
+            'negative_control': 'Omit only the target-J f-dependent tensor unit. This changes the actual desired output gauge and is rejected by the complete inverse coefficient although f1 alone cannot see it. Individual source-query2/query5 unit deletions were insensitive for this selected inverse entry and are not counted as rejected controls.',
+            'scope': 'Independent source binding for the required inverse coefficient at q2/q3. Caller owns full physical all-column/inverse prefix; the separate written coefficient/support theorem covers every q satisfying its stated original-column interface.',
+            'no_new_kappa': True}
+
+
+if __name__ == '__main__':
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--write', action='store_true')
+    args = ap.parse_args()
+    out = json.loads(json.dumps(run()))
+    path = HERE / 'LITERAL-INVERSE-BINDING.json'
+    if args.write:
+        path.write_text(json.dumps(out, indent=2, sort_keys=True) + '\n')
+    else:
+        need(json.loads(path.read_text()) == out, 'saved independent physical coefficient binding differs')
+    print(out['status'])
diff --git a/research/coupled-tail-support-floor/source/native-frames/EVEN-PARITY-SOURCE.json b/research/coupled-tail-support-floor/source/native-frames/EVEN-PARITY-SOURCE.json
new file mode 100644
index 0000000000..2024887e51
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/native-frames/EVEN-PARITY-SOURCE.json
@@ -0,0 +1,381 @@
+{
+  "actual_checks": [
+    {
+      "f": 1,
+      "full_endpoint_recipe_actual_phase_checked": true,
+      "kernel": "even_C",
+      "query_native_arity": 1,
+      "query_recipe_actual_phase": true,
+      "retained_source_native_arity": 6
+    },
+    {
+      "f": 1,
+      "full_endpoint_recipe_actual_phase_checked": true,
+      "kernel": "quadratic_J",
+      "query_native_arity": 2,
+      "query_recipe_actual_phase": true,
+      "retained_source_native_arity": 6
+    },
+    {
+      "f": 2,
+      "full_endpoint_recipe_actual_phase_checked": true,
+      "kernel": "even_C",
+      "query_native_arity": 2,
+      "query_recipe_actual_phase": true,
+      "retained_source_native_arity": 12
+    },
+    {
+      "f": 2,
+      "full_endpoint_recipe_actual_phase_checked": true,
+      "kernel": "quadratic_J",
+      "query_native_arity": 4,
+      "query_recipe_actual_phase": true,
+      "retained_source_native_arity": 12
+    },
+    {
+      "f": 3,
+      "full_endpoint_recipe_actual_phase_checked": false,
+      "kernel": "even_C",
+      "query_native_arity": 3,
+      "query_recipe_actual_phase": true,
+      "retained_source_native_arity": 18
+    },
+    {
+      "f": 3,
+      "full_endpoint_recipe_actual_phase_checked": false,
+      "kernel": "quadratic_J",
+      "query_native_arity": 6,
+      "query_recipe_actual_phase": true,
+      "retained_source_native_arity": 18
+    }
+  ],
+  "all_f_phase_and_recipe_proof": "C_even,f=C_even,1^tensor f. J_f=i^(1-f)J_1^tensor f. E_f=i^(L*(1-f))E_1^tensor f. Therefore each source endpoint K_f E_f=i^((L+exponentK)*(1-f)) (K_1 E_1)^tensor f. Tensor the saved actualonebitnativeandmonomialrecipes, with the displayedleftglobalunit. This proves full actual phases and endpoint adapters for everyf without f1 tableau extrapolation.",
+  "all_f_two_column_checks": [
+    {
+      "all_f_input_columns": 2,
+      "kernel": "even_C",
+      "literal_inverse_orders": 2
+    },
+    {
+      "all_f_input_columns": 2,
+      "kernel": "quadratic_J",
+      "literal_inverse_orders": 2
+    }
+  ],
+  "chronological_word": [
+    "source=K source",
+    "target+=source"
+  ],
+  "complete_actual_matrix": "On entrance(E*x,E*y), output(K E*x,E*y+K E*x); bothoriginalfields arbitrary. Source remains an isolatedfullnativeoperatorK E on its ownx. No helperor cleanfield is used.",
+  "endpoint_gauge_obligation": "The fullendpointK E=L C_full R has explicitmonomialleft/rightgauges, bothpaidifused. It isnotexactE. A completecaller whoseindependentoutputsareK_i E may compose the appropriateinputrightgaugesandoutputleftgauges after proving allcolumns. The rightgaugecannotbe dropped at an intermediate mixedcut orassumedto preserve a desiredN response. A dirtyhelper owner mustpriceits actual entrance/terminalresidual; fullarityaloneisnotanownercontract.",
+  "even_only_limitation": "Every evenparityC_q commutes physicalZ_all andphysicalX_all. BinaryorthogonalA fixes1; itscorrectedtagz hasz.dot1=0 because itsphaseat1 equals1. Thus R_A=P_A Z_z also commutesbothglobalPaulis. Anybankword usingonlythoseevenqueriesandorthogonalcorrectedcontrollerscommutesdiag(Z_all), whereas afullnativeClifford with invertibleB cannotfix nonzeroZ_all. An odd/nativeanchor or a controlleroutside thatrestrictedcommutant is necessary. GeneralADDRESS adapters outside theorthogonalgroup are notcoveredbythisno-even-onlyclaim. IncomingE isexactlysuch analreadypaidanchor.",
+  "explicit_old_native_source_chart": "Let A be bitwise CNOT p0->p1 and q0->q1, and M_f=X_all_p0 Z_all_p0 P_A. Then J_f=M_f N0 M_f^-1 exactly. ADDRESSconjugation sends theoldnativeC directions to v,w; Z_p0 reverses the v parities with the mandatory i^f factor, and X_p0 supplies the remaining (-1)^f. Thus the phase is i^(f+1). M has oneaffineADDRESS plus onePauliZ scan; applying M^-1,N0,M exposes the sameJ nativequery with bothmonomialadapters paid. This is a source-frame change relative to the retainedincomingE, not a new abstract quadraticalgebra.",
+  "full_source_rank_proof": "The fullold E has binary symplecticA=D=I,B=I,C=0. A C_even query has B=Gamma=sum qk qkT. All selectedparities in each kernel are pairwiseorthogonal, so Gamma^2=0 and I+Gamma is invertible, inverseI+Gamma. A PauliZ leftfactor doesnotchangeB. Hence both C_even E andJ E have fullnativearity2Lf, for everyL>=2,f>=1. This is a rank/admission statement, not equality of the endpoint withE.",
+  "incoming_anchor": "The source already equals E*x for arbitrary x, E=product_i N_i fullnative on L>=2 oldplanes. This fullnative anchor is an incoming paid caller premise; no free preparation is claimed. The checked fixture has L=3.",
+  "limits": [
+    "No currentpublicreaderN isreplacedbyJ orC_even withouta newall-columnidentity.",
+    "No stockor exponentgain isclaimed: thepaid incominganchor, sourceCOPY/readscans, endpointgauges, ownerbinding, precisionandphysicaltapecontract remainrequired.",
+    "The fullsourceendpointgauge fixturescoverL3; the writtenrankandphaseidentitiesholdallL>=2."
+  ],
+  "literal_inverse": [
+    "target-=source",
+    "source=K^-1 source"
+  ],
+  "native_query_recipes": {
+    "even_C": {
+      "left": {
+        "linear_Z4": [
+          2,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        "matrix_rows": [
+          3,
+          1,
+          4,
+          8,
+          16,
+          32
+        ],
+        "offset": 0,
+        "phase": 0,
+        "quadratic_rows": [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      },
+      "rank": 1,
+      "right": {
+        "linear_Z4": [
+          0,
+          2,
+          0,
+          0,
+          0,
+          0
+        ],
+        "matrix_rows": [
+          2,
+          3,
+          4,
+          8,
+          16,
+          32
+        ],
+        "offset": 1,
+        "phase": 1,
+        "quadratic_rows": [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      }
+    },
+    "quadratic_J": {
+      "left": {
+        "linear_Z4": [
+          2,
+          2,
+          0,
+          0,
+          0,
+          0
+        ],
+        "matrix_rows": [
+          5,
+          10,
+          1,
+          2,
+          16,
+          32
+        ],
+        "offset": 0,
+        "phase": 0,
+        "quadratic_rows": [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      },
+      "rank": 2,
+      "right": {
+        "linear_Z4": [
+          2,
+          2,
+          2,
+          2,
+          0,
+          0
+        ],
+        "matrix_rows": [
+          4,
+          8,
+          5,
+          10,
+          16,
+          32
+        ],
+        "offset": 0,
+        "phase": 2,
+        "quadratic_rows": [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      }
+    }
+  },
+  "no_new_kappa": true,
+  "producer_sha256": "961f136e4bc1b5da930bdd4ba9bbb594892b9e27f7ab44749d747d4fe16b4cb3",
+  "quadratic_kernel": "Let v_k=p0k+p1k,w_k=q0k+q1k, U=product_k C_v_k C_w_k, Z=Z_all_p0 Z_all_q0, and J_f=i^(f+1) Z U. For each anticommtingparity, Z C_v Z=i C_v^-1; hence ZUZ=i^(2f) U^-1 and J_f^2=i^(2f+2) i^(2f)=-I for everyf. The f-dependentGaussianunit is mandatory. This has exact nativearity2f and is a changed literalJ response, nottheold N0 response.",
+  "quadratic_query_invoice": {
+    "ADDRESS_scans_at_most": 2,
+    "Gaussian_quadratic_phase_scans_at_most": 2,
+    "H2": 1,
+    "delivery_ADD_scans": 1,
+    "native_monomial_adapters": 2,
+    "native_rank_mass": 2,
+    "ordinary_helpers": 0,
+    "private_fields": 0
+  },
+  "rankf_kernel": "C_even,f=product_k C_(p0k+q0k), with C_q=((1+i)I+(1-i)X_q)/2. Each parity vector has evenweight, and they are independent. Thus nativearityf. Its exact square is X_all_commonp+commonq, a paid ADDRESS translation, not a discarded residual.",
+  "rankf_query_invoice": {
+    "ADDRESS_scans_at_most": 2,
+    "Gaussian_quadratic_phase_scans_at_most": 2,
+    "H1": 1,
+    "delivery_ADD_scans": 1,
+    "native_monomial_adapters": 2,
+    "native_rank_mass": 1,
+    "ordinary_helpers": 0,
+    "private_fields": 0
+  },
+  "retained_full_endpoint_recipes_L3": {
+    "even_C": {
+      "left": {
+        "linear_Z4": [
+          3,
+          3,
+          2,
+          2,
+          2,
+          2
+        ],
+        "matrix_rows": [
+          2,
+          1,
+          4,
+          8,
+          16,
+          32
+        ],
+        "offset": 0,
+        "phase": 0,
+        "quadratic_rows": [
+          3,
+          3,
+          0,
+          0,
+          0,
+          0
+        ]
+      },
+      "rank": 6,
+      "right": {
+        "linear_Z4": [
+          3,
+          3,
+          0,
+          0,
+          0,
+          0
+        ],
+        "matrix_rows": [
+          1,
+          2,
+          4,
+          8,
+          16,
+          32
+        ],
+        "offset": 22,
+        "phase": 3,
+        "quadratic_rows": [
+          3,
+          3,
+          0,
+          0,
+          0,
+          0
+        ]
+      }
+    },
+    "quadratic_J": {
+      "left": {
+        "linear_Z4": [
+          3,
+          3,
+          3,
+          3,
+          2,
+          2
+        ],
+        "matrix_rows": [
+          4,
+          8,
+          1,
+          2,
+          16,
+          32
+        ],
+        "offset": 0,
+        "phase": 0,
+        "quadratic_rows": [
+          5,
+          10,
+          5,
+          10,
+          0,
+          0
+        ]
+      },
+      "rank": 6,
+      "right": {
+        "linear_Z4": [
+          1,
+          1,
+          3,
+          3,
+          0,
+          0
+        ],
+        "matrix_rows": [
+          1,
+          2,
+          4,
+          8,
+          16,
+          32
+        ],
+        "offset": 22,
+        "phase": 3,
+        "quadratic_rows": [
+          5,
+          10,
+          5,
+          10,
+          0,
+          0
+        ]
+      }
+    }
+  },
+  "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90",
+  "source_pins": [
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py",
+      "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py",
+      "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f"
+    },
+    {
+      "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/lifted_algebra.py",
+      "sha256": "3b9a58a2048a762ab520ac7fdbb28cbfeb7b30345aaeb777d8dabdd9fb1034d9"
+    }
+  ],
+  "status": "PASS_ALL_F_EVEN_PARITY_AND_QUADRATIC_FULL_SOURCE_RESPONSES",
+  "wrong_constant_i_phase_controls": [
+    {
+      "f": 1,
+      "wrong_constant_i_rejected": true,
+      "wrong_constant_i_square_i_exponent": 0
+    },
+    {
+      "f": 2,
+      "wrong_constant_i_rejected": false,
+      "wrong_constant_i_square_i_exponent": 2
+    },
+    {
+      "f": 3,
+      "wrong_constant_i_rejected": true,
+      "wrong_constant_i_square_i_exponent": 0
+    }
+  ]
+}
diff --git a/research/coupled-tail-support-floor/source/native-frames/conjugated_reflection.py b/research/coupled-tail-support-floor/source/native-frames/conjugated_reflection.py
new file mode 100644
index 0000000000..341df23adc
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/native-frames/conjugated_reflection.py
@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""One native child for the common conjugate of an unpaired ADDRESS reflection.
+Apache-2.0; substantial OpenAI Codex assistance. This is a local resource.
+"""
+from pathlib import Path
+import argparse
+import hashlib
+import json
+from native_model import *
+from orthogonal_source_normalizer import reflection
+from lifted_algebra import Algebra
+
+HERE = Path(__file__).resolve().parent
+
+
+def tensor_monomial(recipe, f):
+    """Lift every one-bit wire and phase bitwise, retaining its actual phase."""
+    chunks = len(recipe['matrix_rows'])
+    n = chunks * f
+    def bitlift(mask, k):
+        return sum(1 << (chunk * f + k) for chunk in range(chunks) if (mask >> chunk) & 1)
+    rows = [bitlift(recipe['matrix_rows'][chunk], k) for chunk in range(chunks) for k in range(f)]
+    quadratic = [bitlift(recipe['quadratic_rows'][chunk], k) for chunk in range(chunks) for k in range(f)]
+    alpha = [recipe['linear_Z4'][chunk] for chunk in range(chunks) for k in range(f)]
+    offset = sum(bitlift(recipe['offset'], k) for k in range(f))
+    return mul(phase(n, f * recipe['phase']), ce.xgate(n, offset),
+               ce.perm(n, rows), ce.diag(n, quadratic, alpha))
+
+
+def run():
+    z1 = Model(1, 3)
+    R1, _ = reflection(z1, 3, (0, 1, 2, 4))
+    base_native = [z1.N, z1.T[0], z1.T[1]]
+    onebit_conjugates = [mul(Ni, R1, Ni.adjoint()) for Ni in base_native]
+    recipes = []
+    for A in onebit_conjugates:
+        rec, compiled = ce.lower_child(A)
+        need(rec['rank'] == 2, 'one-bit conjugate has native rank2')
+        same(compiled, A, 'actual selected-native one-bit lowering')
+        recipes.append(rec)
+    A1, recipe = onebit_conjugates[0], recipes[0]
+    checks = []
+    for f in (1, 2, 3):
+        z = Model(f, 3)
+        R, _ = reflection(z, 3, (0, 1, 2, 4))
+        for plane, (Ni, rec) in enumerate(zip([z.N, z.T[0], z.T[1]], recipes)):
+            A = mul(Ni, R, Ni.adjoint())
+            left = tensor_monomial(rec['left'], f)
+            right = tensor_monomial(rec['right'], f)
+            literal = mul(left, ce.fourier(z.n, range(2 * f)), right)
+            same(literal, A, 'tensor-lifted native child actual phase')
+            same(mul(A, A), z.I, 'conjugated reflection literal involution')
+            need(b.native_rank(A) == 2 * f, 'conjugated reflection rank2f')
+            need(b.native_rank(left) == b.native_rank(right) == 0, 'literal adapters monomial')
+            checks.append({'f': f, 'conjugating_old_plane': plane,
+                           'native_arity': 2 * f, 'inverse': 'same A',
+                           'tensor_recipe_actual_Gaussian_phase': True})
+
+    # Independently retain both bank columns over the exact all-f tensor algebra.
+    a = Algebra(3)
+    R, A = a.lift(R1), a.lift(A1)
+    def shear(sign):
+        out = a.mat_identity(2)
+        out[0][1] = a.scale(a.one, sign)
+        return out
+    E, Ei = shear(1), shear(-1)
+    BR = a.mat_product(a.mat_product(E, a.diagonal(2, 1, R)), Ei)
+    conjugated = a.mat_product(a.mat_product(a.diagonal(2, 0, a.N), a.diagonal(2, 1, a.N)), BR)
+    conjugated = a.mat_product(conjugated, a.mat_product(a.diagonal(2, 0, a.adjoint(a.N)), a.diagonal(2, 1, a.adjoint(a.N))))
+    expected = a.mat_product(a.mat_product(E, a.diagonal(2, 1, A)), Ei)
+    need(conjugated == expected, 'two independent bank-column conjugation identity')
+    need(a.mat_product(expected, expected) == a.mat_identity(2), 'literal bank word inverse')
+    return {'status': 'PASS_ALL_F_SINGLE_CHILD_CONJUGATED_UNPAIRED_REFLECTION',
+            'scientific_pin': PIN,
+            'producer_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+            'reflection_source_sha256': hashlib.sha256((HERE/'orthogonal_source_normalizer.py').read_bytes()).hexdigest(),
+            'native_model_sha256': hashlib.sha256((HERE/'native_model.py').read_bytes()).hexdigest(),
+            'actual_operator': 'R=P_(I+vv^T), v=(1,1,1,0,1,0) on completed(p0,q0,p1,q1,p2,q2); A=N0 R N0^-1.',
+            'all_f_tensor_identity': 'R_f is the bitwise tensor product of R_1. N_f=i^(1-f) N_1^tensor f after regrouping address coordinates. Its global unit cancels in conjugation, so A_f=A_1^tensor f literally, including phase. Tensoring the explicit one-bit monomial/native/monomial equality therefore gives A_f=L_f C_(2f) R_f_adapter. All three factors have fixed bitwise controllers; no f1 tableau-only inference is used.',
+            'native_rank_proof': 'The binary B block of A_1 has rank2. Direct sums under bitwise tensor regrouping have rank2f, so A_f and its inverse have exact native arity2f for every f>=1. A_f^2=I by conjugation of R_f^2=I.',
+            'one_bit_selected_native_recipe': recipe,
+            'one_bit_selected_native_recipes_by_old_plane': recipes,
+            'actual_tensor_recipe_checks': checks,
+            'old_plane_extension': 'The same exact single-child admission holds for A_i=N_i R N_i^-1 on each i=0,1,2, with the three explicit recipes retained. Since N_i=i H_i and H_i=Hp_i Hq_i is involutive, this is also H_i R H_i without any external i. The tensor proof and all adapter phase powers apply separately to each saved recipe.',
+            'single_unary_invoice': {'native_H2': 1, 'native_rank_mass': 2,
+                                     'monomial_adapters': 2, 'ADDRESS_scans_at_most': 2,
+                                     'Gaussian_quadratic_phase_scans_at_most': 2,
+                                     'ordinary_helpers': 0, 'private_fields': 0},
+            'two_bank_identity': 'For E12=I+e1e2^T and B_R=E12 diag(I,R) E12^-1, Ad_(diag(N,N))(B_R)=E12 diag(I,A) E12^-1. Both independent inputs are retained. Its literal inverse reverses the shears and applies A^-1=A; the entire displayed conjugated word is itself involutive.',
+            'two_bank_invoice': {'native_H2': 1, 'native_rank_mass': 2,
+                                 'scalar_ADD_scans': 2, 'monomial_adapters': 2,
+                                 'ordinary_helpers': 0, 'private_fields': 0},
+            'evidence_domain': 'Written all-f exact tensor proof and native B-rank proof; independent actual Gaussian compiled checks at f1/f2/f3; all-f two-bank polynomial coefficients checked in the phase-sensitive tensor algebra.',
+            'limits': ['This is a changed legal local bridge, not a completed caller or shared-debt cancellation.',
+                       'The source-kernel N0R is not assumed quadratic, and no old scalar caller is imported by that assumption.',
+                       'All bank ADD, ADDRESS and phase scans are paid; no source access, owner, precision, all-size or tape gate is discharged.'],
+            'no_new_kappa': True}
+
+
+if __name__ == '__main__':
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--write', action='store_true')
+    args = p.parse_args()
+    out = json.loads(json.dumps(run()))
+    path = HERE/'CONJUGATED-REFLECTION.json'
+    if args.write:
+        path.write_text(json.dumps(out, indent=2, sort_keys=True)+'\n')
+    else:
+        need(json.loads(path.read_text()) == out, 'saved conjugated reflection differs')
+    print(out['status'])
+    print(out['single_unary_invoice'])
diff --git a/research/coupled-tail-support-floor/source/native-frames/even_parity_source.py b/research/coupled-tail-support-floor/source/native-frames/even_parity_source.py
new file mode 100644
index 0000000000..602b02f549
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/native-frames/even_parity_source.py
@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""Paid even-parity native responses preserve an already-full source endpoint.
+Apache-2.0; substantial OpenAI Codex assistance. Changed kernel, no free anchor.
+"""
+from pathlib import Path
+import argparse
+import hashlib
+import json
+from native_model import *
+from conjugated_reflection import tensor_monomial
+from lifted_algebra import Algebra
+
+HERE=Path(__file__).resolve().parent
+
+
+def parity_query(z,chunks):
+    out=z.I
+    for k in range(z.f):
+        q=sum(1<<(j*z.f+k)for j in chunks)
+        out=mul(ce.cgate(z.n,q),out)
+    return out
+
+
+def kernels(z):
+    C=parity_query(z,(0,1))
+    U=mul(parity_query(z,(0,2)),parity_query(z,(1,3)))
+    Z=pauli(z.n,z=(1<<(2*z.f))-1)
+    J=mul(phase(z.n,z.f+1),Z,U)
+    return C,J
+
+
+def source_chart(z):
+    # A is bitwise CNOT p0->p1 and q0->q1. M=X_p0 Z_p0 P_A.
+    rows=[1<<j for j in range(z.n)]
+    for k in range(z.f):
+        rows[2*z.f+k]^=1<<k
+        rows[3*z.f+k]^=1<<(z.f+k)
+    p=(1<<z.f)-1
+    return mul(pauli(z.n,x=p,z=p),ce.perm(z.n,rows))
+
+
+def run():
+    z1=Model(1,2)
+    C1,J1=kernels(z1)
+    E1=mul(z1.N,*z1.T)
+    recipes={}
+    endpoint_recipes={}
+    for name,K in(('even_C',C1),('quadratic_J',J1)):
+        rec,compiled=ce.lower_child(K);same(K,compiled,'actual one-bit response lowering')
+        recipes[name]=rec
+        wr,wc=ce.lower_child(mul(K,E1));same(mul(K,E1),wc,'actual one-bit full endpoint lowering')
+        need(wr['rank']==z1.n,'source endpoint fully native')
+        endpoint_recipes[name]=wr
+    checks=[]
+    phase_mutants=[]
+    for f in(1,2,3):
+        z=Model(f,2);C,J=kernels(z);E=mul(z.N,*z.T)
+        chart=source_chart(z)
+        need(b.native_rank(chart)==0,'explicit source chart is monomial')
+        same(mul(chart,z.N,chart.adjoint()),J,'actual old-N to source-preserving-J chart phase')
+        Xtag=ce.xgate(z.n,(1<<(2*f))-1)
+        same(mul(C,C),Xtag,'evenC square is a literal ADDRESS translation')
+        same(mul(J,J),phase(z.n,2),'quadraticJ square exact minus identity allf')
+        bad=mul(phase(z.n,-f),J)
+        same(mul(bad,bad),phase(z.n,2*(f+1)),'wrong constant-i mutant has its predicted phase')
+        if f%2:
+            need(b.sparse_column(mul(bad,bad))!=b.sparse_column(phase(z.n,2)),
+                 'constant-i mutant is rejected on oddf')
+        phase_mutants.append({'f':f,'wrong_constant_i_square_i_exponent':(2*(f+1))%4,
+                              'wrong_constant_i_rejected':bool(f%2)})
+        Zall=pauli(z.n,z=(1<<z.n)-1)
+        same(mul(C,Zall),mul(Zall,C),'evenC commutes physicalZall')
+        same(mul(J,Zall),mul(Zall,J),'quadraticJ commutes physicalZall')
+        for name,K,exponent,arity in(('even_C',C,0,1),('quadratic_J',J,1,2)):
+            rec=recipes[name]
+            literal=mul(phase(z.n,exponent*(1-f)),tensor_monomial(rec['left'],f),
+                        ce.fourier(z.n,range(arity*f)),tensor_monomial(rec['right'],f))
+            same(K,literal,'native response tensor recipe actual phase')
+            W=mul(K,E)
+            need(b.native_rank(K)==arity*f and b.native_rank(W)==z.n,'query and retainedfullsource arities')
+            phase_checked=False
+            if f<=2:
+                wr=endpoint_recipes[name]
+                lowered=mul(phase(z.n,(3+exponent)*(1-f)),tensor_monomial(wr['left'],f),
+                            ce.fourier(z.n),tensor_monomial(wr['right'],f))
+                same(W,lowered,'retained full endpoint literal tensor gauge phase')
+                phase_checked=True
+            checks.append({'f':f,'kernel':name,'query_native_arity':arity*f,
+                           'retained_source_native_arity':z.n,
+                           'query_recipe_actual_phase':True,
+                           'full_endpoint_recipe_actual_phase_checked':phase_checked})
+
+    # Independently preserve both original fields and literal inverse in
+    # the full tensor-family algebra, with actual global f phases retained.
+    a=Algebra(2);E=a.product(a.product(a.N,a.T[0]),a.T[1])
+    source_records=[]
+    for name,K1,exponent in(('even_C',C1,0),('quadratic_J',J1,1)):
+        K=a.lift(K1,exponent=exponent);Ki=a.adjoint(K)
+        query=a.diagonal(2,0,K)
+        add=a.mat_identity(2);add[1][0]=a.one
+        sub=a.mat_identity(2);sub[1][0]=a.scale(a.one,-1)
+        W=a.mat_product(add,query)
+        Wi=a.mat_product(a.diagonal(2,0,Ki),sub)
+        entrance=[[E,{}],[{},E]]
+        expected=[[a.product(K,E),{}],[a.product(K,E),E]]
+        need(a.mat_product(W,entrance)==expected,'all original source and dirty target columns')
+        need(a.mat_product(W,Wi)==a.mat_product(Wi,W)==a.mat_identity(2),'literal source word inverse bothorders')
+        source_records.append({'kernel':name,'all_f_input_columns':2,'literal_inverse_orders':2})
+    return {'status':'PASS_ALL_F_EVEN_PARITY_AND_QUADRATIC_FULL_SOURCE_RESPONSES',
+            'scientific_pin':PIN,'producer_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+            'source_pins':[{'path':str(HERE/p),'sha256':hashlib.sha256((HERE/p).read_bytes()).hexdigest()}
+                           for p in('native_model.py','conjugated_reflection.py','lifted_algebra.py')],
+            'incoming_anchor':'The source already equals E*x for arbitrary x, E=product_i N_i fullnative on L>=2 oldplanes. This fullnative anchor is an incoming paid caller premise; no free preparation is claimed. The checked fixture has L=3.',
+            'rankf_kernel':'C_even,f=product_k C_(p0k+q0k), with C_q=((1+i)I+(1-i)X_q)/2. Each parity vector has evenweight, and they are independent. Thus nativearityf. Its exact square is X_all_commonp+commonq, a paid ADDRESS translation, not a discarded residual.',
+            'quadratic_kernel':'Let v_k=p0k+p1k,w_k=q0k+q1k, U=product_k C_v_k C_w_k, Z=Z_all_p0 Z_all_q0, and J_f=i^(f+1) Z U. For each anticommtingparity, Z C_v Z=i C_v^-1; hence ZUZ=i^(2f) U^-1 and J_f^2=i^(2f+2) i^(2f)=-I for everyf. The f-dependentGaussianunit is mandatory. This has exact nativearity2f and is a changed literalJ response, nottheold N0 response.',
+            'explicit_old_native_source_chart':'Let A be bitwise CNOT p0->p1 and q0->q1, and M_f=X_all_p0 Z_all_p0 P_A. Then J_f=M_f N0 M_f^-1 exactly. ADDRESSconjugation sends theoldnativeC directions to v,w; Z_p0 reverses the v parities with the mandatory i^f factor, and X_p0 supplies the remaining (-1)^f. Thus the phase is i^(f+1). M has oneaffineADDRESS plus onePauliZ scan; applying M^-1,N0,M exposes the sameJ nativequery with bothmonomialadapters paid. This is a source-frame change relative to the retainedincomingE, not a new abstract quadraticalgebra.',
+            'full_source_rank_proof':'The fullold E has binary symplecticA=D=I,B=I,C=0. A C_even query has B=Gamma=sum qk qkT. All selectedparities in each kernel are pairwiseorthogonal, so Gamma^2=0 and I+Gamma is invertible, inverseI+Gamma. A PauliZ leftfactor doesnotchangeB. Hence both C_even E andJ E have fullnativearity2Lf, for everyL>=2,f>=1. This is a rank/admission statement, not equality of the endpoint withE.',
+            'all_f_phase_and_recipe_proof':'C_even,f=C_even,1^tensor f. J_f=i^(1-f)J_1^tensor f. E_f=i^(L*(1-f))E_1^tensor f. Therefore each source endpoint K_f E_f=i^((L+exponentK)*(1-f)) (K_1 E_1)^tensor f. Tensor the saved actualonebitnativeandmonomialrecipes, with the displayedleftglobalunit. This proves full actual phases and endpoint adapters for everyf without f1 tableau extrapolation.',
+            'native_query_recipes':recipes,'retained_full_endpoint_recipes_L3':endpoint_recipes,
+            'chronological_word':['source=K source','target+=source'],
+            'complete_actual_matrix':'On entrance(E*x,E*y), output(K E*x,E*y+K E*x); bothoriginalfields arbitrary. Source remains an isolatedfullnativeoperatorK E on its ownx. No helperor cleanfield is used.',
+            'literal_inverse':['target-=source','source=K^-1 source'],
+            'rankf_query_invoice':{'H1':1,'native_rank_mass':1,'delivery_ADD_scans':1,
+                                   'native_monomial_adapters':2,'ADDRESS_scans_at_most':2,
+                                   'Gaussian_quadratic_phase_scans_at_most':2,
+                                   'ordinary_helpers':0,'private_fields':0},
+            'quadratic_query_invoice':{'H2':1,'native_rank_mass':2,'delivery_ADD_scans':1,
+                                       'native_monomial_adapters':2,'ADDRESS_scans_at_most':2,
+                                       'Gaussian_quadratic_phase_scans_at_most':2,
+                                       'ordinary_helpers':0,'private_fields':0},
+            'endpoint_gauge_obligation':'The fullendpointK E=L C_full R has explicitmonomialleft/rightgauges, bothpaidifused. It isnotexactE. A completecaller whoseindependentoutputsareK_i E may compose the appropriateinputrightgaugesandoutputleftgauges after proving allcolumns. The rightgaugecannotbe dropped at an intermediate mixedcut orassumedto preserve a desiredN response. A dirtyhelper owner mustpriceits actual entrance/terminalresidual; fullarityaloneisnotanownercontract.',
+            'even_only_limitation':'Every evenparityC_q commutes physicalZ_all andphysicalX_all. BinaryorthogonalA fixes1; itscorrectedtagz hasz.dot1=0 because itsphaseat1 equals1. Thus R_A=P_A Z_z also commutesbothglobalPaulis. Anybankword usingonlythoseevenqueriesandorthogonalcorrectedcontrollerscommutesdiag(Z_all), whereas afullnativeClifford with invertibleB cannotfix nonzeroZ_all. An odd/nativeanchor or a controlleroutside thatrestrictedcommutant is necessary. GeneralADDRESS adapters outside theorthogonalgroup are notcoveredbythisno-even-onlyclaim. IncomingE isexactlysuch analreadypaidanchor.',
+            'actual_checks':checks,'all_f_two_column_checks':source_records,
+            'wrong_constant_i_phase_controls':phase_mutants,
+            'limits':['No currentpublicreaderN isreplacedbyJ orC_even withouta newall-columnidentity.',
+                      'No stockor exponentgain isclaimed: thepaid incominganchor, sourceCOPY/readscans, endpointgauges, ownerbinding, precisionandphysicaltapecontract remainrequired.',
+                      'The fullsourceendpointgauge fixturescoverL3; the writtenrankandphaseidentitiesholdallL>=2.'],
+            'no_new_kappa':True}
+
+
+if __name__=='__main__':
+    p=argparse.ArgumentParser(description=__doc__);p.add_argument('--write',action='store_true');args=p.parse_args()
+    out=json.loads(json.dumps(run()));path=HERE/'EVEN-PARITY-SOURCE.json'
+    if args.write:path.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n')
+    else:need(json.loads(path.read_text())==out,'saved even parity source differs')
+    print(out['status'])
diff --git a/research/coupled-tail-support-floor/source/native-frames/lifted_algebra.py b/research/coupled-tail-support-floor/source/native-frames/lifted_algebra.py
new file mode 100644
index 0000000000..a63509e504
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/native-frames/lifted_algebra.py
@@ -0,0 +1,123 @@
+"""Exact all-f tensor algebra with one distinguished Pauli-controlled coordinate.
+Apache-2.0; substantial OpenAI Codex assistance. No finite-f extrapolation.
+"""
+from dataclasses import dataclass
+from fractions import Fraction as F
+from native_model import *
+@dataclass(frozen=True)
+class G:
+ a:F=F(0);b:F=F(0)
+ def __add__(s,t):
+  if not isinstance(t,G):t=G(F(t))
+  return G(s.a+t.a,s.b+t.b)
+ def __neg__(s):return G(-s.a,-s.b)
+ def __sub__(s,t):return s+-t
+ def __mul__(s,t):
+  if not isinstance(t,G):t=G(F(t))
+  return G(s.a*t.a-s.b*t.b,s.a*t.b+s.b*t.a)
+ def conj(s):return G(s.a,-s.b)
+ def __truediv__(s,t):
+  if not isinstance(t,G):t=G(F(t))
+  d=t.a*t.a+t.b*t.b;need(bool(d),'nonzero Gaussian divisor');return s*t.conj()*G(1/d)
+ def __bool__(s):return bool(s.a or s.b)
+ def encode(s):return[str(s.a),str(s.b)]
+ZERO=G();ONE=G(F(1));I=G(F(0),F(1));UNITS=(ONE,I,-ONE,-I)
+def phasevec(q):return tuple(UNITS[(q if isinstance(q,int)else q(r))%4]for r in range(4))
+def cadd(a,c):return tuple(x+y for x,y in zip(a,c))
+def cmul(a,c):return tuple(x*y for x,y in zip(a,c))
+def cconj(a):return tuple(x.conj()for x in a)
+def czero(a):return not any(a)
+class Algebra:
+ def __init__(self,stages=4):
+  self.stages=stages;self.m=2+2*stages;self.rep={};self.products={};self.inverses={};self.phase_cache={};self.model=Model(1,stages);self.idkey=self.canonical(ce.ident(self.m))[0]
+  self.one={(self.idkey,self.idkey):(ONE,)*4};self.N=self.lift(self.model.N,exponent=1);self.U=self.lift(self.model.U);self.V=self.product(self.N,self.adjoint(self.U));self.P=[self.lift(x)for x in self.model.P];self.T=[self.lift(x,exponent=1)for x in self.model.T];self.Q=[]
+  for s in range(stages+1):self.Q.append(self.lift(ce.xgate(self.m,1<<(2*s)),ce.ident(self.m)))
+ def canonical(self,op):
+  key=op.tab
+  # Same signed tableau means the representative differs by exactly a Gaussian unit.
+  state,depth=b.sparse_column(op);first=state[min(state)];q=None
+  for j in range(4):
+   a,c=b.gaussian_unit(first,-j)
+   if a>0 and c>=0:q=j;break
+  need(q is not None,'canonical Gaussian amplitude phase')
+  if key not in self.rep:self.rep[key]=op.then(phase(op.n,-q))
+  return key,q
+ def multiply_keys(self,a,c):
+  if(a,c)not in self.products:self.products[(a,c)]=self.canonical(mul(self.rep[a],self.rep[c]))
+  return self.products[(a,c)]
+ def adjoint_key(self,a):
+  if a not in self.inverses:self.inverses[a]=self.canonical(self.rep[a].adjoint())
+  return self.inverses[a]
+ def lift(self,dist,bulk=None,exponent=0):
+  if bulk is None:bulk=dist
+  kd,qd=self.canonical(dist);kb,qb=self.canonical(bulk)
+  need(b.binary_tableau(dist)==b.binary_tableau(bulk),'distinguished difference must be Pauli only')
+  return{(kd,kb):phasevec(lambda r:exponent*(1-r)+qd+qb*(r-1))}
+ def add(self,a,c):
+  out=dict(a)
+  for k,v in c.items():
+   w=cadd(out.get(k,(ZERO,)*4),v)
+   if czero(w):out.pop(k,None)
+   else:out[k]=w
+  return out
+ def scale(self,a,c):
+  if not isinstance(c,G):c=G(F(c))
+  return{k:tuple(c*x for x in v)for k,v in a.items()if c}
+ def product(self,a,c):
+  out={}
+  for(ad,ab),av in a.items():
+   for(cd,cb),cv in c.items():
+    kd,qd=self.multiply_keys(ad,cd);kb,qb=self.multiply_keys(ab,cb);phase=phasevec(lambda r:qd+qb*(r-1));value=cmul(cmul(av,cv),phase);key=(kd,kb);value=cadd(out.get(key,(ZERO,)*4),value)
+    if czero(value):out.pop(key,None)
+    else:out[key]=value
+  return out
+ def adjoint(self,a):
+  out={}
+  for(ad,ab),av in a.items():
+   kd,qd=self.adjoint_key(ad);kb,qb=self.adjoint_key(ab);value=cmul(cconj(av),phasevec(lambda r:qd+qb*(r-1)));out=self.add(out,{(kd,kb):value})
+  return out
+ def mat_identity(self,n):return[[dict(self.one)if i==j else{}for j in range(n)]for i in range(n)]
+ def mat_product(self,a,c):
+  n=len(a);out=[[{}for j in range(n)]for i in range(n)]
+  for i in range(n):
+   for k in range(n):
+    if not a[i][k]:continue
+    for j in range(n):
+     if c[k][j]:out[i][j]=self.add(out[i][j],self.product(a[i][k],c[k][j]))
+  return out
+ def router(self,n,a,c,selector=0,sign=1):
+  out=self.mat_identity(n);Q=self.scale(self.Q[selector],sign);ep=self.scale(self.add(self.one,Q),F(1,2));em=self.scale(self.add(self.one,self.scale(Q,-1)),F(1,2));out[a][a]=out[c][c]=ep;out[a][c]=out[c][a]=em;return out
+ def diagonal(self,n,bank,op):out=self.mat_identity(n);out[bank][bank]=op;return out
+ def continuation(self,choice):
+  if choice=='U':return self.U
+  if choice=='V':return self.V
+  # alpha_f=(-i)^(f+1), selected completed fresh1 p-bit. Conditional
+  # continuation is directly admitted by the R diag(U,I) R word.
+  need(choice in('C+','C-'),'known role')
+  Q=self.Q[1];ep=self.scale(self.add(self.one,Q),F(1,2));em=self.scale(self.add(self.one,self.scale(Q,-1)),F(1,2));alpha=phasevec(lambda r:-r-1);av={k:cmul(v,alpha)for k,v in self.V.items()}
+  return self.add(self.product(ep if choice=='C+'else em,self.U),self.product(em if choice=='C+'else ep,av))
+ def box(self,n,stage,kind,target,source,role='U',c=1,target_P=False):
+  out=self.mat_identity(n);W=self.continuation(role);P=self.P[stage]
+  if kind=='F':out[source][source]=self.product(W,P);out[target][source]=self.scale(self.N,c)
+  elif kind=='G':
+   Wi=self.adjoint(W);out[source][source]=Wi;out[target][target]=P;out[target][source]=self.scale(self.product(self.product(P,self.N),Wi),c)
+  else:raise ValueError(kind)
+  if target_P:
+   need(kind=='F','only forward postdelivery/pre-T target P admitted')
+   out=self.mat_product(self.diagonal(n,target,P),out)
+  return out
+ def allf_target_residual(self,a):
+  # Right-normalize the desired full native common N. A positive result
+  # has entries in the fixed distinguished Pauli algebra, bulk identity.
+  Ni=self.adjoint(self.N);res=[]
+  for row in a:
+   rr=[]
+   for entry in row:
+    v=self.product(entry,Ni)
+    if any(kb!=self.idkey for kd,kb in v):return None
+    if any(b.binary_tableau(self.rep[kd])!=b.binary_tableau(ce.ident(self.m))for kd,kb in v):return None
+    rr.append(v)
+   res.append(rr)
+  return res
+ def fingerprint(self,a):
+  return tuple(tuple(tuple(sorted((str(k),tuple((v.a,v.b)for v in vec))for k,vec in entry.items()))for entry in row)for row in a)
diff --git a/research/coupled-tail-support-floor/source/native-frames/native_model.py b/research/coupled-tail-support-floor/source/native-frames/native_model.py
new file mode 100644
index 0000000000..0ab770f491
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/native-frames/native_model.py
@@ -0,0 +1,67 @@
+"""Pinned Gaussian Clifford model for common2/fresh2 native bridges.
+Apache-2.0; substantial OpenAI Codex assistance. Frozen imports are read only.
+"""
+from pathlib import Path
+import hashlib,importlib.util,sys
+sys.dont_write_bytecode=True
+BASE=Path(__file__).resolve().parents[1]
+PIN='20ecf2891d80b5acf18d980b2164fb44ea7faa90'
+CE_PATH=BASE/'vendor/clifford_exact.py'
+CE_SHA='2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962'
+BOUND_PATH=BASE/'vendor/full_stabilizer_bound.py'
+BOUND_SHA='f073a00ad4831616e873eb110fd33ad7226010a7c2f6cfa6a6b63167bf58ef75'
+def need(ok,why):
+ if not ok:raise ValueError(why)
+def load(name,path,sha):
+ need(hashlib.sha256(path.read_bytes()).hexdigest()==sha,'source pin '+str(path))
+ spec=importlib.util.spec_from_file_location(name,path);mod=importlib.util.module_from_spec(spec);sys.modules[name]=mod;spec.loader.exec_module(mod);return mod
+ce=load('native_frames_pinned_clifford',CE_PATH,CE_SHA)
+b=load('native_frames_frozen_independent',BOUND_PATH,BOUND_SHA)
+def mul(*ops):return b.standard_product(ce,*ops)
+def same(a,c,why,phase=True):
+ need(a.tab==c.tab,why+' signed tableau')
+ if phase:need(b.sparse_column(a)==b.sparse_column(c),why+' actual Gaussian phase')
+def phase(n,p):return ce.Op(n,ce.identity(n),[('phase',p%4)])
+def symplectic_defect_rank(op):
+ return b.binary_rank(x^y for x,y in zip(b.binary_tableau(op),b.binary_tableau(ce.ident(op.n))))
+def pauli(n,x=0,z=0,p=0):
+ out=ce.diag(n,[0]*n,[2*((z>>j)&1)for j in range(n)])
+ return mul(phase(n,p),ce.xgate(n,x),out)
+def conjugated_pauli(op,x=0,z=0,p=0):
+ triple=ce.apply(op.tab,(x,z,p));return pauli(op.n,*triple),triple
+class Model:
+ def __init__(self,f=1,stages=4):
+  need(f>=1 and stages>=1,'positive chunk/stages');self.f=f;self.stages=stages;self.n=(2+2*stages)*f;self.I=ce.ident(self.n)
+  self.N=self.Npair(0,1);self.U=self.Hp(0);self.V=mul(self.N,self.U.adjoint())
+  self.P=[self.swap_pair(s+1)for s in range(stages)];self.T=[self.Npair(2+2*s,3+2*s)for s in range(stages)]
+  self.Q=ce.xgate(self.n,1)
+ def Hp(self,chunk):
+  out=self.I
+  for j in range(self.f):
+   bit=chunk*self.f+j;alpha=[0]*self.n;alpha[bit]=2
+   out=mul(ce.diag(self.n,[0]*self.n,alpha),ce.cgate(self.n,1<<bit).adjoint(),out)
+  return out
+ def Hq(self,chunk):
+  out=self.I
+  for j in range(self.f):
+   bit=chunk*self.f+j;alpha=[0]*self.n;alpha[bit]=2
+   out=mul(ce.diag(self.n,[0]*self.n,alpha),ce.cgate(self.n,1<<bit),out)
+  return out
+ def Npair(self,p,q):return mul(phase(self.n,1),self.Hp(p),self.Hq(q))
+ def swap_pair(self,s):
+  rows=[1<<j for j in range(self.n)]
+  for k in range(2*self.f):rows[k],rows[2*s*self.f+k]=rows[2*s*self.f+k],rows[k]
+  return ce.perm(self.n,rows)
+ def prefix(self,s):return mul(self.I,*self.T[:s])
+ def phi(self,a):return mul(self.N.adjoint(),a,self.N)
+ def tau(self,a):return mul(self.U,a,self.U.adjoint())
+ def upsilon(self,a):return mul(self.V,a,self.V.adjoint())
+ def pqqp(self):
+  need(self.stages>=4,'pqqp uses4 stages');gs=[self.I,self.I];controls=[];F=self.I
+  for s,(kind,W) in enumerate(zip('FGFG',[self.U,self.V,self.V,self.U])):
+   required=self.phi(gs[1])if kind=='F'else mul(W,self.N.adjoint(),gs[1],self.N,W.adjoint())
+   L=mul(required,gs[0].adjoint());controls.append(L);gs[0]=required
+   if kind=='F':gs=[gs[0],mul(W,self.P[s],gs[1],W.adjoint())]
+   else:gs=[mul(W.adjoint(),gs[0],W),mul(self.P[s],gs[1])]
+   F=mul(self.T[s],F)
+  return gs,controls
diff --git a/research/coupled-tail-support-floor/source/native-frames/orthogonal_source_normalizer.py b/research/coupled-tail-support-floor/source/native-frames/orthogonal_source_normalizer.py
new file mode 100644
index 0000000000..9ffbd4da72
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/native-frames/orthogonal_source_normalizer.py
@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""Gaussian-typed binary orthogonal normalizers at a full source cut.
+
+This is a genuine bit-linear ADDRESS extension beyond plane permutations
+and X translations. It is not itself a completed caller construction.
+Apache-2.0; substantial OpenAI Codex assistance.
+"""
+from pathlib import Path
+from fractions import Fraction
+import argparse
+import hashlib
+import json
+from native_model import *
+
+HERE = Path(__file__).resolve().parent
+
+
+def typed_D(model, oldplanes):
+    alpha, quadratic = [0] * model.n, [0] * model.n
+    for chunk in range(2 * oldplanes):
+        for bit in range(model.f):
+            k = chunk * model.f + bit
+            alpha[k] = 1 if chunk % 2 == 0 else 3
+            quadratic[k] = 1 << k
+    return ce.diag(model.n, quadratic, alpha)
+
+
+def reflection(model, oldplanes=2, support=(0, 1, 2, 3)):
+    need(len(support) % 2 == 0 and len(support) > 0, 'even nonempty reflection support')
+    need(max(support) < 2 * oldplanes, 'reflection uses only completed old chunks')
+    rows = [1 << j for j in range(model.n)]
+    for out in support:
+        for bit in range(model.f):
+            rows[out * model.f + bit] ^= sum(1 << (src * model.f + bit)
+                                            for src in support)
+    D = typed_D(model, oldplanes)
+    P = ce.perm(model.n, rows)
+    return mul(D.adjoint(), P, D), rows
+
+
+def gaussian_add(a, c):
+    return a[0] + c[0], a[1] + c[1]
+
+
+def unit(power):
+    return ((1, 0), (0, 1), (-1, 0), (0, -1))[power % 4]
+
+
+def marked_character_checks():
+    # Actual 64-point Fourier character sum, independent of Clifford tableaux.
+    def residual(w):
+        return tuple(((w >> (2 * k)) ^ (w >> (2 * k + 1))) & 1 for k in range(3))
+
+    def character_coefficient(w, wp, support):
+        v = sum(1 << k for k in support)
+        coefficient = (0, 0)
+        for x in range(64):
+            Ax = x ^ (v if (x & v).bit_count() % 2 else 0)
+            dx = sum((1 if k % 2 == 0 else -1) * ((x >> k) & 1) for k in range(6))
+            dAx = sum((1 if k % 2 == 0 else -1) * ((Ax >> k) & 1) for k in range(6))
+            sign = 2 * (((w & x).bit_count() + (wp & Ax).bit_count()) % 2)
+            coefficient = gaussian_add(coefficient, unit(dx - dAx + sign))
+        return [Fraction(a, 64) for a in coefficient]
+
+    # The initially proposed balanced reflection is NOT an escape. It maps
+    # w to w+(v.w+1)v and preserves both the unique mark and its virtual bit.
+    v = 15
+    paired_checked = 0
+    for w in range(64):
+        marks = residual(w)
+        if sum(marks) != 1:
+            continue
+        wp = w ^ (v if ((w & v).bit_count() + 1) % 2 else 0)
+        owner = marks.index(1)
+        need(character_coefficient(w, wp, (0, 1, 2, 3)) == [1, 0], 'paired exact character map')
+        need(residual(wp) == marks and ((w >> (2 * owner)) & 1) == ((wp >> (2 * owner)) & 1), 'paired reflection commutes marked C')
+        paired_checked += 1
+    # Unpaired three-p/one-q reflection is bare ADDRESS, sending q0 to p0+p1+p2.
+    w, wp = 2, 21
+    coefficient = character_coefficient(w, wp, (0, 1, 2, 4))
+    need(coefficient == [1, 0], 'unpaired actual character coefficient')
+    need(residual(w) == (1, 0, 0) and residual(wp) == (1, 1, 1), 'genuine marked-subspace leakage')
+    return {'paired_negative_control': {'one_mark_characters_checked': paired_checked,
+                                        'marked_C_commutes': True,
+                                        'all_f_lift': 'The map is bitwise. With one residual mark r=(p0,q1^f), its owner inside the balanced support makes v.w=1 at every position and R fixes the character. An owner outside makes R complement only unmarked virtual bits. The marked owner bit is unchanged.'},
+            'unpaired_escape': {'input_X_character': w, 'input_residual_marks': residual(w),
+                                'output_X_character': wp, 'output_residual_marks': residual(wp),
+                                'actual_character_matrix_coefficient': [str(x) for x in coefficient],
+                                'all_f_lift': 'Put ones on all f q0 positions and zeros elsewhere. Bare bitwise ADDRESS sends this X character to ones on all p0,p1,p2 positions, changing exactly one residual mark into three for every f>=1. No diagonal pair gauge can remove this nonzero leakage.'}}
+
+
+def run():
+    checks = []
+    onebit_recipe = None
+    for f in (1, 2, 3):
+        z = Model(f, 2)
+        R, rows = reflection(z)
+        oldG = mul(z.N, z.T[0])
+        same(mul(R, R), z.I, 'actual orthogonal normalizer involution')
+        same(mul(R, oldG), mul(oldG, R), 'actual full-source normalizer phase')
+        need(b.native_rank(R) == 0, 'orthogonal typed reflection is monomial')
+        # Literal two-bank source insertion, with oldfresh=N1 and newfresh=N2.
+        actual_source = mul(z.P[1], R.adjoint(), R, z.N, z.T[0])
+        actual_cross = mul(z.T[1], R, z.N, z.T[0])
+        desired_source = mul(z.T[1], z.T[0], z.P[1])
+        desired_cross = mul(z.T[1], z.T[0], z.N, R)
+        same(actual_source, desired_source, 'unchanged sourcecode and fresh coverage')
+        same(actual_cross, desired_cross, 'changed delivery N0R on arbitrary source column')
+        # The raw target coefficient is N2 N1 and is independent of source.
+        K = mul(z.N, R)
+        power = z.I
+        ranks = []
+        for exponent in range(1, 5):
+            power = mul(K, power)
+            ranks.append(b.native_rank(power))
+        same(power, z.I, 'exact quartic phase of this reflection kernel')
+        need(ranks == [2 * f, 2 * f, 2 * f, 0], 'kernel power is not an unproved full-native completion')
+        if f == 1:
+            compiled, onebit_recipe = ce.monomial(R)
+            same(R, compiled, 'actual literal Gaussian monomial recipe')
+        checks.append({'f': f, 'native_R': 0, 'source_old_native_planes': [0, 1],
+                       'new_fresh_plane': 2, 'source_frame_commutes_actual_phase': True,
+                       'kernel_power_native_arities': ranks, 'kernel_fourth_power': 'I'})
+    unpaired_checks = []
+    for f in (1, 2):
+        z = Model(f, 3)
+        R, rows = reflection(z, 3, (0, 1, 2, 4))
+        bare = ce.perm(z.n, rows)
+        oldG = mul(z.N, z.T[0], z.T[1])
+        same(R, bare, 'unpaired typed normalizer is literally bare ADDRESS')
+        same(mul(R, R), z.I, 'unpaired reflection literal involution')
+        same(mul(R, oldG), mul(oldG, R), 'unpaired full-source Gaussian phase')
+        need(b.native_rank(R) == 0, 'unpaired ADDRESS is nativezero')
+        actual_source = mul(z.P[2], R.adjoint(), R, z.N, z.T[0], z.T[1])
+        actual_cross = mul(z.T[2], R, z.N, z.T[0], z.T[1])
+        same(actual_source, mul(z.T[2], z.T[0], z.T[1], z.P[2]), 'unpaired unchanged source column')
+        same(actual_cross, mul(z.T[2], z.T[0], z.T[1], z.N, R), 'unpaired changed cross column phase')
+        need(b.native_rank(mul(z.N, R)) == 2 * f, 'changed cross native arity')
+        unpaired_checks.append({'f': f, 'old_native_planes': [0, 1, 2], 'new_fresh_plane': 3,
+                                'actual_typed_R_equals_bare_ADDRESS': True, 'native_R': 0,
+                                'source_and_cross_columns_actual_phase': True,
+                                'kernel_native_arity': 2 * f})
+    characters = marked_character_checks()
+    return {'status': 'PASS_ALL_F_ORTHOGONAL_TYPED_SOURCE_NORMALIZER',
+            'scientific_pin': PIN,
+            'producer_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+            'native_model_sha256': hashlib.sha256((HERE/'native_model.py').read_bytes()).hexdigest(),
+            'all_parameter_schema': 'For j old native planes (2j chunks), put D=diag phasei on everyoldp bit and-i on everyoldq bit. Exact G_old=product(N_i)=i^j D^-1 H_all D. If binaryA is orthogonal,A^T A=I, then its literal ADDRESS permutation P_A commutes ordinary WalshH_all. Hence R_A=D^-1 P_A D is monomial and commutesG_old, including all global phases, for every f>=1.',
+            'paired_reflection_negative_control': 'On two complete oldplanes v=1111 gives a legal typed R, but it COMMUTES with the marked-residual C. It is not an escape from that grammar floor. Its kernel K=N0R has exact K^4=I and nativearities2f,2f,2f,0 for its first four powers.',
+            'explicit_unpaired_reflection': 'On three complete oldplanes ordered(p0,q0,p1,q1,p2,q2), take v=(1,1,1,0,1,0), A=I+vv^T. Its support has three p chunks and one q. v^Tv=0, so A^2=A^T A=I. Apply it bitwise at all f positions. Writing d(x)=sum pbits-sum qbits, if v.x is odd then d(x)-d(Ax)=2 d_v(x)-2=0 mod4; otherwise zero. Thus R_A=D^-1 P_A D=P_A literally, with no extra Gaussian phase.',
+            'literal_gaussian_chart': 'Ononebit Hp=e^(-i pi/4) S^-1 H S and Hq=e^(+i pi/4) S H S^-1, S=diag(1,i). Their scalar factors cancel within each actual pairN=i Hp Hq, giving the exact i^j formula above. This is a conjugation identity in Gaussian operators; no irrational phase is introduced by the implementedR, which usesonly D/P_A/D^-1 with Gaussian-unit entries.',
+            'source_cut_binding': 'At stagej with oldF=productfresh1..j-1, source N0oldF is full G_old. Insert R before the source delivery and R^-1 immediately after. Then sourcePj and targetNj give boundary Fnew[[Pj,0],[N0R,I]]. The sourceoriginal column, targetoriginal column, arbitrary source crosscolumn and literal inverse all retain their phases. This doesnot assert(N0R)^2=-I.',
+            'per_pair_invoice': {'native_H2': 2, 'native_rank_mass': 4,
+                                 'delivery_ADD_scans': 1,
+                                 'existing_source_ADDRESS_scans': 1,
+                                 'new_R_ADDRESS_scans': 2,
+                                 'new_R_diagonal_phase_scans': 0,
+                                 'ordinary_helpers': 0, 'private_fields': 0},
+            'native_zero_lowering': 'The useful unpaired R is the explicit bitwise binary ADDRESS map A=I+vv^T itself. Its inverse is the same literal scan. Both new scans use only completed old chunks. The fixed binary controller and all address/source work remain paid.',
+            'paired_one_bit_monomial_recipe': onebit_recipe,
+            'paired_actual_checks': checks,
+            'unpaired_actual_checks': unpaired_checks,
+            'marked_character_checks': characters,
+            'evidence_domain': 'Written all-j/all-f orthogonal conjugation proof and explicit all-f bare-phase/leakage proof; actual Gaussian phase/source-column checks for pairedj2 f1/f2/f3 and unpairedj3 f1/f2; independent64-point actual Fourier-character sums. The paired candidate is correctly rejected as a marked-C escape. No f1-only native admission is extrapolated.',
+            'limits': ['A complete caller must retain the changed noncommuting kernelsN0R and their independent-input sourcecodes, all public couplings and the literal inverse.',
+                       'The old scalar quadratic caller cannot be reused by pretendingK^2=-I.',
+                       'No full exponent, stock/owner, all-size, precision or tape claim is made.'],
+            'no_new_kappa': True}
+
+
+if __name__ == '__main__':
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--write', action='store_true')
+    args = p.parse_args()
+    out = json.loads(json.dumps(run()))
+    path = HERE/'ORTHOGONAL-SOURCE-NORMALIZER.json'
+    if args.write:
+        path.write_text(json.dumps(out, indent=2, sort_keys=True)+'\n')
+    else:
+        need(json.loads(path.read_text()) == out, 'saved orthogonal normalizer differs')
+    print(out['status'])
+    print(out['marked_character_checks']['unpaired_escape'])
diff --git a/research/coupled-tail-support-floor/source/portable/local_block.py b/research/coupled-tail-support-floor/source/portable/local_block.py
new file mode 100644
index 0000000000..12ba0c10ed
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/portable/local_block.py
@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""Exact arbitrary-input q2 cleanup block and its single-entry support gate.
+Apache-2.0. Substantial OpenAI Codex assistance. No new caller/kappa.
+"""
+from pathlib import Path
+from collections import Counter
+import argparse, copy, hashlib, json, sys
+sys.dont_write_bytecode = True
+HERE = Path(__file__).resolve().parent
+RUNDIR = HERE.parent
+PINS = {
+    'two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json': '30d3f569d91304856118796f0c586176d0ad961eff70b09c78fce7532392101f',
+    'two-site-continuation/MANIFEST.json': '44f1e264b3087ab8fdb08b4cd6e27befefbba380852b0119321724b7bc41b5da',
+    'folded-fusion/SIMPLIFIED-FUSIONS.json': '4491cfe2a1f3e48510b33403b9b50c704865c3b1dc6d659ef5157840654e8fc3',
+    'caller-joint/joint_algebra.py': '6fe4de627845a36e2e08723e705daa86959846fe4ea577e94fca233829d7d5c9',
+    'caller-joint/validate_recipe_links.py': '30b9ad84008ff6df9597bb95964174745a6cd978b9bfde968e18b8db396416b8',
+}
+for relative, expected in PINS.items():
+    if hashlib.sha256((RUNDIR / relative).read_bytes()).hexdigest() != expected:
+        raise ValueError('frozen source pin: ' + relative)
+sys.path.insert(0, str(RUNDIR / 'caller-joint'))
+from joint_algebra import *
+from validate_recipe_links import compile_literal, compile_recipe, embedding_circuit
+
+
+def extra(e):
+    return tuple(e.get('extra_global_phase_exponent_by_f_mod4',
+                       [e.get('phase_exponent', 0)*(1-r) % 4 for r in range(4)]))
+
+
+def produce():
+    admitted = json.loads((RUNDIR / 'two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json').read_text())
+    source = json.loads((RUNDIR / 'folded-fusion/SIMPLIFIED-FUSIONS.json').read_text())
+    f = next(f for f in admitted['fixtures'] if f['q'] == 2)
+    old = next(f for f in source['fixtures'] if f['q'] == 2)
+    E = f['events']; m, n, cut = f['ambient_arity'], f['banks'], 69
+    need(E[cut]['label'] == 'final independent a J query', 'exact local physical entrance cut')
+    suffix = copy.deepcopy(E[cut:])
+    inverse = copy.deepcopy(f['inverse_events'][:len(suffix)])
+    compiled = {}
+    used_pool = {}
+    # Every unchanged suffix unary retains an explicit source-event binding.
+    for direction, events in [('forward', suffix), ('inverse', inverse)]:
+        for e in events:
+            if e['kind'] in ('ADD', 'SCALE', 'BANK_SWAP'):
+                continue
+            source_event = old['events'][e['source_event_ordinal']]
+            g = qc.decode(source_event, m)
+            if e['source_operator_is_adjoint']:
+                g = g.inv()
+            e['x_monomial'] = g.data()
+            op = compile_literal(e['one_coordinate_literal_circuit'], m)
+            need(op.tab == tuple(tuple(t) for t in e['one_coordinate_tableau']), 'actual signed source unary')
+            need(ce.rank(x for x,z,p in op.tab[m:]) == e['rank_per_f'], 'actual source unary native rank')
+            # The physical definition is compared with the pinned symbolic
+            # coordinate definition using a separately constructed circuit.
+            from joint_prefix import inverse_transpose
+            circ=[]
+            for i,a in enumerate(g.alpha):
+                if a%4 == 1:circ.append(('C',1<<i,1))
+                elif a%4 == 2:circ.extend([('C',1<<i,1)]*2)
+                elif a%4 == 3:circ.append(('C',1<<i,-1))
+            for i,row in enumerate(g.quad):
+                for j in range(i+1,m):
+                    if row>>j&1:circ.extend([('C',1<<i,1),('C',1<<j,1),('C',(1<<i)|(1<<j),-1)])
+            circ.extend([('P',inverse_transpose(g.rows)),('D',(0,)*m,tuple(2*((g.offset>>i)&1)for i in range(m))),
+                         ('phase',(g.constant+g.global_phase)%4)])
+            same(compile_literal(circ,m), op, 'actual source unary exact Gaussian phase')
+            need(extra(e) == tuple(g.global_phase*(1-r)%4 for r in range(4)), 'actual all-f source tensor phase correction')
+            if e['kind'] == 'NATIVE':
+                key=e['native_recipe_id']; rec=f['native_recipe_pool'][key]
+                local_n=len(rec['one_coordinate_tableau'])//2
+                selected=compile_recipe(rec['selected_native_recipe'],local_n)
+                full=compile_literal(embedding_circuit(selected.circuit,e['recipe_embedding'],m),m)
+                same(full,op,'every used forward/inverse selected source recipe and embedding')
+                need(tuple(rec['extra_global_phase_exponent_by_f_mod4'])==extra(e),'selected source recipe tensor-phase correction')
+                used_pool[key]=rec
+            compiled[(direction,e['label'])] = op
+    M = qc.replay(suffix,n,m); Mi = qc.replay(inverse,n,m)
+    need(mm(M,Mi) == mm(Mi,M) == eye(n,m), 'complete serialized suffix inverse both orders on every arbitrary input')
+    A = qc.decode(next(e for e in suffix if e['label']=='final independent a J query'),m)
+    W = qc.decode(next(e for e in suffix if e['label']=='dual Q1 recovery'),m)
+    reverse_events = [e for e in suffix if e['label'] in ('w reverse2 ADDRESS','w reverse2 selected native2','final extraction D_final inverse sign')]
+    RR = qc.identity(m)
+    for e in reverse_events:RR = qc.decode(e,m) @ RR
+    F5 = prefix(m,5); Q = j_operator(m).inv() @ plane_swap(m,0,1) @ n_pair(m,0).inv() @ j_operator(m) @ j_operator(m)
+    need(mono(A) == mono(F5@j_operator(m)@F5.inv()), 'actual A definition')
+    need(mono(W) == mono(F5@Q.inv()@F5.inv()), 'actual W definition')
+    minus = qc.Mono(qc.identity(m).rows,0,(0,)*m,(0,)*m,0,2)
+    need(mono(RR) == mono(minus@n_pair(m,5)@plane_swap(m,0,5)), 'actual reverse-current operator and minus phase')
+    I = mono(qc.identity(m)); Z = {}; IW = add(I,scale(mono(W),-1))
+    expected = [[{}for _ in range(n)]for _ in range(n)]
+    expected[0][0] = mono(A)
+    expected[1][0] = scale(mono(W@A),-1); expected[1][2] = IW; expected[1][3] = mono(W@RR); expected[1][4] = IW
+    expected[2][0] = scale(mono(A),-1); expected[2][2] = I
+    expected[3][0] = scale(mono(A@W@A),-1); expected[3][1] = mono(A)
+    expected[3][2] = product(mono(A),IW)
+    expected[3][3] = product(mono(A),product(scale(IW,-1),mono(RR)))
+    expected[3][4] = scale(mono(A@W),-1)
+    expected[4][4] = I; expected[5][5] = I
+    need(M == expected, 'literal entire local block equals six-by-six symbolic operator target')
+    need(len(M[1][3]) == 1 and qc.rank(next(iter(M[1][3])).polar()) == 6, 'single actual arity-six input3/output1 coefficient')
+    # Independently lower that exact coefficient to certify its uniform row
+    # support. This recipe is a witness, not a proposed complete cleanup.
+    C = ce.ident(m); ce_extra = [0]*4
+    for e in reverse_events + [next(e for e in suffix if e['label']=='dual Q1 recovery')]:
+        C = C.then(compile_literal(e['one_coordinate_literal_circuit'],m))
+        ce_extra = [(x+y)%4 for x,y in zip(ce_extra,extra(e))]
+    need(ce.rank(x for x,z,p in C.tab[m:]) == 6, 'coefficient physical B-rank6')
+    recipe, lowered = ce.lower_child(C)
+    need(recipe['rank'] == 6, 'explicit selected Fourier rank for support witness')
+    same(lowered,C,'support-witness selected child exact Gaussian phase')
+    same(compile_recipe(recipe,m),C,'independent support-witness recipe recompilation')
+    before = sum(e['rank_per_f']for e in E[:cut]if e['kind']=='NATIVE')
+    local_hist = Counter(e['rank_per_f']for e in suffix if e['kind']=='NATIVE')
+    local = sum(r*c for r,c in local_hist.items())
+    need(before == 66 and local == 10 and before+local == f['native_mass'] == 76, 'complete unchanged-prefix plus local-native bill')
+    need(f['stock'] == 72 and f['stock']-before == 6, 'exact below-stock local threshold')
+    mutant = [[dict(v) for v in row] for row in M];mutant[1][3] = {}
+    need(mutant != M, 'discarding arbitrary incoming bank3 changes an original coefficient')
+    omitted_reverse = [e for e in suffix if e['label'] != 'w reverse2 selected native2']
+    wrong = qc.replay(omitted_reverse,n,m)
+    need(wrong != M and len(wrong[1][3]) == 1, 'omitting the reverse-current native query changes the arbitrary-input block')
+    need(qc.rank(next(iter(wrong[1][3])).polar()) == 4, 'omitted reverse query spuriously lowers the witness rank')
+    need(not any(e['kind']=='SCALE'for e in suffix),'actual suffix needs no hidden SCALE cancellation')
+    return dict(status='PASS_EXACT_COUPLED_CLEANUP_BLOCK_AND_SUPPORT_BOUNDARY', no_new_kappa=True,
+                producer_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+                source_pins=[dict(path=str(RUNDIR/p),sha256=h)for p,h in PINS.items()],
+                q=2,banks=n,ambient_arity=m,cut_event_ordinal=cut,cut_label=E[cut]['label'],
+                unchanged_prefix_native_mass=before,local_native_histogram=dict(sorted(local_hist.items())),local_native_mass=local,
+                complete_mass=76,endpoint_stock=72,strict_improvement_requires_local_native_mass_less_than=6,
+                events=suffix,inverse_events=inverse,native_recipe_pool=used_pool,
+                all_original_local_columns=n,literal_inverse_orders=2,
+                complete_local_matrix=sm(M),complete_local_inverse=sm(Mi),
+                operators=dict(A=A.data(),W=W.data(),R=RR.data()),
+                unavoidable_entry=dict(row=1,column=3,operator=serial(M[1][3]),native_arity_per_f=6,
+                                      one_coordinate_tableau=C.tab,one_coordinate_literal_circuit=C.circuit,
+                                      extra_global_phase_exponent_by_f_mod4=ce_extra,
+                                      support_witness_selected_native_recipe=recipe,
+                                      role='Only certifies row support of an entry; not an executed new cleanup/native invoice.'),
+                all_f_support_inequality='sum_native_arities_R_f + binary_fullbank_ADD_count_S_f >=6f',
+                constant_scan_consequence='For this exact local interface, bounded-in-f ADD count implies liminf R_f/f>=6; unchanged prefix66f then gives asymptotic total>=72f.',
+                finite_f_scope='R_f>=6f-S_f, not a pointwise native-only6f lower bound when S_f is positive.',
+                non_native_event_counts=dict(Counter(e['kind']for e in suffix if e['kind']!='NATIVE')),
+                negative_controls=['Discarding arbitrary incoming bank3 deletes a nonzero arity6 coefficient and is rejected.',
+                                   'Omitting reverse-current N5 changes the exact matrix and spuriously lowers entry rank6 to4; rejected.'],
+                limits=['Any replacement must realize this exact current-input matrix on all arbitrary banks, not only a clean/correlated subspace.',
+                        'Arbitrary extra dirty registers restored are permitted by the support proof; their identity coefficient rows start with support1.',
+                        'Native rank mass lower bound uses monomial adapters/scalars of row support1 and binary ADD/COPY gates, counting every support-doubling scan.',
+                        'Growing O(f) ADD counts, partial/fused scan machine models, changed input/output gauges or an earlier fresh/source/coupled cut require separate analysis.',
+                        'No expensive enumeration, new full cleanup factorization, supplier, owner, BIT, recurrence or kappa admission.'])
+
+
+def main():
+    p = argparse.ArgumentParser();p.add_argument('--write',action='store_true');a=p.parse_args()
+    result=json.loads(json.dumps(produce()));out=HERE/'LOCAL-BLOCK.json'
+    if a.write:out.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n')
+    else:need(json.loads(out.read_text())==result,'saved coupled local block')
+    print(result['status'],'fixed66 + local10; unavoidable entry6f; no bounded-scan local bill<6f')
+
+
+if __name__=='__main__':main()
diff --git a/research/coupled-tail-support-floor/source/root-chronology/quadratic_charts.py b/research/coupled-tail-support-floor/source/root-chronology/quadratic_charts.py
new file mode 100644
index 0000000000..80f2d4d055
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/root-chronology/quadratic_charts.py
@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""Exact X-character monomial algebra and bounded quadratic-chart retiming.
+
+Apache-2.0; substantial OpenAI Codex assistance. Rank screens do not admit a
+physical supplier. A saved positive word must separately lower every child.
+"""
+from dataclasses import dataclass
+from functools import lru_cache
+from fractions import Fraction
+from heapq import nsmallest
+from math import isqrt
+import argparse, hashlib, json
+from pathlib import Path
+
+HERE=Path(__file__).resolve().parent
+def need(c,m):
+    if not c: raise ValueError(m)
+def parity(x): return x.bit_count()&1
+def linear(rows,x): return sum(parity(r&x)<<i for i,r in enumerate(rows))
+def inverse(rows):
+    n=len(rows);a=[r|(1<<(n+i)) for i,r in enumerate(rows)]
+    for i in range(n):
+        j=next((j for j in range(i,n) if a[j]>>i&1),None)
+        need(j is not None,'invertible binary address');a[i],a[j]=a[j],a[i]
+        for j in range(n):
+            if j!=i and a[j]>>i&1:a[j]^=a[i]
+    return tuple(r>>n for r in a)
+@lru_cache(None)
+def rank(rows):
+    basis={}
+    for r in rows:
+        while r:
+            p=r.bit_length()-1
+            if p in basis:r^=basis[p]
+            else:basis[p]=r;break
+    return len(basis)
+
+@dataclass(frozen=True)
+class Mono:
+    rows:tuple
+    offset:int
+    alpha:tuple
+    quad:tuple
+    constant:int=0
+    global_phase:int=0
+    # Actual all-f family: i^global_phase times the f-fold tensor power.
+    def q(self,x):
+        return (self.constant+sum(a for i,a in enumerate(self.alpha) if x>>i&1)
+                +2*sum(parity(r&x) for i,r in enumerate(self.quad) if x>>i&1))%4
+    def act(self,x):return linear(self.rows,x)^self.offset
+    def __matmul__(self,b):return compose(self,b)
+    def inv(self):return adjoint(self)
+    def data(self):return dict(rows=list(self.rows),offset=self.offset,alpha=list(self.alpha),quad=list(self.quad),constant=self.constant,global_phase=self.global_phase)
+    def polar(self):
+        r=[(self.alpha[i]&1)<<i for i in range(len(self.rows))]
+        for i,row in enumerate(self.quad):
+            for j in range(i+1,len(r)):
+                if row>>j&1:r[i]^=1<<j;r[j]^=1<<i
+        return tuple(r)
+
+def from_function(rows,offset,fn,global_phase=0):
+    n=len(rows);c=fn(0)%4;alpha=tuple((fn(1<<i)-c)%4 for i in range(n));quad=[]
+    for i in range(n):
+        row=0
+        for j in range(i+1,n):
+            z=(fn((1<<i)|(1<<j))-c-alpha[i]-alpha[j])%4
+            need(z%2==0,'quadratic Gaussian phase');row|=(z//2)<<j
+        quad.append(row)
+    return Mono(tuple(rows),offset,alpha,tuple(quad),c,global_phase%4)
+
+@lru_cache(None)
+def compose(a,b):
+    n=len(a.rows);rows=tuple(sum(parity(a.rows[i]&sum(((b.rows[k]>>j)&1)<<k for k in range(n)))<<j for j in range(n)) for i in range(n))
+    return from_function(rows,linear(a.rows,b.offset)^a.offset,
+                         lambda x:b.q(x)+a.q(b.act(x)),a.global_phase+b.global_phase)
+@lru_cache(None)
+def adjoint(a):
+    rows=inverse(a.rows);off=linear(rows,a.offset)
+    return from_function(rows,off,lambda x:-a.q(linear(rows,x)^off),-a.global_phase)
+def identity(n):return Mono(tuple(1<<i for i in range(n)),0,(0,)*n,(0,)*n)
+@lru_cache(None)
+def chart(rows):
+    n=len(rows)
+    return Mono(tuple(1<<i for i in range(n)),0,tuple((r>>i)&1 for i,r in enumerate(rows)),tuple(r&~((1<<(i+1))-1) for i,r in enumerate(rows)))
+def old_operator(e,n):
+    d=e['operator'];p=d['block_permutation'];rows=[0]*n
+    for i,j in enumerate(p):rows[2*j]=1<<(2*i);rows[2*j+1]=1<<(2*i+1)
+    out=Mono(tuple(rows),0,(0,)*n,(0,)*n)
+    alpha=[0]*n;offset=0
+    for i in d['native_blocks']:alpha[2*i]=3;alpha[2*i+1]=1;offset^=3<<(2*i)
+    N=Mono(identity(n).rows,offset,tuple(alpha),(0,)*n,0,(len(d['native_blocks'])+(2 if d['sign']==-1 else 0))%4)
+    return N@out
+def decode(e,n):
+    if 'x_monomial' in e:
+        d=e['x_monomial'];return Mono(tuple(d['rows']),d['offset'],tuple(d['alpha']),tuple(d['quad']),d.get('constant',0),d.get('global_phase',0))
+    if e['kind']=='ADDRESS_LINEAR':
+        # Physical P_A acts on X characters by A^-T.
+        ri=inverse(tuple(e['operator']['address_rows']))
+        rows=tuple(sum(((ri[j]>>i)&1)<<j for j in range(n)) for i in range(n))
+        return Mono(rows,0,(0,)*n,(0,)*n)
+    return old_operator(e,n)
+def xor(a,b):return tuple(x^y for x,y in zip(a,b))
+@lru_cache(None)
+def move(g,A):
+    # g D_A = D_B h with h physically monomial (native rank zero).
+    n=len(A);ri=inverse(g.rows);C=xor(g.polar(),A)
+    cols=tuple(sum(((ri[i]>>j)&1)<<i for i in range(n)) for j in range(n))
+    return tuple(sum(parity(u&linear(C,v))<<j for j,v in enumerate(cols)) for u in cols)
+
+def future_charts(events,banks,n):
+    gs=[identity(n)]*banks;out=[None]*(len(events)+1);out[-1]=tuple(g.polar()for g in gs)
+    for k in range(len(events)-1,-1,-1):
+        e=events[k]
+        if e['kind']=='BANK_SWAP':i,j=e['banks'];gs[i],gs[j]=gs[j],gs[i]
+        elif e['kind']not in('ADD','SCALE'):i=e['bank'];gs[i]=gs[i]@decode(e,n)
+        out[k]=tuple(g.polar()for g in gs)
+    return out
+
+def search(events,banks,n,beam,heuristic_weight=1,future_hint=False):
+    zero=(0,)*n;cap=isqrt((n*n-1)//2)
+    future=future_charts(events,banks,n)
+    states={(zero,)*banks:(0,())};sizes=[]
+    for index,e in enumerate(events):
+        kind=e['kind']
+        if kind=='ADD':
+            d,s=e['dst'],e['src'];out={}
+            for state,(cost,path) in states.items():
+                A,B=state[d],state[s]
+                candidates={zero,A,B,xor(A,B),tuple(a&b for a,b in zip(A,B)),tuple(a|b for a,b in zip(A,B))}
+                if future_hint:candidates.update((future[index+1][d],future[index+1][s]))
+                for R in candidates:
+                    ranks=rank(xor(A,R)),rank(xor(B,R))
+                    ns=list(state);ns[d]=ns[s]=R;ns=tuple(ns);c=cost+sum(ranks)
+                    if ns not in out or c<out[ns][0]:out[ns]=(c,path+(R,))
+            def priority(item):
+                st,(cost,path)=item
+                debt=sum(rank(xor(a,b))for a,b in zip(st,future[index+1])) if future_hint else sum(map(rank,st))
+                return cost+heuristic_weight*debt,cost,st
+            states=dict(nsmallest(beam,out.items(),key=priority));sizes.append([index,len(out),len(states)])
+        elif kind=='SCALE':pass
+        elif kind=='BANK_SWAP':
+            out={};i,j=e['banks']
+            for state,v in states.items():ns=list(state);ns[i],ns[j]=ns[j],ns[i];out[tuple(ns)]=v
+            states=out
+        else:
+            g=decode(e,n);i=e['bank'];out={}
+            for state,v in states.items():ns=list(state);ns[i]=move(g,state[i]);out[tuple(ns)]=v
+            states=out
+        need(states,'nonempty bounded chart screen')
+    eligible=list(states.items())
+    st,(cost,path)=min(eligible,key=lambda x:(x[1][0]+sum(map(rank,x[0])),x[0]))
+    return path,cost+sum(map(rank,st)),sizes
+
+def compile_word(events,banks,n,choices):
+    pending=[(0,)*n for _ in range(banks)];out=[];choices=iter(choices)
+    def emit(i,g,label):
+        if g!=identity(n):out.append(dict(kind='NATIVE' if rank(g.polar()) else 'ADDRESS_OR_UNIT',bank=i,x_monomial=g.data(),rank_per_f=rank(g.polar()),label=label))
+    for e in events:
+        if e['kind']=='ADD':
+            R=next(choices)
+            for i in (e['dst'],e['src']):emit(i,chart(R).inv()@chart(pending[i]),'paid quadratic chart alignment');pending[i]=R
+            out.append(e)
+        elif e['kind']=='SCALE':out.append(e)
+        elif e['kind']=='BANK_SWAP':
+            i,j=e['banks'];pending[i],pending[j]=pending[j],pending[i];out.append(e)
+        else:
+            g=decode(e,n);i=e['bank'];B=move(g,pending[i]);h=chart(B).inv()@g@chart(pending[i])
+            need(rank(h.polar())==0,'transport adapter is physically monomial');emit(i,h,'literal free chart transport');pending[i]=B
+    need(next(choices,None) is None,'one choice per ADD')
+    for i,A in enumerate(pending):emit(i,chart(A),'paid final chart')
+    return out
+
+def replay(events,banks,n):
+    I=identity(n);one=(Fraction(1),Fraction(0))*4;zero=(Fraction(0),)*8
+    def rotate(v,c,g):
+        out=[]
+        for r in range(4):
+            a,b=v[2*r:2*r+2]
+            out.extend(((a,b),(-b,a),(-a,-b),(b,-a))[(c*r+g)%4])
+        return tuple(out)
+    def normalize(k,v):
+        return Mono(k.rows,k.offset,k.alpha,k.quad),rotate(v,k.constant,k.global_phase)
+    M=[[{I:one} if i==j else {} for j in range(banks)] for i in range(banks)]
+    for e in events:
+        if e['kind']=='ADD':
+            d,s=e['dst'],e['src'];c=Fraction(e['coefficient'])
+            for j in range(banks):
+                row=dict(M[d][j])
+                for k,v in M[s][j].items():row[k]=tuple(a+c*b for a,b in zip(row.get(k,zero),v))
+                M[d][j]={k:v for k,v in row.items() if any(v)}
+        elif e['kind']=='SCALE':
+            i=e['bank'];c=Fraction(e['coefficient']);need(c!=0,'invertible scalar bank scaling');M[i]=[{k:tuple(c*x for x in v)for k,v in entry.items()}for entry in M[i]]
+        elif e['kind']=='BANK_SWAP':i,j=e['banks'];M[i],M[j]=M[j],M[i]
+        else:
+            g=decode(e,n);i=e['bank'];M[i]=[dict(normalize(g@k,v) for k,v in entry.items()) for entry in M[i]]
+    return M
+
+def controls():
+    n=6;I=identity(n);v=sum(1<<j for j in(0,1,2,4));R=Mono(tuple((1<<i)^(v if v>>i&1 else 0)for i in range(n)),0,(0,)*n,(0,)*n)
+    alpha=(3,1,0,0,0,0);N=Mono(I.rows,3,alpha,(0,)*n,0,1)
+    need(R@R==I and N@N==Mono(I.rows,0,(0,)*n,(0,)*n,0,2),'literal reflection and native square')
+    A=N@R@N.inv();need(rank(A.polar())==2,'independent conjugated reflection rank')
+    for a in (R,N,A,N@R):
+        need(a@a.inv()==I==a.inv()@a,'both literal inverses')
+        for b in (R,N,A):
+            c=a@b
+            for x in range(1<<n):need(c.act(x)==a.act(b.act(x)) and c.q(x)==(b.q(x)+a.q(b.act(x)))%4,'complete exact one-bit monomial composition')
+
+def main():
+    p=argparse.ArgumentParser();p.add_argument('--source',type=Path);p.add_argument('--beam',type=int,default=256);p.add_argument('--heuristic-weight',type=int,default=1);p.add_argument('--future-hint',action='store_true');p.add_argument('--write',action='store_true');a=p.parse_args();controls()
+    if a.source is None:print('PASS_EXACT_QUADRATIC_CHART_ALGEBRA');return
+    raw=a.source.read_bytes();src=json.loads(raw);events=src['events'];banks=src.get('width',src.get('banks'));n=src['ambient_arity']
+    choices,mass,sizes=search(events,banks,n,a.beam,a.heuristic_weight,a.future_hint);out=compile_word(events,banks,n,choices)
+    need(replay(events,banks,n)==replay(out,banks,n),'all independent input columns preserved exactly for every f')
+    need(sum(e.get('rank_per_f',0)for e in out)==mass,'complete screened rank invoice')
+    result=dict(status='PASS_EXACT_QUADRATIC_CHART_RETIMING',no_new_kappa=True,producer_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),source_path=str(a.source),source_sha256=hashlib.sha256(raw).hexdigest(),beam=a.beam,heuristic_weight=a.heuristic_weight,future_hint=a.future_hint,width=banks,ambient_arity=n,native_rank_mass=mass,stock=n*banks,choices=choices,beam_sizes=sizes,events=out,limits=['Bounded search is not an optimality proof.','Rank-based child costs require explicit selected-native lowering and all-f adapters, including contracting splits of large-rank phases, before admission.','No precision, owner, COPY, tape or joint BIT contract is discharged.'])
+    path=HERE/('QUADRATIC-'+a.source.stem+'-'+str(a.beam)+'-H'+str(a.heuristic_weight)+('-F'if a.future_hint else '')+'.json');result=json.loads(json.dumps(result))
+    if a.write:path.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n')
+    else:need(json.loads(path.read_bytes())==result,'saved exact retiming differs')
+    print(result['status'],'mass',mass,'stock',n*banks)
+if __name__=='__main__':main()
diff --git a/research/coupled-tail-support-floor/source/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json.gz b/research/coupled-tail-support-floor/source/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json.gz
new file mode 100644
index 0000000000..413b85ecf2
Binary files /dev/null and b/research/coupled-tail-support-floor/source/two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json.gz differ
diff --git a/research/coupled-tail-support-floor/source/two-site-continuation/MANIFEST.json b/research/coupled-tail-support-floor/source/two-site-continuation/MANIFEST.json
new file mode 100644
index 0000000000..0a22cda80f
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/two-site-continuation/MANIFEST.json
@@ -0,0 +1,128 @@
+{
+  "active_processes": [],
+  "file_count": 24,
+  "files": [
+    {
+      "bytes": 2438797,
+      "path": "ADMITTED-TWO-SITE-FUSIONS.json",
+      "sha256": "30d3f569d91304856118796f0c586176d0ad961eff70b09c78fce7532392101f"
+    },
+    {
+      "bytes": 1227,
+      "path": "CONTINUED-ISOLATION-Q2.json",
+      "sha256": "d944c5b3181442af3cfd855b6f7d059f6bdfaed35755eff549ee7e96c66c5da7"
+    },
+    {
+      "bytes": 355,
+      "path": "CONTROLS.json",
+      "sha256": "3a140e16dcf32b6c630a9dc6cc0ba642dc5f9511d6501d57f1ec79f8e2d0b7f0"
+    },
+    {
+      "bytes": 4308,
+      "path": "HANDOFF.md",
+      "sha256": "404e01603b99f3e865ce5f7f3fd0a6bd9ca79db4217c105816b7010cc371dbf0"
+    },
+    {
+      "bytes": 155971,
+      "path": "INPUT-EVENTS.json",
+      "sha256": "412e126144828455ebfa9d7baafb392e6f8cc5ff956876884451c59545765cfa"
+    },
+    {
+      "bytes": 627015,
+      "path": "ISOLATED-FUSION-Q2.json",
+      "sha256": "5ee7878ccd08a1eff40b9bc68e2d0476e501819aea39fda75cbeeadfb9f81d2e"
+    },
+    {
+      "bytes": 1295931,
+      "path": "ISOLATED-FUSION-Q3.json",
+      "sha256": "4997bab27dda2e20d39209f9002af71c1cee42caa1e69b7a8a2f9eb7f4393fd8"
+    },
+    {
+      "bytes": 3228,
+      "path": "ISOLATED-Q3-RANK-INTAKE.json",
+      "sha256": "d89b23f528bd76b3fc3e4ccb14a33ae0ac53223224f07fe39b7f402fbc2b59a2"
+    },
+    {
+      "bytes": 6769,
+      "path": "PROOF.md",
+      "sha256": "2506f7a89239d2375f14a1d7084aaaf11678818d6a20eb81e29de0a66a9f751a"
+    },
+    {
+      "bytes": 40247,
+      "path": "TWO-SITE-COVER-Q2.json",
+      "sha256": "2ff79767203b7a06e72a148f49312ad2416540b85550ef10b802f503ff4505bd"
+    },
+    {
+      "bytes": 621781,
+      "path": "TWO-SITE-Q2.json",
+      "sha256": "e826892b6bf5db4bfae631743a50ef6668f1c22fa4583499f4ae1ddbc937b845"
+    },
+    {
+      "bytes": 6067,
+      "path": "VALIDATION.json",
+      "sha256": "acb87ee0dbacb286850346795c6961a56745e61b6d75dc5be112c4e5cb3576e8"
+    },
+    {
+      "bytes": 11168,
+      "path": "admit_fusions.py",
+      "sha256": "15c921045d86fe581725d284b1f9557b4adcdff204951b2e12d0b237b2065b09"
+    },
+    {
+      "bytes": 6511,
+      "path": "continue_isolated.py",
+      "sha256": "89551fe31fbf92cdc1167c7a0149b345733abac09da14aa7e482adc3842442a0"
+    },
+    {
+      "bytes": 1875,
+      "path": "controls.py",
+      "sha256": "b1b7543c9d8347dadc242dcf4420e62009e0d410063a3553167b8c4d1d6895b2"
+    },
+    {
+      "bytes": 155971,
+      "path": "frozen-two-site-v1/INPUT-EVENTS.json",
+      "sha256": "412e126144828455ebfa9d7baafb392e6f8cc5ff956876884451c59545765cfa"
+    },
+    {
+      "bytes": 71998,
+      "path": "frozen-two-site-v1/ISOLATED-FUSION-Q2.json",
+      "sha256": "ef41f9b005af1580c3f985bee5d3a4b3bdf842d388ddf409f2bbf2a41d72d3a2"
+    },
+    {
+      "bytes": 123502,
+      "path": "frozen-two-site-v1/ISOLATED-FUSION-Q3.json",
+      "sha256": "868b41d5a1360c10bff236dbd4f6a803b2fef93dc9ad25df30617ceac137dab6"
+    },
+    {
+      "bytes": 9723,
+      "path": "frozen-two-site-v1/isolated_fusion.py",
+      "sha256": "f0f3e46e9c581ce0bd9d9e5072c879a3dfdd56a9628a4ab43eff6b93b7f58711"
+    },
+    {
+      "bytes": 3246,
+      "path": "inputs/REPAIRED-MANIFEST.json",
+      "sha256": "dde942457256b0f037a65eebeb5df822fe4d8911c0441657816c77a4c20c6f1c"
+    },
+    {
+      "bytes": 3658155,
+      "path": "inputs/REPAIRED-SIMPLIFIED-FUSIONS.json",
+      "sha256": "4491cfe2a1f3e48510b33403b9b50c704865c3b1dc6d659ef5157840654e8fc3"
+    },
+    {
+      "bytes": 11788,
+      "path": "isolated_fusion.py",
+      "sha256": "eafc4bd6e0cb0e2136dc9da8454d72ebe2da6f194c7bc62815601ba93d56094e"
+    },
+    {
+      "bytes": 9665,
+      "path": "two_site.py",
+      "sha256": "a3d902fd3ad674caf56c532a7a06926395f3b9fa78a74b77f439373603d9e38a"
+    },
+    {
+      "bytes": 5946,
+      "path": "two_site_cover.py",
+      "sha256": "ebbef015b85a8d3ba04141cdb7291a7cb47ee8ebd808ca20659ad5b99fbbb5ed"
+    }
+  ],
+  "no_new_kappa": true,
+  "status": "FROZEN_BOUNDED_TWO_SITE_PACKAGE"
+}
diff --git a/research/coupled-tail-support-floor/source/two-site-independent-audit/audit_two_sites.py b/research/coupled-tail-support-floor/source/two-site-independent-audit/audit_two_sites.py
new file mode 100644
index 0000000000..8a3dcd7bff
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/two-site-independent-audit/audit_two_sites.py
@@ -0,0 +1,263 @@
+#!/usr/bin/env python3
+"""Independent transport/gluing and literal recipe audit, q2/q3, all f.
+Apache-2.0; substantial OpenAI Codex assistance. No source generator import.
+"""
+from pathlib import Path
+from fractions import Fraction
+from collections import Counter
+from functools import lru_cache
+import argparse,hashlib,json,sys,importlib.machinery,py_compile,types
+sys.dont_write_bytecode=True
+HERE=Path(__file__).resolve().parent;ROOT=HERE.parent;SOURCE=ROOT/'two-site-continuation'
+
+# Execute the exact source bytes read and hashed, including explicit legacy
+# SourceFileLoader imports. Ignore bytecode caches and keep legacy assertions
+# active even when this independent parent is run with -O.
+EXECUTED={};original_get_code=importlib.machinery.SourceFileLoader.get_code
+def source_only(self,fullname):
+    path=Path(self.path)
+    if str(path).startswith('/Users/ross/git/math/'):
+        raw=path.read_bytes();EXECUTED[str(path)]=hashlib.sha256(raw).hexdigest()
+        return compile(raw,str(path),'exec',dont_inherit=True,optimize=0)
+    return original_get_code(self,fullname)
+importlib.machinery.SourceFileLoader.get_code=source_only
+sys.path.insert(0,str(ROOT/'fusion-audit'))
+import audit_fusions as old
+ce,b,mul,need=old.ce,old.b,old.mul,old.need
+product,add,scale,from_circuit=old.product,old.sumexpr,old.scale,old.from_circuit
+from literal_inverse_binding import serial
+from lifted_algebra import G
+UNITS=(G(Fraction(1)),G(Fraction(0),Fraction(1)),G(Fraction(-1)),G(Fraction(0),Fraction(-1)))
+
+
+def loader_controls():
+    probe=HERE/'_bytecode_probe.py';cache=Path(importlib.util.cache_from_source(str(probe)))
+    need(not probe.exists()and not cache.exists(),'loader control owns fresh scratch paths')
+    try:
+        probe.write_text('raise RuntimeError("poisoned cached source")\n')
+        py_compile.compile(str(probe),cfile=str(cache),doraise=True,
+                           invalidation_mode=py_compile.PycInvalidationMode.UNCHECKED_HASH)
+        probe.write_text('VALUE="exact source bytes"\ndef check():\n    assert False, "legacy checker remains active"\n')
+        loader=importlib.machinery.SourceFileLoader('audit_bytecode_probe',str(probe))
+        module=types.ModuleType('audit_bytecode_probe');module.__file__=str(probe);loader.exec_module(module)
+        need(module.VALUE=='exact source bytes','poisoned unchecked-hash bytecode ignored')
+        try:module.check()
+        except AssertionError:pass
+        else:raise ValueError('workspace legacy assertions disabled under parent optimization')
+        try:ce.diag(2,(2,0),(0,0))
+        except AssertionError:pass
+        else:raise ValueError('retained exact Clifford source assertion disabled')
+    finally:
+        probe.unlink(missing_ok=True);cache.unlink(missing_ok=True);EXECUTED.pop(str(probe),None)
+        try:cache.parent.rmdir()
+        except OSError:pass
+    return ['unchecked-hash poisoned bytecode bypassed','workspace source assertions active','retained Clifford assertion active']
+
+
+@lru_cache(None)
+def op_of(circuit,n):return old.circuit_op(json.loads(circuit),n)
+def event_op(e,m):
+    op=op_of(json.dumps(e['one_coordinate_literal_circuit']),m)
+    need(op.tab==tuple(tuple(x)for x in e['one_coordinate_tableau']),'literal event tableau')
+    need(b.native_rank(op)==e['rank_per_f'],'literal event native rank')
+    need(len(e['extra_global_phase_exponent_by_f_mod4'])==4,'four exact tensor phase residues')
+    need(not any(k in e for k in('x_monomial','native_family','phase_exponent')),'no stale operator shadows')
+    return op
+def xsafe(op):return all(e[0]!='D'or(not any(e[1])and all(x%2==0 for x in e[2]))for e in op.circuit)
+@lru_cache(None)
+def sparse(circuit,n):return b.sparse_column(op_of(circuit,n))
+def equal_op(a,c):
+    if a.tab!=c.tab:return False
+    if xsafe(a)and xsafe(c):return from_circuit(a,0)==from_circuit(c,0)
+    return sparse(json.dumps(a.circuit),a.n)==sparse(json.dumps(c.circuit),c.n)
+def old_unary(e,m,inverse=False):
+    op=old.event_op(e,m);return from_circuit(op.adjoint()if inverse else op,-e['phase_exponent']if inverse else e['phase_exponent'])
+def identity(n,m):
+    I=from_circuit(ce.ident(m),0);return[[dict(I)if i==j else{}for j in range(n)]for i in range(n)]
+def mm(A,B):return[[sumexpr(product(A[i][k],B[k][j])for k in range(len(A))if A[i][k]and B[k][j])for j in range(len(A))]for i in range(len(A))]
+def sumexpr(items):
+    out={}
+    for x in items:out=add(out,x)
+    return out
+def replay_old(E,n,m,inverse=False):
+    M=identity(n,m)
+    for e in reversed(E)if inverse else E:
+        typ=e['kind']
+        if typ=='ADD':
+            d,s=e['dst'],e['src'];c=Fraction(e['coefficient'])*(-1 if inverse else 1)
+            M[d]=[add(x,scale(y,c))for x,y in zip(M[d],M[s])]
+        elif typ=='SCALE':
+            c=Fraction(e['coefficient']);c=1/c if inverse else c
+            M[e['bank']]=[scale(x,c)for x in M[e['bank']]]
+        elif typ=='BANK_SWAP':i,j=e['banks'];M[i],M[j]=M[j],M[i]
+        else:
+            U=old_unary(e,m,inverse);M[e['bank']]=[product(U,x)for x in M[e['bank']]]
+    return M
+def pullback(C,e,m):
+    C=[[dict(x)for x in row]for row in C];typ=e['kind']
+    if typ=='ADD':
+        d,s=e['dst'],e['src'];c=Fraction(e['coefficient'])
+        C[d]=[add(x,scale(y,-c))for x,y in zip(C[d],C[s])]
+        for row in C:row[s]=add(row[s],scale(row[d],c))
+    elif typ=='BANK_SWAP':
+        i,j=e['banks'];C[i],C[j]=C[j],C[i]
+        for row in C:row[i],row[j]=row[j],row[i]
+    elif typ=='SCALE':
+        j=e['bank'];c=Fraction(e['coefficient']);C[j]=[scale(x,1/c)for x in C[j]]
+        for row in C:row[j]=scale(row[j],c)
+    else:
+        j=e['bank'];U,Ui=old_unary(e,m),old_unary(e,m,True)
+        C[j]=[product(Ui,x)for x in C[j]]
+        for row in C:row[j]=product(row[j],U)
+    return C
+def transported(P,i,j,n,m):
+    I=from_circuit(ce.ident(m),0);bank=P[i]['bank']
+    col=[dict(I)if x==bank else{}for x in range(n)];row=[dict(x)for x in col]
+    for e in P[i+1:j+1]:
+        typ=e['kind']
+        if typ=='ADD':
+            d,s=e['dst'],e['src'];c=Fraction(e['coefficient'])
+            col[d]=add(col[d],scale(col[s],c));row[s]=add(row[s],scale(row[d],-c))
+        elif typ=='BANK_SWAP':a,c=e['banks'];col[a],col[c]=col[c],col[a];row[a],row[c]=row[c],row[a]
+        elif typ=='SCALE':
+            x=e['bank'];c=Fraction(e['coefficient']);col[x]=scale(col[x],c);row[x]=scale(row[x],1/c)
+        else:
+            x=e['bank'];col[x]=product(old_unary(e,m),col[x]);row[x]=product(row[x],old_unary(e,m,True))
+    need(sumexpr(product(x,y)for x,y in zip(row,col))==I,'transported row times column equals I')
+    return col,row
+def to_op(E):
+    need(len(E)==1,'one exact old Clifford ray');(key,v),=E.items();n=len(key[0]);out=ce.ident(n)
+    for i,a in enumerate(key[2]):
+        if a in(1,3):out=out.then(ce.cgate(n,1<<i,1 if a==1 else-1))
+        elif a==2:out=out.then(ce.xgate(n,1<<i))
+    for i,row in enumerate(key[3]):
+        for j in range(i+1,n):
+            if row>>j&1:out=out.then(ce.cgate(n,1<<i)).then(ce.cgate(n,1<<j)).then(ce.cgate(n,(1<<i)|(1<<j),-1))
+    inv=ce.inv(key[0],n);out=out.then(ce.perm(n,ce.transpose(inv,n)))
+    if key[1]:out=out.then(ce.diag(n,[0]*n,[2*((key[1]>>i)&1)for i in range(n)]))
+    units=[UNITS.index(x)for x in v];out=out.then(old.phase(n,units[1]))
+    need(from_circuit(out,0)=={key:tuple(UNITS[(units[1]*r)%4]for r in range(4))},'independent X-character-to-physical circuit direction/phase')
+    return out,[(units[r]-r*units[1])%4 for r in range(4)]
+
+
+def native_check(e,pool,m,cache):
+    op=event_op(e,m)
+    if e['kind']!='NATIVE':need(b.native_rank(op)==0,'first emitted free operator is physical monomial');return
+    key=e['native_recipe_id'];need(key in pool,'native pointer exists');p=pool[key]
+    need(e['extra_global_phase_exponent_by_f_mod4']==p['extra_global_phase_exponent_by_f_mod4'],'native pool phase-vector direction')
+    if key not in cache:
+        n=len(p['one_coordinate_tableau'])//2;actual=op_of(json.dumps(p['one_coordinate_definition_circuit']),n)
+        need(actual.tab==tuple(tuple(x)for x in p['one_coordinate_tableau']),'pool definition tableau')
+        compiled=old.compile_recipe(p['selected_native_recipe'],n)
+        need(equal_op(compiled,actual),'selected recipe actual Gaussian ray')
+        need(b.native_rank(actual)==p['selected_native_recipe']['rank'],'selected recipe rank')
+        cache[key]=actual
+    need(len(e['recipe_embedding'])==cache[key].n,'recipe embedding dimension')
+    embedded=old.circuit_op(old.embedding(cache[key].circuit,e['recipe_embedding'],m),m)
+    need(equal_op(embedded,op),'actual event equals selected recipe embedding including phase')
+    cap=int(((m*m-1)//2)**0.5)
+    need(e['rank_per_f']<=cap and e['rank_per_f']<m,'proper native child cap')
+
+
+def check(q,current,source,science):
+    n,m=current['banks'],current['ambient_arity'];P,T=source['prefix_events'],source['tail_events'];i,j=current['changed_sites']
+    removed=set(science['removed_tail_sites']);newT=[e for at,e in enumerate(T)if at not in removed]
+    C=mm(replay_old(newT,n,m,True),replay_old(T,n,m))
+    for e in reversed(P[j+1:]):C=pullback(C,e,m)
+    A,B=transported(P,i,j,n,m);bank=P[j]['bank'];I=identity(n,m)
+    need(all(not x for r,x in enumerate(A)if r!=bank)and all(not x for r,x in enumerate(B)if r!=bank),'actual two-sided bank isolation')
+    need(all(C[r][c]==I[r][c]for r in range(n)for c in range(n)if(r,c)!=(bank,bank)),'actual tail-deletion correction only one bank')
+    need(product(A[bank],B[bank])==I[0][0],'isolated transport inverse orientation')
+    L=product(C[bank][bank],product(A[bank],old_unary(P[i],m)))
+    R=product(B[bank],old_unary(P[j],m));Lop,lp=to_op(L);Rop,rp=to_op(R)
+    E=current['events'];U,W=event_op(E[i],m),event_op(E[j],m)
+    need(E==current['full_events']==current['prefix_events']+current['tail_events'],
+         'admitted current prefix/tail/full partitions are literal, not inherited shadows')
+    need(len(current['prefix_events'])==len(P),'changed prefix keeps current site indices')
+    up,wp=E[i]['extra_global_phase_exponent_by_f_mod4'],E[j]['extra_global_phase_exponent_by_f_mod4']
+    need(equal_op(mul(Lop,U.adjoint(),Rop),W),'literal W=L U^-1 R exact Gaussian operator')
+    need(wp==[(a-c+d)%4 for a,c,d in zip(lp,up,rp)],'W=L U^-1 R all f-mod4 Gaussian units')
+    gaugeU=[(x+1)%4 for x in up];gaugeW=[(x-1)%4 for x in wp]
+    need(gaugeW==[(a-c+d)%4 for a,c,d in zip(lp,gaugeU,rp)],'equivalent opposite whole-field Gaussian phase gauge accepted')
+    ranks=[b.native_rank(x)for x in(Lop,Rop,U,W)]
+    need(ranks==([4,2,0,2]if q==2 else[8,6,0,2]),'actual Bruhat rank-distance attainment')
+    # No hidden event changes: every unchanged field/operator is bound to
+    # the independently verified repaired source. Tail removal is explicit.
+    oldE=P+newT;need(len(E)==len(oldE),'only named tail queries removed')
+    for at,(a,c)in enumerate(zip(E,oldE)):
+        if at in(i,j):continue
+        need(a['kind']==c['kind'],'unchanged event kind')
+        if a['kind']in('ADD','SCALE','BANK_SWAP'):
+            for key in('bank','banks','dst','src','coefficient'):
+                if key in c:need(a.get(key)==c[key],'unchanged scalar/bank event')
+        else:
+            op=event_op(a,m);need(from_circuit(op,0)==from_circuit(old.event_op(c,m),0),'unchanged physical event phase')
+            need(a['extra_global_phase_exponent_by_f_mod4']==[(c['phase_exponent']*(1-r))%4 for r in range(4)],'unchanged all-f event unit')
+    z,J,F,unused=old.required(q);target=from_circuit(mul(F,J),2*q+2)
+    need(replay_old(P+T,n,m)==[[target if r==c else{}for c in range(n)]for r in range(n)],'independent old source all original output columns')
+    cache={};pool=current['native_recipe_pool'];inv=current['inverse_events'];need(len(inv)==len(E),'serialized inverse covers every event')
+    for e in E+inv:
+        if e['kind']not in('ADD','SCALE','BANK_SWAP'):native_check(e,pool,m,cache)
+    for a,c in zip(reversed(E),inv):
+        need(a['kind']==c['kind'],'literal inverse primitive kind')
+        typ=a['kind']
+        if typ=='ADD':need(a['dst']==c['dst']and a['src']==c['src']and Fraction(c['coefficient'])==-Fraction(a['coefficient']),'inverse ADD')
+        elif typ=='SCALE':need(a['bank']==c['bank']and Fraction(a['coefficient'])*Fraction(c['coefficient'])==1,'inverse SCALE')
+        elif typ=='BANK_SWAP':need(a['banks']==c['banks'],'inverse SWAP')
+        else:
+            need(a['bank']==c['bank']and equal_op(event_op(a,m).adjoint(),event_op(c,m)),'serialized exact literal unary adjoint')
+            need(c['extra_global_phase_exponent_by_f_mod4']==[(-x)%4 for x in a['extra_global_phase_exponent_by_f_mod4']],'inverse all-f unit')
+    used={e['native_recipe_id']for e in E+inv if e['kind']=='NATIVE'};need(used==set(pool)==set(cache),'used-only complete forward/inverse pool')
+    hist=dict(Counter(e['rank_per_f']for e in E if e['kind']=='NATIVE'));mass=sum(k*v for k,v in hist.items())
+    need(hist=={2:n*n,4:1}and mass==n*m+4==current['native_mass'],'actual full native histogram')
+    need(hist=={int(k):v for k,v in current['histogram'].items()}and current['stock']==n*m
+         and current['D']==n*m-mass,'admitted inventory metadata matches current literal events')
+    need(current['changed_native_ranks']==[0,2]and current['all_original_columns']==n
+         and current['used_only_native_definitions']==len(pool),'admitted domain/recipe counters')
+    need(current['every_serialized_unary_checked']==sum(e['kind']not in('ADD','SCALE','BANK_SWAP')for e in E+inv),
+         'serialized forward/inverse unary counter')
+    negative=[]
+    bad=dict(next(e for e in inv if e['kind']=='NATIVE'));k=bad['native_recipe_id'];bad['native_recipe_id']=k[:-3]if k.endswith('inv')else k+'inv'
+    try:native_check(bad,pool,m,{})
+    except ValueError as error:
+        need(str(error)in('native pool phase-vector direction','actual event equals selected recipe embedding including phase'),
+             'wrong-direction pointer fails its intended phase/operator check')
+        negative.append('opposite-direction inverse native pointer')
+    else:raise ValueError('wrong native pointer unexpectedly accepted')
+    changed=list(wp);changed[2]=(changed[2]+2)%4
+    need(changed[1]==wp[1]and changed!=[(a-c+d)%4 for a,c,d in zip(lp,up,rp)],'f2-only scalar mutation changes required local operator family')
+    negative.append('f2-only phase mutant with f1 unchanged')
+    need(not equal_op(mul(Lop,Rop),W),'omitting first physical monomial cannot satisfy unique local correction')
+    negative.append('omitted first free monomial rejects arbitrary-input correction')
+    return {'q':q,'all_original_columns':n,'all_positive_f':'exact source transport, general Clifford local identity and four scalar residues',
+            'complete_endpoint':'diag(F_k J)','both_literal_inverse_orders':'PASS_by_complete_primitive_inverse_and_forward_gluing',
+            'L_R_U_W_ranks_per_f':ranks,'histogram':hist,'native_mass':mass,'stock':n*m,
+            'source_transport_row_and_column':'isolated','all_used_forward_inverse_recipes':len(pool),'native_event_links':sum(e['kind']=='NATIVE'for e in E+inv),
+            'negative_controls':negative,'phase_vectors':{'L':lp,'R':rp,'U':up,'W':wp},
+            'equivalent_positive_control':'opposite whole-field i/-i gauges on U/W preserve the exact local identity',
+            'proof_method':'Independent old X-character bank matrix transport and source all-column replay; emitted general Clifford U/W and selected recipes checked in physical coordinates, no author generator or general tensor algebra imported.'}
+
+
+def run():
+    pins=json.loads((HERE/'SOURCE-PINS.json').read_text())['source_pins']
+    for x in pins:need(hashlib.sha256(Path(x['path']).read_bytes()).hexdigest()==x['sha256'],'source pin '+x['path'])
+    need(hashlib.sha256((SOURCE/'MANIFEST.json').read_bytes()).hexdigest()=='44f1e264b3087ab8fdb08b4cd6e27befefbba380852b0119321724b7bc41b5da','frozen assigned manifest')
+    for x in json.loads((SOURCE/'MANIFEST.json').read_text())['files']:need(hashlib.sha256((SOURCE/x['path']).read_bytes()).hexdigest()==x['sha256'],'manifest file '+x['path'])
+    raw=json.loads((SOURCE/'ADMITTED-TWO-SITE-FUSIONS.json').read_text());sources=json.loads((SOURCE/'inputs/REPAIRED-SIMPLIFIED-FUSIONS.json').read_text())
+    cases=[]
+    for f in raw['fixtures']:
+        q=f['q'];s=next(x for x in sources['fixtures']if x['q']==q);science=json.loads((SOURCE/f'ISOLATED-FUSION-Q{q}.json').read_text())
+        cases.append(check(q,f,s,science))
+    controls=loader_controls()
+    return {'status':'PASS_INDEPENDENT_TWO_SITE_TRANSPORT_LITERAL_PHASE_AND_NATIVE_ADMISSION','scientific_pin':old.PIN,
+            'producer_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),'source_pins':pins,'cases':cases,
+            'exact_source_execution':EXECUTED,'source_loader':'Workspace Python modules executed from the exact bytes hashed in memory, ignoring bytecode caches; historical workspace assertions explicitly active under parent -O.',
+            'source_loader_controls':controls,
+            'no_all_q_construction':True,'no_new_kappa':True}
+
+
+if __name__=='__main__':
+    p=argparse.ArgumentParser();p.add_argument('--write',action='store_true');a=p.parse_args();out=json.loads(json.dumps(run()));file=HERE/'AUDIT.json'
+    if a.write:file.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n')
+    else:need(json.loads(file.read_text())==out,'saved independent two-site audit differs')
+    print(out['status'])
diff --git a/research/coupled-tail-support-floor/source/vendor/clifford_exact.py b/research/coupled-tail-support-floor/source/vendor/clifford_exact.py
new file mode 100644
index 0000000000..166841a037
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/vendor/clifford_exact.py
@@ -0,0 +1,149 @@
+"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals.
+Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d.
+The tableau is supplemented by a literal circuit, so global phases are kept.
+"""
+from dataclasses import dataclass
+
+def parity(x):return x.bit_count()&1
+def rank(rows):
+ p={}
+ for x in rows:
+  while x:
+   b=x.bit_length()-1
+   if b not in p:p[b]=x;break
+   x^=p[b]
+ return len(p)
+def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<<j for j in range(n)) for i in range(n))
+def mv(rows,x):return sum(parity(r&x)<<i for i,r in enumerate(rows))
+def inv(rows,n):
+ a=[r|(1<<(n+i)) for i,r in enumerate(rows)]
+ for j in range(n):
+  k=next(i for i in range(j,n) if a[i]>>j&1);a[j],a[k]=a[k],a[j]
+  for i in range(n):
+   if i!=j and a[i]>>j&1:a[i]^=a[j]
+ assert [r&((1<<n)-1) for r in a]==[1<<i for i in range(n)]
+ return tuple(r>>n for r in a)
+def basis_extend(cols,n):
+ out=[]
+ for x in list(cols)+[1<<i for i in range(n)]:
+  if rank(out+[x])>len(out):out.append(x)
+ assert len(out)==n
+ return tuple(out)
+def nullspace(rows,n):
+ a=list(rows);p=[];k=0
+ for j in range(n):
+  t=next((i for i in range(k,len(a)) if a[i]>>j&1),None)
+  if t is None:continue
+  a[t],a[k]=a[k],a[t]
+  for i in range(len(a)):
+   if i!=k and a[i]>>j&1:a[i]^=a[k]
+  p.append(j);k+=1
+ return tuple((1<<j)|sum(((a[i]>>j)&1)<<v for i,v in enumerate(p)) for j in range(n) if j not in p)
+def pmul(a,b):
+ x,z,p=a;y,w,q=b
+ return x^y,z^w,(p+q+2*parity(z&y))%4
+def identity(n):return tuple([(1<<i,0,0) for i in range(n)]+[(0,1<<i,0) for i in range(n)])
+def apply(T,p):
+ n=len(T)//2;x,z,ph=p;out=(0,0,ph)
+ for i in range(n):
+  if x>>i&1:out=pmul(out,T[i])
+ for i in range(n):
+  if z>>i&1:out=pmul(out,T[n+i])
+ return out
+def compose(A,B):return tuple(apply(A,p) for p in B)
+def inverse(T):
+ n=len(T)//2;cols=[x|(z<<n) for x,z,p in T];rows=transpose(cols,2*n);cols_inv=transpose(inv(rows,2*n),2*n);out=[]
+ for j,w in enumerate(cols_inv):
+  x=w&((1<<n)-1);z=w>>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4))
+ return tuple(out)
+def qvalue(Q,alpha,x,n):
+ return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4
+def mul_i(a,p):
+ x,y=a;p%=4
+ return [(x,y),(-y,x),(-x,-y),(y,-x)][p]
+@dataclass
+class Op:
+ n:int
+ tab:tuple
+ circuit:list
+ def then(self,b):
+  assert self.n==b.n
+  return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit)
+ def adjoint(self):
+  circ=[]
+  for e in reversed(self.circuit):
+   if e[0]=='P':circ.append(('P',inv(e[1],self.n)))
+   elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2])))
+   elif e[0]=='C':circ.append(('C',e[1],-e[2]))
+   elif e[0]=='phase':circ.append(('phase',(-e[1])%4))
+   else:circ.append(e)
+  return Op(self.n,inverse(self.tab),circ)
+ def zero_state(self,basis=0):
+  N=1<<self.n;vec=[(0,0)]*N;vec[basis]=(1,0);den=0
+  for e in self.circuit:
+   if e[0]=='P':
+    v=[(0,0)]*N
+    for x,a in enumerate(vec):v[mv(e[1],x)]=a
+    vec=v
+   elif e[0]=='X':vec=[vec[x^e[1]] for x in range(N)]
+   elif e[0]=='D':vec=[mul_i(a,qvalue(e[1],e[2],x,self.n)) for x,a in enumerate(vec)]
+   elif e[0]=='phase':vec=[mul_i(a,e[1]) for a in vec]
+   elif e[0]=='C':
+    q,sgn=e[1:];v=[]
+    for x,(a,b) in enumerate(vec):
+     c,d=vec[x^q]
+     # C=(1+i)I/2+(1-i)X/2; inverse conjugates both coefficients.
+     v.append((a-sgn*b+c+sgn*d,b+sgn*a+d-sgn*c))
+    vec=v;den+=1
+   else:raise AssertionError(e)
+   while den and all((a&1)==(b&1)==0 for a,b in vec):vec=[(a//2,b//2) for a,b in vec];den-=1
+  return vec,den
+def ident(n):return Op(n,identity(n),[])
+def perm(n,G):
+ cols=transpose(G,n);gi=inv(G,n)
+ return Op(n,tuple([(a,0,0) for a in cols]+[(0,a,0) for a in gi]),[('P',tuple(G))])
+def diag(n,Q,alpha=None):
+ Q=tuple(Q);assert transpose(Q,n)==Q
+ alpha=tuple(alpha) if alpha is not None else tuple((Q[i]>>i)&1 for i in range(n))
+ assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n))
+ return Op(n,tuple([(1<<i,Q[i],alpha[i]) for i in range(n)]+[(0,1<<i,0) for i in range(n)]),[('D',Q,alpha)])
+def cgate(n,q,sgn=1):
+ return Op(n,tuple([(1<<i,0,0) for i in range(n)]+[(q if q>>i&1 else 0,1<<i,(3*sgn)%4 if q>>i&1 else 0) for i in range(n)]),[('C',q,sgn)])
+def xgate(n,b):return Op(n,tuple([(1<<i,0,0) for i in range(n)]+[(0,1<<i,2*((b>>i)&1)) for i in range(n)]),[('X',b)])
+def fourier(n,axes=None):
+ out=ident(n)
+ for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<<i))
+ return out
+def hadamard(n,axes):
+ axes=list(axes);Q=tuple(1<<i if i in axes else 0 for i in range(n));S=diag(n,Q)
+ return S.then(fourier(n,axes)).then(S)
+def canonical_frame(n,U):
+ r=len(U)
+ if r==0:return ident(n)
+ if r==n:return fourier(n)
+ G=transpose(basis_extend(U,n),n);gi=inv(G,n);Q=tuple((1<<i)^sum(parity(gi_i&gi_j)<<j for j,gi_j in enumerate(transpose(gi,n))) for i,gi_i in enumerate(transpose(gi,n)))
+ K=perm(n,G).then(diag(n,Q))
+ return K.adjoint().then(fourier(n,range(r))).then(K)
+def monomial(op):
+ n=op.n;T=op.tab;assert all(x==0 and p%2==0 for x,z,p in T[n:]);G=transpose([x for x,z,p in T[:n]],n);b=mv(G,sum((p//2)<<i for i,(x,z,p) in enumerate(T[n:])))
+ gt=transpose(G,n);cols=[mv(gt,z) for x,z,p in T[:n]];Q=transpose(cols,n);alpha=[(p-2*parity(b&z))%4 for x,z,p in T[:n]]
+ out=diag(n,Q,alpha).then(perm(n,G)).then(xgate(n,b));assert out.tab==T
+ vec,den=op.zero_state();assert den==0 and all(a==(0,0) for i,a in enumerate(vec) if i!=b);phase=[(1,0),(0,1),(-1,0),(0,-1)].index(vec[b]);out=out.then(Op(n,identity(n),[('phase',phase)]));assert out.zero_state()==op.zero_state()
+ return out,dict(matrix_rows=G,offset=b,quadratic_rows=Q,linear_Z4=alpha,phase=phase)
+def lower_child(op):
+ n=op.n;Bcols=[x for x,z,p in op.tab[n:]];r=rank(Bcols)
+ if not r:
+  mon,rec=monomial(op);return dict(rank=0,left=rec,right=None),mon
+ G=transpose(basis_extend(Bcols,n),n);A=inv(G,n);PA=perm(n,A);part=op.then(PA);Bcols=[x for x,z,p in part.tab[n:]];Dcols=[z for x,z,p in part.tab[n:]]
+ picks=[];selected=[]
+ for j,x in enumerate(Bcols):
+  if rank(selected+[x])>len(selected):picks.append(j);selected.append(x)
+ assert len(picks)==r and all(x>>r==0 for x in Bcols)
+ Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<<r)-1) for j in picks],r)
+ Qsmall=tuple(sum(parity(row&col)<<j for j,col in enumerate(transpose(Bi,r))) for row in Dr);Q=Qsmall+(0,)*(n-r);DQ=diag(n,Q)
+ V=part.then(DQ).then(hadamard(n,range(r)));assert all(x==0 for x,z,p in V.tab[n:]);Vmon,Vrec=monomial(V)
+ S=diag(n,tuple(1<<i if i<r else 0 for i in range(n)))
+ left=S.adjoint().then(DQ.adjoint()).then(PA.adjoint());right=Vmon.then(S.adjoint()).then(xgate(n,(1<<r)-1))
+ lmon,lrec=monomial(left);rmon,rrec=monomial(right);compiled=rmon.then(fourier(n,range(r))).then(lmon)
+ assert compiled.tab==op.tab and compiled.zero_state()==op.zero_state()
+ return dict(rank=r,left=lrec,right=rrec),compiled
diff --git a/research/coupled-tail-support-floor/source/vendor/credits/NOTICE.md b/research/coupled-tail-support-floor/source/vendor/credits/NOTICE.md
new file mode 100644
index 0000000000..8d3c3349e1
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/vendor/credits/NOTICE.md
@@ -0,0 +1,7 @@
+# Attribution
+
+Prepared for Rohan Arun (rohanarun) with OpenAI Codex assistance. Apache-2.0.
+
+This composition combines chafreaky's PR533 92-pivot construction and owner map with the delivery-frame assignment from rohanarun's PR534, prepared with Claude Opus 5.5 assistance. PR534's search and monotone-lift checker are retained unchanged. Its frozen B frames are reused, not claimed as a new search discovery. The scalar word and physical allocation are PR533's. The integration, reconstruction binding and independent replay are this contribution.
+
+PR531's direct-delivery construction belongs to icekylinx; its entire vendored package and notices remain unchanged. All predecessor credits, including DreamingOfClouds, Dugongue, eumemic and the geometry/compiler authors, remain in PR533-NOTICE.md and vendor/pr531/NOTICE.md. See SOURCES.json for exact commits.
diff --git a/research/coupled-tail-support-floor/source/vendor/credits/PR533-NOTICE.md b/research/coupled-tail-support-floor/source/vendor/credits/PR533-NOTICE.md
new file mode 100644
index 0000000000..6e6d0042d1
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/vendor/credits/PR533-NOTICE.md
@@ -0,0 +1,33 @@
+# Attribution
+
+This increment was prepared for chafreaky with OpenAI Codex assistance.
+Its new contribution is the frozen 92-pivot shared-donor selection for PR531's
+504-helper word, a new literal whole-owner allocation, and the fixed verifier
+which reconstructs all local phases and checks every selected correction.
+The discovery search and pattern-flow nomination produced finite inputs;
+the verifier does not trust floating objectives or solver optimality.
+
+PR531 (icekylinx, with GPT-6 Astra and OpenAI Codex assistance) contributes the
+direct-delivery factory, same-partition source frontier, 504-helper inventory,
+72-gauge baseline, frame coalescing, 112-port controller binding, and supplier,
+owner and invoice checkers. Its complete package and notices are retained
+byte-for-byte under `vendor/pr531`, pinned at
+`e07a8a3f9f79c22113398a0c5dbbc7601f489b3e`.
+
+The shared-donor and entrance-gauge implementation is DreamingOfClouds's
+credited PR417/433/435/434/440/484 lineage, with Claude Opus 5.5 assistance.
+It is reused without changes. PR514 (Dugongue) and PR507 (eumemic) supply the
+Hamming packet and partial-own ancestry. PR505 (Dugongue) supplies the
+asynchronous scheduling lineage. PR523 (icekylinx) supplies the 112-port
+controller and restriction ancestry. PR493 (eumemic) supplies the unchanged
+bit operator. PR425/433 (icekylinx), PR370, PR361, PR315 and their credited
+contributors supply the geometry, phase, moment and analytic framework.
+All source-specific assistance and license notices are retained.
+
+The full local-phase driver is copied unchanged from PR529's attributed
+PR523 reference. PR529's independent kernel scalar checker is adapted only
+to read the actual port count instead of the literal 120-port dimension.
+PR529 is also the prior frontier comparison; its rank-sector construction
+is not imported as an additive improvement to PR531.
+
+See `SOURCES.json` for immutable pins and file hashes. Apache-2.0.
diff --git a/research/coupled-tail-support-floor/source/vendor/credits/vendor/pr531/NOTICE.md b/research/coupled-tail-support-floor/source/vendor/credits/vendor/pr531/NOTICE.md
new file mode 100644
index 0000000000..f7a8f861be
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/vendor/credits/vendor/pr531/NOTICE.md
@@ -0,0 +1,24 @@
+# Attribution and derivative scope
+
+Prepared for icekylinx with OpenAI GPT-6 Astra assistance; Apache-2.0.
+Copyright 2026 icekylinx. Local review and submission packaging used OpenAI Codex.
+The new work is the same-partition 504-helper scalar architecture, its frozen
+entrance selection, delivery-frame coalescing, literal global allocation,
+targeted certificate reuse and complete new finite recount.
+
+The included Hamming inputs, Gaussian-dyadic Clifford compiler, primitive
+scalar routines, rational moment engines and outer assembly descend from the
+authors recorded in `SOURCES.json` and `inputs/PR523-ANCESTRY.json`. Original
+source notices are retained. In particular, DreamingOfClouds' gauge/kernel
+and paid-wrapper files retain their notice crediting Claude Opus 5.5 assistance;
+those files are not presented as newly authored work.
+
+Dugongue's PR522 rank-sector coordinate-total principle was inspected and is
+credited as a related idea. This increment does not import its ranksector99
+patch or add its reported gain arithmetically. Higherbeing's PR520 face-packet
+geometry helped direct the structural investigation; its code is not copied.
+The latest numerical comparison, Rohan Arun's PR527, is a comparison source.
+
+The reproduction wrapper deliberately separates fresh changed-word/global
+checks from reuse of the byte-pinned completed baseline and unchanged bit
+operator. Old finite receipts never stand in for the changed local word.
diff --git a/research/coupled-tail-support-floor/source/vendor/credits/vendor/pr531/SOURCES.json b/research/coupled-tail-support-floor/source/vendor/credits/vendor/pr531/SOURCES.json
new file mode 100644
index 0000000000..78244052aa
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/vendor/credits/vendor/pr531/SOURCES.json
@@ -0,0 +1,63 @@
+{
+  "repository": "https://github.com/CrocSwap/integer-mult-bounds",
+  "prepared_for": "icekylinx",
+  "assistance": "OpenAI GPT-6 Astra",
+  "license": "Apache-2.0",
+  "baseline": {
+    "pr": 523,
+    "author": "icekylinx",
+    "head": "a900f98be8ff2c09d3292b5112d4731dbd0c8438",
+    "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/523",
+    "role": "112 ordered ports, fixed data controller, completed phase cache and finite baseline allowances."
+  },
+  "retained": [
+    {
+      "pr": 514,
+      "author": "Dugongue",
+      "head": "246bfacd4cb4072836ae3147099f548bb728229f",
+      "role": "Pinned Hamming modules and scalar constructor ancestry; derived from PR507 and PR425/433."
+    },
+    {
+      "pr": 493,
+      "author": "eumemic",
+      "head": "c3a9a436b84fe44fdc223a5784d84736d1c2d3c7",
+      "role": "Unchanged bit supplier; published histogram repriced, operator not reconstructed."
+    },
+    {
+      "pr": 484,
+      "author": "DreamingOfClouds",
+      "head": "035845ce95f31d0a2dcfb42b8c8e13411271fa5f",
+      "role": "Attributed shared-donor kernel, entrance-gauge, paid-wrapper and hosting lineage; original Claude Opus assistance notices retained."
+    }
+  ],
+  "related_ideas": [
+    {
+      "pr": 522,
+      "author": "Dugongue",
+      "head": "e9f8075b5212e9bddf361097dbb022dcd052e0bb",
+      "role": "Rank-sector coordinate-total principle inspected and credited. Its ranksector99 patch is not imported; this word completes eight independent retired carriers before the center cut."
+    },
+    {
+      "pr": 520,
+      "author": "higherbeing",
+      "head": "6077fa76950facbce11ec2f04dfbc93493114a44",
+      "role": "Face-packet delivery geometry and open allocation framing informed the bottleneck investigation; no PR520 implementation is copied."
+    }
+  ],
+  "comparison": {
+    "pr": 527,
+    "author": "rohanarun",
+    "head": "2080903b9e6bd01e3f64cc4c7c62ea1b3af0aa6a",
+    "kappa": "0.001467289440740487",
+    "role": "Latest comparable numerical PR in the recorded snapshot; comparison only."
+  },
+  "new_contribution": "Same-partition direct output loading and two-half face delivery with 504 helpers; 72 compatible gauges and 80 exact kernel pivots; body frame coalescing; literal pure-pattern whole-owner allocation; fresh finite global invoice and exact kappa.",
+  "ancestry_file": "inputs/PR523-ANCESTRY.json",
+  "comparison_at_submission": {
+    "pr": 529,
+    "author": "chafreaky",
+    "head": "05fc7e332651a41860add3c217cd6f6e88758003",
+    "kappa": "0.001469603966017302",
+    "role": "Comparison only; no code or proof imported."
+  }
+}
diff --git a/research/coupled-tail-support-floor/source/vendor/credits/vendor/pr531/inputs/PR523-ANCESTRY.json b/research/coupled-tail-support-floor/source/vendor/credits/vendor/pr531/inputs/PR523-ANCESTRY.json
new file mode 100644
index 0000000000..385a202fbc
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/vendor/credits/vendor/pr531/inputs/PR523-ANCESTRY.json
@@ -0,0 +1,118 @@
+{
+  "prepared_at_utc": "2026-10-12T00:00:25Z",
+  "repository": "https://github.com/CrocSwap/integer-mult-bounds",
+  "new_contribution": "Exact 112-port direct-sum restriction, new complete physical whole-owner allocation, independent raw geometric/chronological audit and exact global assembly.",
+  "baseline": {
+    "pr": 514,
+    "author": "Dugongue",
+    "head_repository": "Dugongue/integer-mult-bounds",
+    "head": "246bfacd4cb4072836ae3147099f548bb728229f",
+    "source_path": "research/partial-kernel92-async",
+    "local_path": "vendor/pr514",
+    "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/514",
+    "kappa": "1391523459591829/1000000000000000000",
+    "manifest_sha256": "4e6ffc149df6515f330d984e99b86e7d1deef01ed2bbac24bba3f19708f36c02"
+  },
+  "pinned_bit_supplier": {
+    "pr": 493,
+    "author": "eumemic",
+    "head": "c3a9a436b84fe44fdc223a5784d84736d1c2d3c7",
+    "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/493",
+    "scope": "Published profile repriced; unchanged operator cited, not freshly rebuilt."
+  },
+  "comparison_only": [
+    {
+      "pr": 518,
+      "author": "Dugongue",
+      "head": "e0a071dce251eeca96d446f73147048cfebbd5c7",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/518",
+      "kappa": "1393662920776407/1000000000000000000",
+      "created_at": "2026-10-11T23:50:50Z",
+      "role": "Newer comparable numerical report observed during packaging; no added pair choices, 99-pivot word, or owner transport copied."
+    },
+    {
+      "pr": 519,
+      "head": "ffd3c48a80ba8b579dc300e785e387fe8acddfef",
+      "role": "Automatic-width binary counting formalization; public context only."
+    },
+    {
+      "pr": 517,
+      "head": "65518fcff5a7bd490365273ae5469a82aac14853",
+      "kappa": "0.001389125582984265",
+      "role": "Smaller asynchronous result and fixed-word packing ceiling; no code adopted."
+    },
+    {
+      "pr": 516,
+      "head": "1c6b6ff9366a94e1f86a6c5d661a7df75c6ff814",
+      "role": "Lemma A Lean realization, updated during work; formal context only, not recompiled or used as a newly discharged interface.",
+      "first_observed_head": "871b1c51e53918c5e6c945dfe8ef45546c17da56"
+    },
+    {
+      "pr": 510,
+      "head": "64edee18af02aab0c1696b677a0287dd0146381b",
+      "role": "Larger nonbinding bit rate; not adopted."
+    },
+    {
+      "pr": 520,
+      "head": "6077fa76950facbce11ec2f04dfbc93493114a44",
+      "author": "higherbeing",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/520",
+      "role": "Open asynchronous allocator and delivery map. Viewed only during the final comparison refresh; no code or claimed gain adopted. No larger global kappa stated."
+    }
+  ],
+  "retained_ancestry": [
+    {
+      "pr": 496,
+      "head": "00cf70efd6a8637531deafef698157ca83e249ee",
+      "role": "whole-owner parent, invoice and assembly ancestry"
+    },
+    {
+      "pr": 484,
+      "head": "035845ce95f31d0a2dcfb42b8c8e13411271fa5f",
+      "role": "PR496 pinned gauge80-kernel42 parent, not newer moving head"
+    },
+    {
+      "pr": 493,
+      "head": "c3a9a436b84fe44fdc223a5784d84736d1c2d3c7",
+      "role": "unchanged cited R489 bit supplier"
+    },
+    {
+      "pr": 502,
+      "head": "4d30b8322184598e65e90a92389e17e1baedd9eb",
+      "role": "retiming transfer constructor and PR495 schedule fixture"
+    },
+    {
+      "pr": 501,
+      "head": "1dc056496fdbbc74073ed26d948a2dc235dbf356",
+      "role": "parallel retiming integration; credited, no duplicated gain"
+    },
+    {
+      "pr": 473,
+      "head": "628b454d3df00367d2d4f78de7d4eb9cbcbd47ca",
+      "role": "single-helper gauge withdrawal inspiration"
+    },
+    {
+      "pr": 507,
+      "head": "8d4444cf8a16d500cbb94add6e4fa8bcfb9c7d5e",
+      "role": "partial-own factory, 84-pivot reference and retiming map"
+    },
+    {
+      "pr": 505,
+      "head": "4ee769c8e28837482272b5f4742497da8e2fc9d4",
+      "role": "Complete-invocation asynchronous scheduling",
+      "author": "Dugongue"
+    },
+    {
+      "pr": 506,
+      "head": "a4948baee6c7ea35323db74ff636620c6af2925a",
+      "role": "public asynchronous retiming comparison and portability feedback"
+    }
+  ],
+  "original_additional_credits_file": "vendor/pr514/NOTICE.md",
+  "excluded_interfaces": {
+    "494": "Disputed residual splitting is not used.",
+    "499": "Larger claimed number using the disputed split-residual interface is not a proof ingredient."
+  },
+  "last_public_comparison_utc": "2026-10-12T00:09:14Z",
+  "public_snapshot": "evidence/PUBLIC-SNAPSHOT.json"
+}
diff --git a/research/coupled-tail-support-floor/source/vendor/full_stabilizer_bound.py b/research/coupled-tail-support-floor/source/vendor/full_stabilizer_bound.py
new file mode 100644
index 0000000000..e4a31f2a9e
--- /dev/null
+++ b/research/coupled-tail-support-floor/source/vendor/full_stabilizer_bound.py
@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""Exact full-insertion obstruction for the canonical common-cut relay.
+
+Apache-2.0. Written with substantial OpenAI Codex assistance.
+Frozen predecessor code/data are read only. No randomized search is used.
+"""
+import argparse
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+import sys
+
+sys.dont_write_bytecode = True
+HERE = Path(__file__).resolve().parent
+OLD = Path('/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/shared-helper-algebra')
+PIN = '20ecf2891d80b5acf18d980b2164fb44ea7faa90'
+PINS = {
+    'SOURCE-COMMON-FRAME-INVERSE-SEARCH.json': 'bc45cf6f3ab114c565fd330d01174092bf4a32d94d3e3e2c49f80ccaa602bb99',
+    'SOURCE-D4-BUS-INPUT.json': '93716ba2a0297c4b468ca7344a9b744fcdaee4013f490443a58ddc7a6610eedd',
+    'canonical_endpoints.py': '0bbd62dd84f7f7172a57b04abcccd62831042cc417c491970ede42d257cb41a6',
+    'noncommon_b1.py': '4badaf9158a945da34dd4497508d36483da52a87968b24d0553ef18d858e8c49',
+    'NONCOMMON-B1.json': '7e59465f98810f3daa73a14a15d434ddced3a09ce3fb931eeb81f34721e25cff',
+}
+
+
+def need(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+# Independent binary implementation. Matrices are columns packed as integers.
+def binary_image(columns, vector):
+    value = 0
+    while vector:
+        bit = vector & -vector
+        value ^= columns[bit.bit_length() - 1]
+        vector ^= bit
+    return value
+
+
+def binary_product(left, right):
+    return tuple(binary_image(left, column) for column in right)
+
+
+def binary_rank(vectors):
+    pivots = {}
+    for vector in vectors:
+        while vector:
+            pivot = vector.bit_length() - 1
+            if pivot not in pivots:
+                pivots[pivot] = vector
+                break
+            vector ^= pivots[pivot]
+    return len(pivots)
+
+
+def binary_tableau(operator):
+    return tuple(x | (z << operator.n) for x, z, _ in operator.tab)
+
+
+def native_rank(operator):
+    n = operator.n
+    return binary_rank(v & ((1 << n) - 1) for v in binary_tableau(operator)[n:])
+
+
+def address(rows, value):
+    return sum(((row & value).bit_count() % 2) << index for index, row in enumerate(rows))
+
+
+# Independent Gaussian-dyadic sparse state evaluator, retaining global phase.
+def gaussian_unit(value, phase):
+    real, imag = value
+    return ((real, imag), (-imag, real), (-real, -imag), (imag, -real))[phase % 4]
+
+
+def sparse_column(operator, basis=0):
+    state, denominator = {basis: (1, 0)}, 0
+    for event in operator.circuit:
+        kind = event[0]
+        if kind == 'P':
+            state = {address(event[1], x): value for x, value in state.items()}
+        elif kind == 'X':
+            state = {x ^ event[1]: value for x, value in state.items()}
+        elif kind == 'phase':
+            state = {x: gaussian_unit(value, event[1]) for x, value in state.items()}
+        elif kind == 'D':
+            rows, alpha = event[1:]
+            result = {}
+            for x, value in state.items():
+                phase = sum(alpha[i] for i in range(operator.n) if x >> i & 1)
+                for i in range(operator.n):
+                    if x >> i & 1:
+                        phase += 2 * ((rows[i] >> (i + 1)) & (x >> (i + 1))).bit_count()
+                result[x] = gaussian_unit(value, phase)
+            state = result
+        elif kind == 'C':
+            direction, sign = event[1:]
+            result = {}
+            for x, (a, b) in state.items():
+                for y, value in ((x, (a-sign*b, b+sign*a)),
+                                 (x ^ direction, (a+sign*b, b-sign*a))):
+                    u, v = result.get(y, (0, 0))
+                    result[y] = u + value[0], v + value[1]
+            state = {x: value for x, value in result.items() if value != (0, 0)}
+            denominator += 1
+        else:
+            raise ValueError(event)
+        while denominator and all(not ((a | b) & 1) for a, b in state.values()):
+            state = {x: (a // 2, b // 2) for x, (a, b) in state.items()}
+            denominator -= 1
+    return state, denominator
+
+
+def standard_product(ce, *operators):
+    """Return operators[0] ... operators[-1] in conventional product order."""
+    result = ce.ident(operators[0].n)
+    for operator in reversed(operators):
+        result = result.then(operator)
+    return result
+
+
+def canonical_predecessor():
+    for name, expected in PINS.items():
+        need(hashlib.sha256((OLD / name).read_bytes()).hexdigest() == expected, 'frozen source pin: ' + name)
+    spec = importlib.util.spec_from_file_location('stabilizer_frozen_endpoint', OLD / 'canonical_endpoints.py')
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    need(hashlib.sha256(module.CP.read_bytes()).hexdigest() == '2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962', 'native compiler pin')
+    return module
+
+
+def deliberate_monomial(ce, n, cut, variant):
+    """Dense pair stabilizer: nonorthogonal GL2, fresh GL, and cross chirps.
+
+    This is one prescribed construction, not a seed or search. The common
+    address matrix is A=[[0,1],[1,1]], and Q_CC=I+A^-T A^-1=[[1,1],[1,0]].
+    """
+    rows = [1 << i for i in range(n)]
+    rows[:2] = [2, 3]
+    fresh = list(range(2, n))
+    # Swap completed and future directions, then mix every fresh direction.
+    past = 2 + 5 * (cut + 1) - 1
+    future = 2 + 5 * (cut + 1)
+    if future < n:
+        rows[past], rows[future] = rows[future], rows[past]
+    for index in range(len(fresh) - 1):
+        a, b = fresh[index], fresh[index + 1]
+        rows[a] ^= rows[b]
+    rows[0] ^= sum(1 << i for i in fresh if (i + variant) % 2 == 0)
+    rows[1] ^= sum(1 << i for i in fresh if (i + variant) % 3 == 0)
+    quadratic = [3, 1] + [0] * (n - 2)
+    for i in fresh:
+        j = (i + variant) % 2
+        quadratic[i] ^= 1 << j
+        quadratic[j] ^= 1 << i
+        if (i + variant) % 3 == 1:
+            quadratic[i] ^= 1 << i
+    for a, b in zip(fresh[::2], fresh[1::2]):
+        quadratic[a] ^= 1 << b
+        quadratic[b] ^= 1 << a
+    operator = ce.perm(n, rows).then(ce.diag(n, quadratic)).then(ce.xgate(n, (1 << (2 + variant % (n - 2))) | 1))
+    common = ce.cgate(n, 1).adjoint().then(ce.cgate(n, 2))
+    other = standard_product(ce, common, operator, common.adjoint())
+    need(native_rank(operator) == native_rank(other) == 0, 'prescribed full pair stabilizer admission')
+    # Sparse complete-column phase witness for the actual rank-zero conjugate.
+    state, den = sparse_column(other)
+    need(den == 0 and len(state) == 1 and next(iter(state.values())) in ((1, 0), (0, 1), (-1, 0), (0, -1)), 'actual second-cut monomial phase')
+    return operator, {'address_rows': rows, 'quadratic_rows': quadratic, 'second_front_zero_column': [list(state.items()), den]}
+
+
+def verify_free_word():
+    """Independent group-ring replay of the frozen arbitrary-input B1 word."""
+    data = json.loads((OLD / 'NONCOMMON-B1.json').read_text())
+
+    def reduce(word):
+        result = []
+        for symbol in word:
+            if result and result[-1] == -symbol:
+                result.pop()
+            else:
+                result.append(symbol)
+        return tuple(result)
+
+    rows = [{((), 0): 1}, {((), 1): 1}]
+    for gate in data['word']:
+        if gate['op'] == 'LEFT':
+            rows[gate['dst']] = {(reduce(tuple(gate['word']) + word), column): coefficient for (word, column), coefficient in rows[gate['dst']].items()}
+        elif gate['op'] == 'ADD':
+            destination = dict(rows[gate['dst']])
+            for key, coefficient in rows[gate['src']].items():
+                destination[key] = destination.get(key, 0) + gate['q'] * coefficient
+                if destination[key] == 0:
+                    del destination[key]
+            rows[gate['dst']] = destination
+        elif gate['op'] == 'EXCHANGE':
+            rows = [rows[1], {key: -coefficient for key, coefficient in rows[0].items()}]
+        else:
+            raise ValueError(gate)
+    endpoint = (-3, 5, -2, 4, -1)
+    need(rows == [{(endpoint, 0): 1}, {(endpoint, 1): 1}], 'independent arbitrary-column group-ring identity')
+    return {'input_columns': 2, 'free_invertible_operators': 5, 'endpoint': list(endpoint)}
+
+
+def run():
+    old = canonical_predecessor()
+    ce = old.ce
+    records, phase_cases, controls = [], [], []
+    for group in range(3):
+        for coordinate, p in enumerate(old.bus['groups7'][group]):
+            q = old.bus['groups7'][(group + 1) % 3][coordinate]
+            r = old.bus['groups7'][(group + 2) % 3][coordinate]
+            chart = ce.perm(7, ce.transpose(old.completion(p, q), 7))
+            if group == 2:
+                pre = old.build(7, old.winner[p]['pre_events'])
+            else:
+                direction = q ^ r
+                pre = ce.perm(7, [(1 << i) ^ (direction if direction >> i & 1 else 0) for i in range(7)])
+            canonical_pre, _ = ce.monomial(chart.then(pre).then(chart.adjoint()))
+            local_p = canonical_pre.adjoint()
+            local_fresh = ce.fourier(7, range(2, 7))
+            local_common = ce.cgate(7, 1).then(ce.cgate(7, 2).adjoint())
+            first = standard_product(ce, local_fresh, local_p, local_common)
+            rank_first = native_rank(first)
+            need(rank_first == (3 if group == 2 else 5), 'actual fixed first-factor native rank')
+            # Complete phase check against the pinned compiler's literal lowering.
+            recipe, lowered = ce.lower_child(first)
+            need(recipe['rank'] == rank_first and first.tab == lowered.tab, 'native lowering signed tableau')
+            need(sparse_column(first) == sparse_column(lowered), 'independent local global phase')
+            cases = []
+            for length in (1, 3, 5, 9):
+                n = 2 + 5 * length
+                cp, cq = ce.cgate(n, 1), ce.cgate(n, 2)
+                common = cp.then(cq.adjoint())
+                fresh = [ce.fourier(n, range(2 + 5 * stage, 7 + 5 * stage)) for stage in range(length)]
+                ps = [old.embed(n, canonical_pre.circuit, [0, 1] + list(range(2 + 5 * stage, 7 + 5 * stage))).adjoint() for stage in range(length)]
+                qtotal, baseline, fpast, factored = ps[0], ps[0], fresh[0], standard_product(ce, fresh[0], ps[0], common)
+                monomials = []
+                for stage in range(1, length):
+                    monomial, _ = deliberate_monomial(ce, n, stage - 1, stage)
+                    monomials.append(monomial)
+                    insertion = standard_product(ce, fpast.adjoint(), monomial, fpast)
+                    qtotal = standard_product(ce, ps[stage], insertion, qtotal)
+                    baseline = standard_product(ce, ps[stage], baseline)
+                    fpast = standard_product(ce, fresh[stage], fpast)
+                    factor = standard_product(ce, fresh[stage], ps[stage])
+                    need(native_rank(factor) == 5, 'later factor native rank')
+                    factored = standard_product(ce, factor, monomial, factored)
+                original = standard_product(ce, fpast, qtotal, common)
+                need(original.tab == factored.tab, 'exact signed tableau of telescoping factorization')
+                # Independent columns/multiplication agree with exact compiler.
+                independent = binary_product(binary_tableau(fpast), binary_product(binary_tableau(qtotal), binary_tableau(common)))
+                need(independent == binary_tableau(original), 'independent symplectic endpoint multiplication')
+                rank_y = native_rank(original)
+                bound = 5 * (length - 1) + rank_first
+                need(rank_y <= bound < n, 'universal theorem bound on deliberate insertion')
+                baseline_y = standard_product(ce, fpast, baseline, common)
+                need(native_rank(baseline_y) == bound, 'identity insertion attains universal Y bound')
+                fx = standard_product(ce, ce.fourier(n), ce.xgate(n, 1), qtotal)
+                rank_x = native_rank(fx)
+                # At genuine B1 size17, independently compare full columns for
+                # a representative A port and C port; this fixes global phase.
+                if length == 3 and coordinate == 0 and group in (0, 2):
+                    original_state = sparse_column(original)
+                    need(original_state == sparse_column(factored), 'global B1 exact Gaussian column')
+                    phase_wrong = factored.then(ce.Op(n, ce.identity(n), [('phase', 1)]))
+                    need(phase_wrong.tab == original.tab and sparse_column(phase_wrong) != original_state, 'global-phase omission control')
+                    phase_cases.append({'group': group, 'p': p, 'n': n, 'output_support': len(original_state[0]), 'denominator_depth': original_state[1]})
+                cases.append({'L': length, 'm': n, 'X_native_rank': rank_x, 'Y_native_rank': rank_y, 'Y_rank_upper_bound': bound, 'identity_insertion_Y_native_rank': native_rank(baseline_y), 'Y_deficit_lower_bound': n - bound})
+            records.append({'group': group, 'coordinate': coordinate, 'p': p, 'q': q, 'first_factor_rank': rank_first, 'cases': cases})
+    # An undressed logical ADDRESS swap has a real hidden native query.
+    n = 4
+    cp, cq, past = ce.cgate(n, 1), ce.cgate(n, 2), ce.cgate(n, 4)
+    dx = standard_product(ce, cp, past)
+    swap = ce.perm(n, [1, 2, 8, 4])
+    dressed = standard_product(ce, dx.adjoint(), swap, dx)
+    need(native_rank(standard_product(ce, dx, dressed, dx.adjoint())) == 0, 'dressed swap admitted')
+    hidden = native_rank(standard_product(ce, dx, swap, dx.adjoint()))
+    need(hidden == 2, 'undressed swap admission control')
+    common = standard_product(ce, cq, cp.adjoint())
+    no_chirp = ce.perm(n, [2, 3, 4, 8])
+    need(native_rank(standard_product(ce, common, no_chirp, common.adjoint())) > 0, 'common chirp omission control')
+    wrong_inverse = standard_product(ce, past, swap, past)
+    right_inverse = standard_product(ce, past.adjoint(), swap, past)
+    need(wrong_inverse.tab != right_inverse.tab, 'positive/adjoint past-frame control')
+    controls.extend(['undressed_swap_costs_rank2', 'common_chirp_omission_breaks_second_front', 'past_frame_inverse_sign_is_essential', 'global_phase_i_rejected_on_two_B1_ports'])
+    return {
+        'status': 'PASS_FULL_MONOMIAL_INSERTION_Y_RANK_OBSTRUCTION_NO_NEW_KAPPA',
+        'scientific_pin': PIN,
+        'sources_sha256': PINS,
+        'source_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+        'free_word': verify_free_word(),
+        'theorem': {'C_Y_rank_upper': '5L-2 = m-4', 'AB_Y_rank_upper': '5L = m-2', 'm': '2+5L', 'quantifiers': 'Every L>=1; every locally admitted monomial pre_s on common2 plus own fresh5 with fixed first-factor ranks3/5; every insertion whose physical X-cut pullback is any invertible monomial. Second-front admission is unnecessary for the upper bound. Arbitrary permutations and diagonal nonzero phases, including non-Clifford monomials, are covered by the row-support proof.'},
+        'factorization': 'F_all P_last (F_past^-1 M_last-1 F_past) ... P_1 (F_0^-1 M_0 F_0) P_0 R = (F_last P_last) M_last-1 ... (F_1 P_1) M_0 (F_0 P_0 R)',
+        'records': records,
+        'independent_global_phase_cases': phase_cases,
+        'defect_controls': controls,
+        'all_size': 'Tensor columnwise over f>=1: each later factor has row support2^(5f), first factor2^(3f) C or2^(5f) A/B; monomials preserve support. Thus terminal Y has row support <=2^((m-4)f) C or2^((m-2)f) A/B and cannot be a rank-mf native child, even with arbitrary input values.',
+        'cost_boundary': {'OPEN_local_histogram': {'1': 8, '2': 40, '3': 16}, 'OPEN_local_rank_mass': 136, 'ordinary_helpers': 0, 'private_fields': 0, 'isolated_unary_completion_rank_lower_bound_per_twelve_port_Y_bank': 32, 'insertion_scans': 'All actual monomial address/phase scans remain paid; zero native rank does not mean zero work.'},
+        'limits': ['No arbitrary multibank insertion, changed scalar word, changed entrance code, overlapping local fresh supports, or different raw local boundary is excluded.', 'The proof does not calculate an optimal paid completion word, owner allocation, all-size rounded precision, physical tape controller, or positive conditional kappa.', 'This is a written all-parameter proof with finite exact operator checks, not formal-kernel verification.'],
+        'attribution': 'Uses frozen source-carrier/common-F normalizers and canonical endpoint charts from the2026-10-18 run; predecessor complex and algebra lanes plus root own those constructions. This lane supplies the exact telescoping argument, full arbitrary-monomial support bound, independent symplectic arithmetic and Gaussian phase evaluator.'
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--write', action='store_true')
+    args = parser.parse_args()
+    output = json.loads(json.dumps(run()))
+    target = HERE / 'FULL-STABILIZER-BOUND.json'
+    if args.write:
+        target.write_text(json.dumps(output, indent=2, sort_keys=True) + '\n')
+    else:
+        need(json.loads(target.read_bytes()) == output, 'stored exact receipt mismatch')
+    print(output['status'])
+    print('12 ports x L1/3/5/9; arbitrary-monomial proof;2 exact n17 phase checks;4 defect controls')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/coupled-tail-support-floor/verify.py b/research/coupled-tail-support-floor/verify.py
new file mode 100644
index 0000000000..81050b6dde
--- /dev/null
+++ b/research/coupled-tail-support-floor/verify.py
@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+"""Exact caller replay. Ross Richardson; substantial OpenAI Codex assistance.
+
+Apache-2.0. Immutable predecessor implementations are compiled from the same
+bytes authenticated below, with optimize=0 to preserve historical assertions.
+This direct verifier needs Python's standard library, no Git and no network.
+"""
+from pathlib import Path
+from fractions import Fraction
+from collections import Counter
+import copy
+import gzip
+import zlib
+import hashlib
+import importlib
+import importlib.abc
+import importlib.util
+import json
+import sys
+
+sys.dont_write_bytecode=True
+ROOT=Path(__file__).resolve().parent
+META=json.loads((ROOT/'BINDINGS.json').read_bytes())
+PINS={row['path']:row for row in META['files']}
+def need(condition,message):
+    if not condition:raise ValueError(message)
+need(len(PINS)==len(META['files']),'duplicate retained-source path')
+PHYSICAL_READ_BYTES=Path.read_bytes
+PHYSICAL_READ_TEXT=Path.read_text
+VIRTUAL=META.get('compressed_inputs',{})
+def unpack(transport,transport_sha,logical_sha,logical_bytes):
+    need(hashlib.sha256(transport).hexdigest()==transport_sha,'compressed input transport hash')
+    try:raw=gzip.decompress(transport)
+    except(OSError,EOFError,zlib.error)as error:raise ValueError('compressed payload decoding')from error
+    need(len(raw)==logical_bytes and hashlib.sha256(raw).hexdigest()==logical_sha,'compressed input logical bytes')
+    return raw
+def checked(relative,raw=None):
+    if relative in VIRTUAL:
+        need(raw is None,'logical aliases use authenticated transport bytes')
+        row=VIRTUAL[relative]
+        return unpack(checked(row['storage_path']),row['transport_sha256'],row['logical_sha256'],row['logical_bytes'])
+    row=PINS[relative];path=ROOT/relative
+    need(path.resolve()==path,'retained source must not be a symlink')
+    if raw is None:raw=PHYSICAL_READ_BYTES(path)
+    need(hashlib.sha256(raw).hexdigest()==row['sha256'],'retained source hash: '+relative)
+    return raw
+for relative in PINS:checked(relative)
+for alias,row in VIRTUAL.items():
+    need(alias.startswith(('source/','original/'))and alias.endswith('.json')and alias not in PINS and '..'not in Path(alias).parts,'declared read-only JSON alias')
+    need(row['storage_path']in PINS and row['transport_sha256']==PINS[row['storage_path']]['sha256'],'declared transport inventory')
+    checked(alias)
+def logical_name(path):
+    path=Path(path).resolve()
+    return str(path.relative_to(ROOT))if path.is_relative_to(ROOT)else None
+def alias_read_bytes(path):
+    original=META.get('original_read_aliases',{}).get(str(Path(path)))
+    if original is not None:return checked(original)
+    relative=logical_name(path)
+    need(relative is not None or not str(Path(path)).startswith('/Users/ross/git/math/'),'undeclared external workspace source read')
+    return checked(relative)if relative in VIRTUAL else PHYSICAL_READ_BYTES(path)
+def alias_read_text(path,encoding=None,errors=None):
+    original=META.get('original_read_aliases',{}).get(str(Path(path)))
+    if original is not None:return checked(original).decode(encoding or 'utf-8',errors or 'strict')
+    relative=logical_name(path)
+    need(relative is not None or not str(Path(path)).startswith('/Users/ross/git/math/'),'undeclared external workspace source read')
+    if relative in VIRTUAL:return checked(relative).decode(encoding or 'utf-8',errors or 'strict')
+    return PHYSICAL_READ_TEXT(path,encoding=encoding,errors=errors)
+Path.read_bytes=alias_read_bytes
+Path.read_text=alias_read_text
+
+def rejection(action,needle):
+    try:action()
+    except ValueError as error:
+        need(needle in str(error),'wrong rejecting predicate: '+str(error))
+    else:raise ValueError('negative control unexpectedly accepted: '+needle)
+
+# Positive and negative source-binding controls use real source bytes. The
+# loader below has no bytecode-cache path, including for dynamic source loads.
+first=next(p for p in PINS if p.endswith('.py'))
+need(checked(first,checked(first))==checked(first),'identical source positive control')
+rejection(lambda:checked(first,checked(first)+b'\n# altered source\n'),'retained source hash')
+MODULES=META['executed_modules']
+need(len(MODULES)==len(set(MODULES)), 'unique explicit executed module inventory')
+for name,relative in MODULES.items():need(relative in PINS and relative.endswith('.py'),'declared executable source')
+class ByteLoader(importlib.abc.Loader):
+    def __init__(self,relative):self.relative=relative
+    def create_module(self,spec):return None
+    def exec_module(self,module):
+        raw=checked(self.relative)
+        exec(compile(raw,str(ROOT/self.relative),'exec',dont_inherit=True,optimize=0),module.__dict__)
+class ByteFinder(importlib.abc.MetaPathFinder):
+    def find_spec(self,fullname,path=None,target=None):
+        if fullname in MODULES:
+            relative=MODULES[fullname]
+            return ORIGINAL_SPEC(fullname,str(ROOT/relative),loader=ByteLoader(relative))
+ORIGINAL_SPEC=importlib.util.spec_from_file_location
+def bound_spec(name,location,*args,**kwargs):
+    path=Path(location).resolve()
+    if path.is_relative_to(ROOT):
+        relative=str(path.relative_to(ROOT))
+        need(relative in PINS,'undeclared dynamic source '+relative)
+        return ORIGINAL_SPEC(name,str(path),loader=ByteLoader(relative))
+    need(not str(path).startswith('/Users/ross/git/math/'),'undeclared external dynamic source')
+    return ORIGINAL_SPEC(name,location,*args,**kwargs)
+importlib.util.spec_from_file_location=bound_spec
+sys.meta_path.insert(0,ByteFinder())
+def module(name):return importlib.import_module(name)
+def data(relative):return json.loads(checked('source/'+relative))
+def source_path(original):
+    candidates=[p for p,row in PINS.items() if p.startswith('source/') and (row['origin']==original or row['origin'].endswith('/'+original))]
+    need(len(candidates)==1,'one retained original source for '+original)
+    return ROOT/candidates[0]
+
+# Receipts contain original absolute provenance paths. All retained bytes are
+# separately checked above. These explicitly enumerated metadata fields are
+# omitted ONLY when comparing replay's mathematical body to its frozen receipt.
+PROVENANCE={'sources','source_pins','producer_sha256','helper_sha256',
+ 'native_model_sha256','base_producer_sha256','reflection_source_sha256','source_path','source_sha256',
+ 'path','witness','witness_sha256','elapsed_seconds','executed_source_bytes','exact_source_execution','bootstrap_sha256','solver_sha256'}
+def body(value):
+    if isinstance(value,dict):return {str(k):body(v) for k,v in value.items() if k not in PROVENANCE}
+    if isinstance(value,(list,tuple)):return [body(v) for v in value]
+    return value
+def difference(a,b,path='root'):
+    if type(a)!=type(b):return path+': type mismatch'
+    if isinstance(a,dict):
+        if a.keys()!=b.keys():return path+': keys '+str(set(a)^set(b))
+        for k in a:
+            if a[k]!=b[k]:return difference(a[k],b[k],path+'.'+k)
+    elif isinstance(a,list):
+        if len(a)!=len(b):return path+': lengths '+str((len(a),len(b)))
+        for i,(x,y) in enumerate(zip(a,b)):
+            if x!=y:return difference(x,y,path+'['+str(i)+']')
+    elif a!=b:return path+': '+repr(a)[:150]+' != '+repr(b)[:150]
+    return path
+RESULTS=[]
+def replay(name,function,receipt):
+    actual=json.loads(json.dumps(getattr(module(name),function)()))
+    expected=data(receipt)
+    aa,bb=body(actual),body(expected)
+    need(aa==bb,'mathematical receipt mismatch '+receipt+' '+difference(aa,bb))
+    RESULTS.append({'entry':name+'.'+function,'status':actual.get('status','PASS_COMPLETE_RECEIPT_EQUALITY'),'mathematical_receipt':receipt})
+    print('PASS_REPLAY',name,function,flush=True)
+    return actual
+
+# Immutable transport and full logical-payload authentication controls.
+alias=next(iter(VIRTUAL));row=VIRTUAL[alias];transport=checked(row['storage_path'])
+need(checked(alias)==unpack(transport,row['transport_sha256'],row['logical_sha256'],row['logical_bytes']),'identical lossless payload positive control')
+rejection(lambda:unpack(transport+b'x',row['transport_sha256'],row['logical_sha256'],row['logical_bytes']),'compressed input transport hash')
+rejection(lambda:unpack(transport,row['transport_sha256'],'0'*64,row['logical_bytes']),'compressed input logical bytes')
+bad=transport[:-1]
+rejection(lambda:unpack(bad,hashlib.sha256(bad).hexdigest(),row['logical_sha256'],row['logical_bytes']),'compressed payload decoding')
+for alias in VIRTUAL:need(not(ROOT/alias).exists(),'logical data aliases stay in memory without writing package files')
+print('PASS_LOSSLESS_READONLY_JSON_ALIAS_CONTROLS',flush=True)
+
+
+import ast
+for frozen in META['freezes']:
+    raw=checked(frozen['manifest']);need(hashlib.sha256(raw).hexdigest()==frozen['sha256'],'frozen exact manifest')
+    inv=json.loads(raw)['files']
+    if frozen['complete']:need(len(inv)==len(frozen['file_map']),'complete frozen inventory')
+    for name,relative in frozen['file_map'].items():
+        need(hashlib.sha256(checked(relative)).hexdigest()==next(x['sha256']for x in inv if x['path']==name),'raw frozen file '+name)
+for a in META['path_adaptations']:
+    if 'function_source_sha256'not in a:continue
+    def parts(raw):
+        s=raw.decode();return {n.name:ast.get_source_segment(s,n).encode()for n in ast.parse(s).body if isinstance(n,(ast.FunctionDef,ast.ClassDef))}
+    old,new=parts(checked(a['original'])),parts(checked(a['path']))
+    need(set(new)==set(a['function_source_sha256']),'exact pure function inventory')
+    for name,digest in a['function_source_sha256'].items():need(old[name]==new[name]and hashlib.sha256(new[name]).hexdigest()==digest,'unchanged recipe function '+name)
+base=checked('original/coupled-tail-escape/local_block.py')
+expected=base.replace(b'5782033e347c9b10ad47c01ed12a0a52ea07e901fa9e8f7aa9d3a2a928327232',PINS['source/caller-joint/joint_algebra.py']['sha256'].encode()).replace(b'7457b3672d5a73c584d2073b5d3312e6429fd3f433151f15f8f07da33aa4c59a',PINS['source/caller-joint/validate_recipe_links.py']['sha256'].encode())
+need(checked('source/portable/local_block.py')==expected,'only two executed hash guard changes')
+rejection(lambda:Path('/Users/ross/git/math/undeclared-tail-control.py').read_bytes(),'undeclared external workspace source read')
+print('PASS_COMPLETE_FROZEN_TAIL_SOURCE_BINDINGS',flush=True)
+q2=replay('local_block','produce','coupled-tail-escape/LOCAL-BLOCK.json')
+q3=replay('q3_tail','produce','coupled-tail-escape/Q3-LOCAL-BLOCK.json')
+need((q2['unchanged_prefix_native_mass'],q2['local_native_mass'],q2['endpoint_stock'],q2['unavoidable_entry']['native_arity_per_f'])==(66,10,72,6),'q2 whole prefix/local/stock/entry invoice')
+need((q3['unchanged_prefix_native_mass'],q3['local_native_mass'],q3['stock'],q3['unavoidable_entry']['native_arity_per_f'])==(120,12,128,8),'q3 whole prefix/local/stock/entry invoice')
+print('PASS_SOURCE_LOCAL_BLOCKS_AND_ALL_F_SUPPORT_WITNESSES',flush=True)
+
+for dependency in META.get('independent_external_sources',[]):
+    need(hashlib.sha256(checked(dependency['relative'])).hexdigest()==dependency['sha256'],'raw independent source input')
+independent=replay('audit_tail','run','coupled-tail-independent-review/AUDIT.json')
+need([(x['q'],x['prefix_native_mass'],x['local_native_mass'],x['single_entry_arity'])for x in independent['cases']]==[(2,66,10,6),(3,120,12,8)],'complete independent exact local cases')
+need([x['q']for x in independent['conditional_tail_rank_grid']]==list(range(2,11)),'conditional rank grid q2throughq10')
+ce=module('native_model').ce
+try:ce.diag(2,(2,0),(0,0))
+except AssertionError:pass
+else:raise ValueError('historical source assertions disabled under optimized parent')
+rejection(lambda:bound_spec('unbound_tail_control','/Users/ross/git/math/undeclared-tail-control.py'),'undeclared external dynamic source')
+print('PASS_COMPLETE_INDEPENDENT_LOCAL_TAIL_SUPPORT_NO_NEW_KAPPA',flush=True)
+
+admitted=data('two-site-continuation/ADMITTED-TWO-SITE-FUSIONS.json')
+for f in admitted['fixtures']:
+    q=f['q'];cut={2:69,3:119}[q]
+    prefix=Counter(e['rank_per_f']for e in f['events'][:cut]if e['kind']=='NATIVE')
+    need(prefix=={2:{2:33},3:{2:60}}[q],'actual fixed prefix histogram for conditional moment')
+print('PASS_CONDITIONAL_FULLSCAN_MOMENT_PREFIX_BINDING',flush=True)
+
+# Exact next-interface appendix, strictly planning-only and rank-neutral.
+for x in META['cut58_raw_sources']:
+    need(hashlib.sha256(checked(x['relative'])).hexdigest()==x['sha256'],'raw cut58 planning source pin')
+planning=replay('cut58','produce','early-cut58-planning/CUT58.json')
+review=replay('audit_cut58','run','early-cut58-independent-review/AUDIT.json')
+need(planning['target_is_not_achieved']is True and planning['hypothetical_target_suffix_mass']==16,'open hypothetical target never claimed achieved')
+need((planning['prefix_native_mass'],planning['suffix_native_mass'],planning['complete_mass'],planning['stock'])==(54,22,76,72),'unchanged planning native bill')
+need(review['all_current_input_columns']==6 and review['literal_inverse_orders']==2 and review['neutral_factorization_mass']==22,'complete independent planning-only scope')
+print('PASS_CUT58_NEXT_INTERFACE_NEUTRAL_ONLY_TARGET16_OPEN',flush=True)