diff --git a/research/p104-nearest-contact-verification/INPUTS.json b/research/p104-nearest-contact-verification/INPUTS.json
new file mode 100644
index 0000000000..73f2c98d68
--- /dev/null
+++ b/research/p104-nearest-contact-verification/INPUTS.json
@@ -0,0 +1,28 @@
+{
+  "files": {
+    "NOMINATION.json": "4b9d8416befd5a82e46cfdcbe90c1460f02286f6682d661d61990b3041de9483",
+    "source/NOTICE": "e8e0cabef6cf40d63f3cea3b6403dfd1af8727e40df03f09b2932718bcddc1b0",
+    "source/PROOF.md": "a599f482ec35ddf84b1ddf72da92a6edbb77b9c4eccab6ffe31fdece2419f099",
+    "source/RESULT.json": "ab036dc5fd6c1b19255d03007a858325a18bb7de12843687db74d85f146f5020",
+    "source/SOURCES.json": "d87d48095d56bdc26a2f86e05760915b2b341000e53c1f877d6348331f66dded",
+    "source/WITNESS.json": "0753bc9933fbb954ec79b3d054b4f60bb3ee5c97801f426d4104da5fc5bc38b3",
+    "source/WORD-CUSTODY.json": "da8001e3fccfdc040aa87ce4562c0883508719c509087a02cdbd79872b282964",
+    "source/WORD.json.gz": "b56281a67f84832198be2f2ad36d87b75244d424f1e0a6f4dda2df74f20cc08d",
+    "source/construct.py": "ab9b0e00e67caac137477c0b8e646ba5604d02a7a0a297c4e3fce9e20105812e",
+    "source/local-grammar.py": "716d01a342467f87b14d67853d8de30740f9f2fa881afe271db0df5ef8b19697"
+  },
+  "git_blobs": {
+    "source/NOTICE": "fa0bd1401f5775f4351cfa23b08f3998dba6129e",
+    "source/PROOF.md": "77ef428c1ad8bc20690edecee92d8dd16c28ba52",
+    "source/RESULT.json": "d5a73ee8eceab0b4ac6850c06bca7152d3d6800e",
+    "source/SOURCES.json": "5c13f25a07882c22c7e5ede4f1aaa5cfc94928da",
+    "source/WITNESS.json": "d3554cd80f0d7534c07b76dd64eadfb228c0c8d6",
+    "source/construct.py": "ff4d7701fc1eaa7e31a9b937ac7f6c732c6634a9",
+    "source/local-grammar.py": "e72cb02dba9b68d3bd5934371b5d25a44589c482"
+  },
+  "grammar_scope": "Authenticated declared public grammar, not archive-member or full runtime equality. No source module imported.",
+  "source_result": "source/RESULT.json",
+  "witness": "source/WITNESS.json",
+  "word": "source/WORD.json.gz",
+  "word_custody": "source/WORD-CUSTODY.json"
+}
diff --git a/research/p104-nearest-contact-verification/LICENSE b/research/p104-nearest-contact-verification/LICENSE
new file mode 100644
index 0000000000..261eeb9e9f
--- /dev/null
+++ b/research/p104-nearest-contact-verification/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/p104-nearest-contact-verification/NOMINATION.json b/research/p104-nearest-contact-verification/NOMINATION.json
new file mode 100644
index 0000000000..08cfe66f05
--- /dev/null
+++ b/research/p104-nearest-contact-verification/NOMINATION.json
@@ -0,0 +1,43 @@
+{
+  "fixed_anchors": {
+    "R": {
+      "instruction": [
+        "ADD",
+        140,
+        438,
+        "-1/2",
+        794
+      ]
+    },
+    "Y": {
+      "instruction": [
+        "ADD",
+        144,
+        438,
+        "-1/2",
+        911
+      ]
+    }
+  },
+  "missing_anchors": {
+    "P": {
+      "required_prefix": [
+        "ADD",
+        144,
+        140,
+        "1"
+      ]
+    },
+    "Q": {
+      "required_prefix": [
+        "ADD",
+        144,
+        140,
+        "-1"
+      ]
+    }
+  },
+  "source": {
+    "head": "af814f6f3c477fdd13b8f04380a33cf32004966b"
+  }
+}
diff --git a/research/p104-nearest-contact-verification/NOTICE b/research/p104-nearest-contact-verification/NOTICE
new file mode 100644
index 0000000000..1f04855435
--- /dev/null
+++ b/research/p104-nearest-contact-verification/NOTICE
@@ -0,0 +1,13 @@
+P104 fixed nearest-contact verification. Apache-2.0; see LICENSE.
+
+Ali Romman's public paid interior bases, block certificates, author-side
+verification and released screening work are credited. Full original notices
+are preserved verbatim in source/NOTICE and in the vendored source files.
+The source-word, private-reuse, controller, native, compiler, precision and
+analytic lineage retains all predecessor credit named there. The elementary
+compensated-update identity and binary subspace methods are classical.
+
+Chris R (Clear1nsight)'s bounded qualification, separate static review and
+portable verification packaging used substantial OpenAI Codex assistance.
+The scientific core is unchanged except for its package-root assignment.
+No source module is imported; no new construction or kappa is claimed.
diff --git a/research/p104-nearest-contact-verification/PORTABLE.json b/research/p104-nearest-contact-verification/PORTABLE.json
new file mode 100644
index 0000000000..50a1321ee5
--- /dev/null
+++ b/research/p104-nearest-contact-verification/PORTABLE.json
@@ -0,0 +1,129 @@
+{
+  "core_adaptation": "Exactly ROOT=HERE.parents[2] becomes ROOT=HERE. All scientific logic unchanged.",
+  "inventory_scope": "All package payloads except this inventory and verifier, avoiding self-reference. Those are bound by root publication request and committed-byte checks.",
+  "original_checker_sha256": "2c747e340f4818a1064608323a877d693b5885bd58a1774e9b82315033649525",
+  "original_result_sha256": "18dac3a5092667ab5f5118ed6e953d65d558a8d11066e95cc728a069ec01f50f",
+  "payloads": {
+    "INPUTS.json": {
+      "bytes": 1764,
+      "sha256": "d0a54e640750d418b3be43f19128886e99678372a3c6fb26fe5379de426ae379"
+    },
+    "LICENSE": {
+      "bytes": 11357,
+      "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    },
+    "NOMINATION.json": {
+      "bytes": 578,
+      "sha256": "4b9d8416befd5a82e46cfdcbe90c1460f02286f6682d661d61990b3041de9483"
+    },
+    "NOTICE": {
+      "bytes": 808,
+      "sha256": "5e45c5dc13a50fba74266169d9a4b5fa5d1fd95d44a4e3ed29b039bcd7cb4c9c"
+    },
+    "PROOF.md": {
+      "bytes": 2725,
+      "sha256": "c5f2f8d3d5b2ccd59b1694c8eb604f14f861d472217928945ca3099fa71db038"
+    },
+    "README.md": {
+      "bytes": 7037,
+      "sha256": "c08fcf008a16fc9d2b69cb80de772184de99b08dbb5ea984cec7fa78d5709b39"
+    },
+    "SOURCES.json": {
+      "bytes": 5228,
+      "sha256": "2af14419c467a50054a4876a33509c3b83925d5680f5d143b2360be8ddcd2c48"
+    },
+    "TASK.json": {
+      "bytes": 4888,
+      "sha256": "f2bc4526829cc31491ba61df0bac7815d60fa3a4e42922ffbbdbab571426b419"
+    },
+    "VERIFY.json": {
+      "bytes": 1081,
+      "sha256": "5410b0faf5219ae8aed6c0d3f569493b97f588af1b97b2a2bb6e92b86c71c0d3"
+    },
+    "check.py": {
+      "bytes": 20751,
+      "sha256": "1218dac4b1ab3fa5d9b143b68a7398cfd2960377df3330744198e626933bf6cb"
+    },
+    "evidence/CORE-ADAPTATION.diff": {
+      "bytes": 327,
+      "sha256": "52e4e4dab3e4bd9d8fc95a395f52cb22ae1ba2b19882b3036a082b7adda1ddf1"
+    },
+    "evidence/ORIGINAL-EXECUTION.json": {
+      "bytes": 1843,
+      "sha256": "0c0391411d859bc23ab6cfa8d58b31c9edbb9929d6fbe0c0bd4cf624d3b0bf10"
+    },
+    "evidence/ORIGINAL-REQUEST.json": {
+      "bytes": 1951,
+      "sha256": "42538882b3ece2d350bc37dbf1d94c95b88ab02a278ca050dced007ab75213cf"
+    },
+    "evidence/POST-REVIEW.json": {
+      "bytes": 2693,
+      "sha256": "57fc8e72c5e2fbb27c07bdca1446f23c7aa2e234ed00671413765efde56f74f3"
+    },
+    "evidence/PUBLICATION-CONTEXT.json": {
+      "bytes": 1341,
+      "sha256": "efa718513b94666662dc120861ab02e025607a970fc174b6240418ecd4435e38"
+    },
+    "evidence/RESULT-normal.json": {
+      "bytes": 3233,
+      "sha256": "18dac3a5092667ab5f5118ed6e953d65d558a8d11066e95cc728a069ec01f50f"
+    },
+    "evidence/RESULT-optimized.json": {
+      "bytes": 3233,
+      "sha256": "18dac3a5092667ab5f5118ed6e953d65d558a8d11066e95cc728a069ec01f50f"
+    },
+    "evidence/STATIC-REVIEW.json": {
+      "bytes": 914,
+      "sha256": "4ea712eadaa501778c1ae5cbce240e04340e23227f583935ebf9198b1d2752d1"
+    },
+    "evidence/original-check.py": {
+      "bytes": 20762,
+      "sha256": "2c747e340f4818a1064608323a877d693b5885bd58a1774e9b82315033649525"
+    },
+    "source/NOTICE": {
+      "bytes": 2179,
+      "git_blob": "fa0bd1401f5775f4351cfa23b08f3998dba6129e",
+      "sha256": "e8e0cabef6cf40d63f3cea3b6403dfd1af8727e40df03f09b2932718bcddc1b0"
+    },
+    "source/PROOF.md": {
+      "bytes": 5043,
+      "git_blob": "77ef428c1ad8bc20690edecee92d8dd16c28ba52",
+      "sha256": "a599f482ec35ddf84b1ddf72da92a6edbb77b9c4eccab6ffe31fdece2419f099"
+    },
+    "source/RESULT.json": {
+      "bytes": 14703,
+      "git_blob": "d5a73ee8eceab0b4ac6850c06bca7152d3d6800e",
+      "sha256": "ab036dc5fd6c1b19255d03007a858325a18bb7de12843687db74d85f146f5020"
+    },
+    "source/SOURCES.json": {
+      "bytes": 2028,
+      "git_blob": "5c13f25a07882c22c7e5ede4f1aaa5cfc94928da",
+      "sha256": "d87d48095d56bdc26a2f86e05760915b2b341000e53c1f877d6348331f66dded"
+    },
+    "source/WITNESS.json": {
+      "bytes": 7815,
+      "git_blob": "d3554cd80f0d7534c07b76dd64eadfb228c0c8d6",
+      "sha256": "0753bc9933fbb954ec79b3d054b4f60bb3ee5c97801f426d4104da5fc5bc38b3"
+    },
+    "source/WORD-CUSTODY.json": {
+      "bytes": 214,
+      "sha256": "da8001e3fccfdc040aa87ce4562c0883508719c509087a02cdbd79872b282964"
+    },
+    "source/WORD.json.gz": {
+      "bytes": 120135,
+      "git_blob": "8be2b3e1c2d02034d4579bef5d36df7761d826ff",
+      "sha256": "b56281a67f84832198be2f2ad36d87b75244d424f1e0a6f4dda2df74f20cc08d"
+    },
+    "source/construct.py": {
+      "bytes": 5439,
+      "git_blob": "ff4d7701fc1eaa7e31a9b937ac7f6c732c6634a9",
+      "sha256": "ab9b0e00e67caac137477c0b8e646ba5604d02a7a0a297c4e3fce9e20105812e"
+    },
+    "source/local-grammar.py": {
+      "bytes": 9392,
+      "git_blob": "e72cb02dba9b68d3bd5934371b5d25a44589c482",
+      "sha256": "716d01a342467f87b14d67853d8de30740f9f2fa881afe271db0df5ef8b19697"
+    }
+  },
+  "schema": "pr5678-nearest-public-payloads/v1"
+}
diff --git a/research/p104-nearest-contact-verification/PROOF.md b/research/p104-nearest-contact-verification/PROOF.md
new file mode 100644
index 0000000000..8950c5edcd
--- /dev/null
+++ b/research/p104-nearest-contact-verification/PROOF.md
@@ -0,0 +1,27 @@
+# The fixed nearest-contact predicate fails
+
+The public basis construction in Ali Romman's [PR #5678](https://github.com/CrocSwap/integer-mult-bounds/pull/5678), head `af814f6f3c477fdd13b8f04380a33cf32004966b`, supplies the certified scalar anchors
+
+$$R:\;140\mathrel{+}=-\tfrac12\,438\quad\text{at frame }794,$$
+$$Y:\;144\mathrel{+}=-\tfrac12\,438\quad\text{at frame }911.$$
+
+One fixed proposed prerequisite asked whether the two immediately preceding complete semantic contacts of 144 before Y were exactly
+
+$$P:\;144\mathrel{+}=140,\qquad Q:\;144\mathrel{+}=-140,$$
+
+with $P<R<Q<Y$. It did not ask for some farther-back pair or a different coefficient, source role or orientation. ADD and COPY source reads and destination writes count as observers, as does every SCALE, including identity SCALE. Owned interfaces are included. MOVE is excluded from this logical observer projection only under the declared source transport invariant; native/phase equivalence is not thereby admitted.
+
+The uniquely bound final-source R and Y occur at zero-based program events 14893 and 15473. The actual two immediately preceding contacts of 144 before Y are:
+
+| Event | Exact actual instruction |
+|---:|---|
+| 13344 | `ADD(144,317,"1",356)` |
+| 13463 | `ADD(144,530,"1",1035)` |
+
+Neither has source 140, the second coefficient is positive rather than negative, and both events precede R. Therefore the strict nominated nearest-contact predicate is false. No question about a farther pair is answered. Roles 317 and 530 are witnesses to this falsifier, not new nominations.
+
+Binding uses the unique entry/R context and spectator/Y/exit context of the published high-pair certificate. Their actual event indices are entry 14891, R 14893, spectator 15470, Y 15473 and exit 15476. Historical stage block identifiers are not reused as final indices. Complete original result bytes preserve the exact contacts, contexts and stop reason.
+
+The checker stops at this mismatch. It does not execute the source write-corridor checks or complete affected-route extraction, evaluate powers/prices, derive a changed paid invoice, construct a word or claim a new $\kappa$. The conditional compensated-update identity is classical and is not refuted: its strictly nominated occurrence is absent here.
+
+The source owner separately reports 222435 absorbed-shear placements and 189 whole-block relocation screens. Their exact matcher coverage of this predicate remains UNKNOWN. This certificate is an independent fixed-input verification, with no claim of a new mechanism, an unsearched word, a global exclusion or a defect in the published construction. Any different pair, chart, source, schedule or graph requires a fresh nomination and ownership gate.
diff --git a/research/p104-nearest-contact-verification/README.md b/research/p104-nearest-contact-verification/README.md
new file mode 100644
index 0000000000..4c7d00ed0c
--- /dev/null
+++ b/research/p104-nearest-contact-verification/README.md
@@ -0,0 +1,46 @@
+# Verification of one fixed nearest-contact falsifier
+
+## Change and mathematical scope
+
+This package independently verifies one strict prerequisite on the published word of Ali Romman's [PR #5678](https://github.com/CrocSwap/integer-mult-bounds/pull/5678), head `af814f6f3c477fdd13b8f04380a33cf32004966b`. Before certified Y=`ADD(144,438,"-1/2",911)`, the actual two immediately preceding complete semantic contacts of role 144 are `ADD(144,317,"1",356)` at event 13344 and `ADD(144,530,"1",1035)` at event 13463. They are not the nominated `ADD(144,140,"1",U)` and `ADD(144,140,"-1",V)`. Both also precede certified R at event 14893, whereas the proposed order required P<R<Q<Y. The short argument is in [PROOF.md](PROOF.md).
+
+The completed status is `COMPLETED_FIXED_NEAREST_CONTACT_FALSIFIER`. The test stops before source corridor checks, complete affected-route extraction, powers, pricing, any candidate invoice or construction. It earns no paid saving or new $\kappa$. It is a verification of the fixed predicate, not a defect in the original construction or a general negative theorem.
+
+The exact compressed public WORD is 120,135 bytes, Git blob `8be2b3e1c2d02034d4579bef5d36df7761d826ff`, SHA256 `b56281a67f84832198be2f2ad36d87b75244d424f1e0a6f4dda2df74f20cc08d`. The checker authenticates custody before bounded decompression. No earlier or alternative contact pair is queried.
+
+## Task and overlap
+
+The package records a changed scope under `complex-new-helper-inventory`; [TASK.json](TASK.json) copies its exact original card and explains the narrower verification result. Publication base is `df0137efd35e11b4445734bf612bdd4c7ebc330c`. All runtime data is committed inside this package; no cached predecessor Git objects, network, released modules, constructors or predecessor archives are required for replay.
+
+The source owner's released screens report 222435 absorbed-shear placements and 189 whole-block relocations. Their exact coverage of this matcher is UNKNOWN. The useful contribution is a small independently reviewed, source-bound falsifier with exact contact witnesses and portable replay. It does not claim a new elementary identity, an unsearched whole word, global novelty or exhaustive failure. Neighboring [Discussion #5125](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125) and [Discussion #5645](https://github.com/CrocSwap/integer-mult-bounds/discussions/5645) remain distinct coordination contexts. No matcher domain is appropriated by different role labels.
+
+## Validation
+
+The original independently reviewed serial normal/optimized pair returned identical complete result bytes, SHA256 `18dac3a5092667ab5f5118ed6e953d65d558a8d11066e95cc728a069ec01f50f`. Both children exited 0 with empty stderr. Nine bounded negative controls rejected; one exact positive synthetic conditional identity passed. The guard elapsed 1.0066231779928785 seconds with sampled peak descendant RSS 52,416,512 bytes, under 150 seconds, 512 MiB and 60-second child limits. All 26 frozen files including the request, plus the independent approval, remained unchanged.
+
+The portable scientific core differs by exactly one ROOT assignment; [the diff](evidence/CORE-ADAPTATION.diff) is checked against the preserved original core before execution. Minimal local INPUTS, custody and nomination contain only consumed public scientific fields. Each registered command runs the core once and requires its **entire** original output SHA256, exact nearest witnesses and strict stop. The registered normal/optimized pair therefore performs two core executions. Additional integrity controls reject altered compressed source and core bytes without decoding mutated input. No assertion decides acceptance.
+
+```sh
+python3 -B scripts/research_package.py --package research/p104-nearest-contact-verification --check-only
+python3 -B scripts/research_package.py --package research/p104-nearest-contact-verification
+python3 -B scripts/check_research_commit.py --package research/p104-nearest-contact-verification --check-source-history
+```
+
+A relocated, read-only, Git-free package supports the same two commands from any directory:
+
+```sh
+python3 -I -B /path/to/p104-nearest-contact-verification/verify.py
+python3 -I -B -O /path/to/p104-nearest-contact-verification/verify.py
+```
+
+Root qualification uses one serial 150-second, 512 MiB guard per registered pair and 60 seconds per child, with no retry or cap increase. Portable checkout and export receipts are separate from the original experiment; the verifier requires no Git or network and uses only a temporary external bytecode cache. Metadata, committed-byte/source-history and scientific replay checks are separate gates.
+
+Both full original result byte strings and the original core are preserved in `evidence/`. Public request/review/receipt extracts identify their original hashes and explicitly omit local paths, human prompts and unrelated planning. [SOURCES.json](SOURCES.json) records custody and [PORTABLE.json](PORTABLE.json) hashes payloads. The 16 MiB decompression limit is an abort cap, not an asserted required size; original JSON/instruction/frame caps remain. The authenticated public grammar has not been equated to an archive member. Conservative unresolved COPY-zero cases are source/grammar failures, never scientific falsifiers. Endpoint matrices, erasure-zero values, native operators/global phases/all widths, physical caller, ordinary costs, pricing and the compiler/funding/BIT/outer conjunction are not admitted.
+
+## Credit
+
+Ali Romman supplied the concrete paid interior bases, public block certificates and verification in [PR #5678](https://github.com/CrocSwap/integer-mult-bounds/pull/5678), as well as the released screen work whose exact matcher coverage remains unknown. [PR #5660](https://github.com/CrocSwap/integer-mult-bounds/pull/5660), zxv's [PR #5643](https://github.com/CrocSwap/integer-mult-bounds/pull/5643), helper cleanup [PR #5644](https://github.com/CrocSwap/integer-mult-bounds/pull/5644), and released composition [PR #5650](https://github.com/CrocSwap/integer-mult-bounds/pull/5650) retain their credit. The copied [source notice](source/NOTICE) preserves the full source-word/private/controller/native/compiler/precision lineage, including David Arias, Cinna Davis, Gareth Davidson and other named contributors. The compensated-update identity and exact subspace methods are classical. Chris R/Clear1nsight's bounded qualification, separate static review and portable packaging used substantial OpenAI Codex assistance. Apache-2.0 notices are retained; no independent human or proof-kernel acceptance is implied.
+
+## Open next questions
+
+None is automatically justified for this exact nomination. Stop at the nearest-contact mismatch; roles 317/530, farther-back pairs, altered signs/charts or longer intervals are not follow-up nominations. A materially changed question needs a fresh exact-source nomination and ownership gate. [TASK.json](TASK.json) records why this result authorizes no next scan or construction.
diff --git a/research/p104-nearest-contact-verification/SOURCES.json b/research/p104-nearest-contact-verification/SOURCES.json
new file mode 100644
index 0000000000..cd8cd2e3c6
--- /dev/null
+++ b/research/p104-nearest-contact-verification/SOURCES.json
@@ -0,0 +1,87 @@
+{
+  "base_commit": "df0137efd35e11b4445734bf612bdd4c7ebc330c",
+  "files": [
+    {
+      "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602",
+      "path": "docs/research/agent-task-catalog.json",
+      "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72",
+      "usage": "provenance"
+    }
+  ],
+  "grammar_caveat": "Authenticated declared public grammar; archive-member/full runtime equality untested. The standalone reader imports no source module or archive.",
+  "original_checker_sha256": "2c747e340f4818a1064608323a877d693b5885bd58a1774e9b82315033649525",
+  "original_request_sha256": "31af46d73942c9dc1c16369d0d473b3afb194365df2e1baa54f78885394de2a1",
+  "original_result_sha256": "18dac3a5092667ab5f5118ed6e953d65d558a8d11066e95cc728a069ec01f50f",
+  "payload_inventory": "PORTABLE.json",
+  "schema_version": 1,
+  "source_head": "af814f6f3c477fdd13b8f04380a33cf32004966b",
+  "source_policy": "Self-contained committed source export; public predecessor heads are provenance labels, not runtime Git dependencies or unsupported external pins. Runtime paths are package-local INPUTS/PORTABLE entries. No external live input; package-local changes trigger replay.",
+  "source_pr_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5678",
+  "vendored_sources": [
+    {
+      "git_blob": "77ef428c1ad8bc20690edecee92d8dd16c28ba52",
+      "head": "af814f6f3c477fdd13b8f04380a33cf32004966b",
+      "package_path": "source/PROOF.md",
+      "sha256": "a599f482ec35ddf84b1ddf72da92a6edbb77b9c4eccab6ffe31fdece2419f099",
+      "upstream_path": "research/p104-paid-interior-bases/PROOF.md",
+      "url": "https://github.com/aliromman/integer-mult-bounds/blob/af814f6f3c477fdd13b8f04380a33cf32004966b/research/p104-paid-interior-bases/PROOF.md"
+    },
+    {
+      "git_blob": "d3554cd80f0d7534c07b76dd64eadfb228c0c8d6",
+      "head": "af814f6f3c477fdd13b8f04380a33cf32004966b",
+      "package_path": "source/WITNESS.json",
+      "sha256": "0753bc9933fbb954ec79b3d054b4f60bb3ee5c97801f426d4104da5fc5bc38b3",
+      "upstream_path": "research/p104-paid-interior-bases/WITNESS.json",
+      "url": "https://github.com/aliromman/integer-mult-bounds/blob/af814f6f3c477fdd13b8f04380a33cf32004966b/research/p104-paid-interior-bases/WITNESS.json"
+    },
+    {
+      "git_blob": "d5a73ee8eceab0b4ac6850c06bca7152d3d6800e",
+      "head": "af814f6f3c477fdd13b8f04380a33cf32004966b",
+      "package_path": "source/RESULT.json",
+      "sha256": "ab036dc5fd6c1b19255d03007a858325a18bb7de12843687db74d85f146f5020",
+      "upstream_path": "research/p104-paid-interior-bases/RESULT.json",
+      "url": "https://github.com/aliromman/integer-mult-bounds/blob/af814f6f3c477fdd13b8f04380a33cf32004966b/research/p104-paid-interior-bases/RESULT.json"
+    },
+    {
+      "git_blob": "5c13f25a07882c22c7e5ede4f1aaa5cfc94928da",
+      "head": "af814f6f3c477fdd13b8f04380a33cf32004966b",
+      "package_path": "source/SOURCES.json",
+      "sha256": "d87d48095d56bdc26a2f86e05760915b2b341000e53c1f877d6348331f66dded",
+      "upstream_path": "research/p104-paid-interior-bases/SOURCES.json",
+      "url": "https://github.com/aliromman/integer-mult-bounds/blob/af814f6f3c477fdd13b8f04380a33cf32004966b/research/p104-paid-interior-bases/SOURCES.json"
+    },
+    {
+      "git_blob": "ff4d7701fc1eaa7e31a9b937ac7f6c732c6634a9",
+      "head": "af814f6f3c477fdd13b8f04380a33cf32004966b",
+      "package_path": "source/construct.py",
+      "sha256": "ab9b0e00e67caac137477c0b8e646ba5604d02a7a0a297c4e3fce9e20105812e",
+      "upstream_path": "research/p104-paid-interior-bases/construct.py",
+      "url": "https://github.com/aliromman/integer-mult-bounds/blob/af814f6f3c477fdd13b8f04380a33cf32004966b/research/p104-paid-interior-bases/construct.py"
+    },
+    {
+      "git_blob": "fa0bd1401f5775f4351cfa23b08f3998dba6129e",
+      "head": "af814f6f3c477fdd13b8f04380a33cf32004966b",
+      "package_path": "source/NOTICE",
+      "sha256": "e8e0cabef6cf40d63f3cea3b6403dfd1af8727e40df03f09b2932718bcddc1b0",
+      "upstream_path": "research/p104-paid-interior-bases/NOTICE",
+      "url": "https://github.com/aliromman/integer-mult-bounds/blob/af814f6f3c477fdd13b8f04380a33cf32004966b/research/p104-paid-interior-bases/NOTICE"
+    },
+    {
+      "bytes": 120135,
+      "git_blob": "8be2b3e1c2d02034d4579bef5d36df7761d826ff",
+      "head": "af814f6f3c477fdd13b8f04380a33cf32004966b",
+      "package_path": "source/WORD.json.gz",
+      "sha256": "b56281a67f84832198be2f2ad36d87b75244d424f1e0a6f4dda2df74f20cc08d",
+      "upstream_path": "research/p104-paid-interior-bases/WORD.json.gz",
+      "url": "https://github.com/aliromman/integer-mult-bounds/blob/af814f6f3c477fdd13b8f04380a33cf32004966b/research/p104-paid-interior-bases/WORD.json.gz"
+    },
+    {
+      "git_blob": "e72cb02dba9b68d3bd5934371b5d25a44589c482",
+      "head": "ed4dc88a09a7d201971f6603b8c2074e95dd9c32",
+      "package_path": "source/local-grammar.py",
+      "sha256": "716d01a342467f87b14d67853d8de30740f9f2fa881afe271db0df5ef8b19697",
+      "upstream_path": "research/p104-helper-subspace-splits/local.py",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/ed4dc88a09a7d201971f6603b8c2074e95dd9c32/research/p104-helper-subspace-splits/local.py"
+    }
+  ]
+}
diff --git a/research/p104-nearest-contact-verification/TASK.json b/research/p104-nearest-contact-verification/TASK.json
new file mode 100644
index 0000000000..3090f28c9c
--- /dev/null
+++ b/research/p104-nearest-contact-verification/TASK.json
@@ -0,0 +1,61 @@
+{
+  "actual_scope": "One fixed nearest-contact falsifier on exact PR #5678 source, with complete semantic-observer coverage and preserved source/result custody.",
+  "ai_assistance": "Substantial OpenAI Codex assistance in bounded qualification, separate static review, proof explanation and portable packaging. Prior construction and released screens remain credited.",
+  "author": "Chris R (Clear1nsight), with substantial OpenAI Codex assistance",
+  "base_commit": "df0137efd35e11b4445734bf612bdd4c7ebc330c",
+  "bottleneck_link": "A paid graph-contraction proposal cannot proceed when the prescribed two nearest receiver contacts are absent.",
+  "budget_minutes": null,
+  "evidence": "Both full original result byte strings; source WORD and public scientific data; unchanged original core plus one ROOT adaptation; sanitized request, static/post review and execution evidence.",
+  "no_open_questions_reason": "The strictly nominated nearest pair is absent. This fixed verification justifies stopping the object, not automatically constructing or searching alternatives.",
+  "open_questions": [],
+  "original_card": {
+    "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model. 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.",
+    "allowed_variations": [
+      "Narrow to one changed boundary or helper type with explicit counts.",
+      "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."
+    ],
+    "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.",
+    "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/complex-local-word-ceiling/verify.py"
+      ],
+      "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING",
+      "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.",
+      "scope": "Positive control and planning budget only; this is not a new construction or full cold replay."
+    },
+    "id": "complex-new-helper-inventory",
+    "methods": [
+      "Propose a changed helper inventory and derive an optimistic exact moment.",
+      "Design a small completed instance and independently verify its endpoint and rank bill."
+    ],
+    "overlap_terms": [
+      "helper inventory",
+      "heterogeneous-owner",
+      "mutable leaver"
+    ],
+    "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?",
+    "scope_change_triggers": [
+      "Mixing only providers already inside the pinned catalogue.",
+      "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.",
+      "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts."
+    ],
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "research/complex-local-word-ceiling/README.md",
+      "research/heterogeneous-owner-assembly/README.md",
+      "certificates/selected-result.json",
+      "research/selected-k8-unrestricted-ends/README.md"
+    ]
+  },
+  "outcome": "negative-result",
+  "priority_revision": 7,
+  "schema_version": 1,
+  "scope_change_reason": "The broad inventory question is narrowed to independent verification of one exact nearest-contact prerequisite. Its absence stops this proposed occurrence, without a changed inventory or supplier.",
+  "scope_key": "pr5678-fixed-nearest144-beforeY15473-R14893-source-af814f6",
+  "scope_status": "changed",
+  "stop_rule": "Stop this exact nomination; no earlier pair, role 317/530, alternate sign/chart/window or wider scan follows. A changed question needs a fresh source/ownership nomination.",
+  "task_id": "complex-new-helper-inventory"
+}
diff --git a/research/p104-nearest-contact-verification/VERIFY.json b/research/p104-nearest-contact-verification/VERIFY.json
new file mode 100644
index 0000000000..30757f4130
--- /dev/null
+++ b/research/p104-nearest-contact-verification/VERIFY.json
@@ -0,0 +1,30 @@
+{
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "checks": "Authenticate public committed payloads and one-line ROOT adaptation; execute the core once; require entire original result SHA256, exact nearest contacts and strict pre-corridor stop, nine original negative controls, exact positive semantic/algebra control and two integrity controls; no candidate or kappa.",
+      "timeout_seconds": 60
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "-O",
+        "{package}/verify.py"
+      ],
+      "checks": "Authenticate public committed payloads and one-line ROOT adaptation; execute the core once; require entire original result SHA256, exact nearest contacts and strict pre-corridor stop, nine original negative controls, exact positive semantic/algebra control and two integrity controls; no candidate or kappa.",
+      "timeout_seconds": 60
+    }
+  ],
+  "inputs": [],
+  "python": "3.12",
+  "requirements": [],
+  "schema_version": 1,
+  "status": "ready"
+}
diff --git a/research/p104-nearest-contact-verification/check.py b/research/p104-nearest-contact-verification/check.py
new file mode 100644
index 0000000000..00cc17b751
--- /dev/null
+++ b/research/p104-nearest-contact-verification/check.py
@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+"""One fixed PR5678 nearest-contact prerequisite; root-only bounded execution.
+
+Apache-2.0. Credit Ali Romman and retained P104/source/native/caller/compiler
+contributors; classical compensated-update identity; OpenAI Codex assistance.
+No source imports, constructor, changed full word, numeric powers or pricing.
+"""
+from collections import Counter
+from fractions import Fraction as Q
+import gzip
+import hashlib
+import io
+import json
+from pathlib import Path
+import sys
+
+HERE=Path(__file__).resolve().parent
+ROOT=HERE
+HEAD='af814f6f3c477fdd13b8f04380a33cf32004966b'
+WORD_SHA='b56281a67f84832198be2f2ad36d87b75244d424f1e0a6f4dda2df74f20cc08d'
+WORD_BLOB='8be2b3e1c2d02034d4579bef5d36df7761d826ff'
+LIMIT=16*1024*1024
+ENTRY=['ADD',438,733,'-4',794]
+R=['ADD',140,438,'-1/2',794]
+SPECTATOR=['ADD',160,451,'-1/2',911]
+Y=['ADD',144,438,'-1/2',911]
+EXIT=['ADD',438,733,'4',127]
+P_PREFIX=['ADD',144,140,'1']
+Q_PREFIX=['ADD',144,140,'-1']
+
+class SourceError(ValueError):pass
+
+
+def need(ok,message):
+    if not ok:raise SourceError(message)
+
+
+def sha(raw):return hashlib.sha256(raw).hexdigest()
+def blob(raw):return hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()
+def canonical(value):return json.dumps(value,sort_keys=True,separators=(',',':')).encode()
+def shown(h):return {str(r):n for r,n in sorted(h.items()) if n}
+def mass(h):return sum(r*n for r,n in h.items())
+def clean(h):return {r:n for r,n in h.items() if n}
+def isint(x):return type(x) is int
+
+
+def authenticate_word(raw,pin):
+    need(pin['head']==HEAD and pin['bytes']==120135 and pin['sha256']==WORD_SHA and pin['git_blob']==WORD_BLOB,
+         'Exact fixed source binding')
+    need(len(raw)==120135 and sha(raw)==WORD_SHA and blob(raw)==WORD_BLOB,'Compressed WORD byte/Git/SHA identity before decode')
+
+
+def integer_token(s):
+    need(len(s)<=11,'Bounded JSON integer token')
+    n=int(s);need(abs(n)<=2**31-1,'Bounded JSON integer value');return n
+
+
+def pairs_unique(pairs):
+    out={}
+    for k,v in pairs:
+        need(k not in out,'Duplicate JSON descriptor key');out[k]=v
+    return out
+
+
+def bad_constant(s):raise SourceError('Unexpected JSON numeric constant '+s)
+
+
+def read_capped(stream,limit):
+    decoded=stream.read(limit+1)
+    need(len(decoded)<=limit,'Decompressed WORD exceeds hard abort cap')
+    need(stream.read(1)==b'','Decompressed WORD has excess data')
+    return decoded
+
+
+def decode(raw,pin):
+    authenticate_word(raw,pin)
+    with gzip.GzipFile(fileobj=io.BytesIO(raw),mode='rb') as stream:
+        decoded=read_capped(stream,LIMIT)
+    word=json.loads(decoded,object_pairs_hook=pairs_unique,parse_int=integer_token,parse_constant=bad_constant)
+    stack=[(word,0)];nodes=0
+    while stack:
+        x,depth=stack.pop();nodes+=1
+        need(nodes<=500000 and depth<=16,'Descriptor node/depth cap')
+        if isinstance(x,dict):
+            need(len(x)<=64 and all(isinstance(k,str) and len(k)<=128 for k in x),'Descriptor field cap')
+            stack.extend((v,depth+1) for v in x.values())
+        elif isinstance(x,list):
+            need(len(x)<=26000,'Descriptor array cap');stack.extend((v,depth+1) for v in x)
+        elif isinstance(x,str):need(len(x)<=4096,'Descriptor string cap')
+        elif isinstance(x,float):need(x==x and abs(x)!=float('inf'),'Finite unused metadata number')
+        else:need(x is None or type(x) in (int,bool),'Unexpected descriptor value')
+    return word,len(decoded),sha(decoded)
+
+
+def reduced_basis(vectors):
+    pivots={}
+    for v in vectors:
+        need(isint(v) and 0<v<512,'Nine-axis binary frame vector')
+        x=v
+        for p,b in sorted(pivots.items(),reverse=True):
+            if x&(1<<p):x^=b
+        need(x!=0,'Independent frame basis')
+        pivots[x.bit_length()-1]=x
+    return sorted(pivots.items(),reverse=True)
+
+
+def included(a,b):
+    for _,v in a:
+        x=v
+        for p,w in b:
+            if x&(1<<p):x^=w
+        if x:return False
+    return True
+
+
+def strict(a,b):return len(a)<len(b) and included(a,b)
+
+
+def roles(e):return set(e[1:3]) if e[0] in ('ADD','COPY') else {e[1]}
+def access(e,r):
+    out=[]
+    if e[0] in ('ADD','COPY'):
+        if e[2]==r:out.append('read')
+        if e[1]==r:out.append('write')
+    elif e[0]=='SCALE' and e[1]==r:out=['read','write']
+    return out
+
+def grammar(e,n,owned,frame_count):
+    need(isinstance(e,list) and e and isinstance(e[0],str),'Instruction record')
+    op=e[0];width={'ADD':5,'COPY':5,'SCALE':4,'MOVE':5,'INIT':3,'CLEAR':3}
+    need(op in width and len(e)==width[op],'Known opcode and exact fail-closed width')
+    need(isint(e[1]) and 0<=e[1]<n+owned,'Destination role')
+    def frame(f):need(isint(f) and 0<=f<frame_count,'Frame index')
+    if op=='MOVE':
+        frame(e[2]);frame(e[3]);need(type(e[4]) is bool,'MOVE ownership flag')
+    elif op in ('INIT','CLEAR'):
+        need(e[1]>=n,'Public lifetime operation is unsupported/source failure');frame(e[2])
+    else:
+        frame(e[-1]);need(isinstance(e[-2],str) and len(e[-2])<=128,'Bounded exact scalar coefficient')
+        q=Q(e[-2]);need(q and q.numerator.bit_length()<=256 and q.denominator.bit_length()<=256 and
+            q.denominator&(q.denominator-1)==0 and abs(q)+1<2**16,'Bounded nonzero dyadic scalar')
+        if op=='SCALE':need(abs(q.numerator)&(abs(q.numerator)-1)==0,'Dyadic unit SCALE')
+        else:
+            need(isint(e[2]) and 0<=e[2]<n+owned and e[1]!=e[2],'Distinct valid scalar source')
+            if op=='COPY':need(e[1]>=n,'Public COPY is not the declared grammar')
+
+
+def validate(word,receipt):
+    need(isinstance(word,dict) and word.get('schema')=='p104-paid-interior-bases/1','Exact emitted source schema')
+    n,owned=word.get('public'),word.get('owned_fields')
+    need(n==743 and isint(n) and owned==9 and isint(owned),'Retained public/owned counts')
+    frames=word.get('frames');need(isinstance(frames,list) and 912<=len(frames)<=4096,'Bounded frame table')
+    need(all(isinstance(b,list) and len(b)<=9 for b in frames),'Nine-axis frame cap')
+    spaces=[reduced_basis(b) for b in frames]
+    need([len(spaces[f]) for f in (794,911,127)]==[6,7,9] and strict(spaces[794],spaces[911]) and strict(spaces[911],spaces[127]),'Published high-pair ordered strict frame chain')
+    for name in ('initial','final'):
+        need(isinstance(word.get(name),list) and len(word[name])==n and all(isint(f) and 0<=f<len(frames) for f in word[name]),'Complete public boundary descriptor')
+    live=word.get('live');need(isinstance(live,list) and len(live)==104 and all(isint(r) and 0<=r<n and r+112<n for r in live) and len(set(live))==104,'104 distinct live roles')
+    main=set(live)|{r+112 for r in live};need(len(main)==208,'Main role convention')
+    helper=Counter()
+    for r in range(n):
+        if r not in main:
+            a,b=word['initial'][r],word['final'][r];need(strict(spaces[a],spaces[b]),'Helper productive boundary')
+            helper[len(spaces[b])-len(spaces[a])]+=1
+    need(shown(helper)==receipt['local']['helpers'] and receipt['local']['public_inputs']==n and receipt['local']['owned_fields']==owned,'Authenticated source descriptor/target receipt')
+    program=word.get('program');need(isinstance(program,list) and 0<len(program)<=26000,'Hard instruction cap')
+    current=word['initial'][:]+[None]*owned;zero=[None]*owned;life=peak=0;semantic=[];protected=[]
+    for i,e in enumerate(program):
+        grammar(e,n,owned,len(frames));op,r=e[:2]
+        if r>=n or (op in ('ADD','COPY') and e[2]>=n):protected.append(e)
+        if op=='MOVE':
+            need(current[r]==e[2] and e[4] is (r>=n),'Exact MOVE source/ownership chronology')
+            need(strict(spaces[e[3]],spaces[e[2]]) if r>=n else strict(spaces[e[2]],spaces[e[3]]),'Typed old MOVE nesting')
+            current[r]=e[3];continue
+        semantic.append({'event':i,'instruction':e})
+        if op=='INIT':
+            need(current[r] is None,'Fresh owned lifetime');current[r]=e[2];zero[r-n]=True;life+=1
+            peak=max(peak,sum(f is not None for f in current[n:]))
+        elif op=='CLEAR':
+            need(current[r]==e[2] and zero[r-n] is not None,'Active owned CLEAR chart');current[r]=None;zero[r-n]=None
+        else:
+            need(all(current[a]==e[-1] for a in roles(e)),'Every scalar operand has its declared actual common chart')
+            if op=='COPY':
+                need(zero[r-n] is True,'COPY destination proven zero by conservative lifetime bookkeeping')
+                zero[r-n]=zero[e[2]-n] if e[2]>=n else False
+            elif op=='ADD' and r>=n:
+                if e[2]<n or zero[e[2]-n] is not True:zero[r-n]=False
+            # Nonzero SCALE preserves the conservative zero flag.
+    need(current[:n]==word['final'] and all(f is None for f in current[n:]),'All source public/owned exits')
+    need(life==receipt['local']['owned_lifetimes']==11 and peak==receipt['local']['peak_owned_fields']==2,'Owned lifetime/peak counts')
+    return spaces,program,semantic,{'public_inputs':n,'helpers':535,'owned_fields':owned,'owned_lifetimes':life,'peak_owned_fields':peak,
+      'protected_subsequence_sha256':sha(canonical(protected)),
+      'boundary_descriptor_sha256':sha(canonical({k:word[k] for k in ('public','owned_fields','initial','final','live')})),
+      'scope':'Chart/lifetime descriptors only; no endpoint rows, owned erasure-zero, native phases or physical caller admission.'}
+
+
+def unique(items,label):
+    need(len(items)==1,'Unique '+label+' context required');return items[0]
+
+
+def bind(semantic):
+    es=[x['instruction'] for x in semantic]
+    start=unique([i for i in range(len(es)-1) if es[i:i+2]==[ENTRY,R]],'entry/R')
+    end=unique([i for i in range(len(es)-2) if es[i:i+3]==[SPECTATOR,Y,EXIT]],'spectator/Y/exit')
+    bound={'entry':semantic[start],'R':semantic[start+1],'spectator':semantic[end],'Y':semantic[end+1],'exit':semantic[end+2]}
+    need(bound['entry']['event']<bound['R']['event']<bound['spectator']['event']<bound['Y']['event']<bound['exit']['event'],'Ordered published fixed contexts')
+    return bound
+
+
+def contact(row,r):
+    return {'event':row['event'],'instruction':row['instruction'],'access':access(row['instruction'],r)}
+
+
+def predicate(semantic,bound):
+    ri,yi=bound['R']['event'],bound['Y']['event']
+    previous=[contact(x,144) for x in semantic if x['event']<yi and 144 in roles(x['instruction'])]
+    nearest=previous[-2:]
+    answer={'nearest_144_contacts':nearest,'certified_R':bound['R'],'certified_Y':bound['Y']}
+    if len(nearest)!=2 or nearest[0]['instruction'][:4]!=P_PREFIX or nearest[1]['instruction'][:4]!=Q_PREFIX:
+        return dict(answer,status='NEAREST_MISMATCH',reason='The fixed two immediately preceding semantic contacts do not equal the nominated P/Q opcode, roles and signs.')
+    p,q=nearest;pi,qi=p['event'],q['event']
+    if not pi<ri<qi<yi:return dict(answer,status='CORRIDOR_MISMATCH',reason='The actual order is not P<R<Q<Y.')
+    observers=[contact(x,144) for x in semantic if pi<=x['event']<=yi and 144 in roles(x['instruction'])]
+    if [x['event'] for x in observers]!=[pi,qi,yi]:return dict(answer,status='CORRIDOR_MISMATCH',reason='An additional receiver observer exists.',observers=observers)
+    writes=[contact(x,140) for x in semantic if pi<x['event']<qi and 'write' in access(x['instruction'],140)]
+    if [x['event'] for x in writes]!=[ri]:return dict(answer,status='CORRIDOR_MISMATCH',reason='R is not the sole logical 140 write between P and Q.',writes_140=writes)
+    changed=[contact(x,438) for x in semantic if ri<x['event']<yi and 'write' in access(x['instruction'],438)]
+    if changed:return dict(answer,status='CORRIDOR_MISMATCH',reason='438 has another logical write between R and Y.',writes_438=changed)
+    return dict(answer,status='MATCH',P=p,Q=q,observers_144=observers,writes_140=writes,writes_438=changed,
+                retained_other_140_reads=[contact(x,140) for x in semantic if pi<x['event']<yi and 'read' in access(x['instruction'],140) and x['event'] not in (pi,qi)])
+
+
+def semantics(events):return [{'event':i,'instruction':e} for i,e in enumerate(events) if e[0]!='MOVE']
+
+def rejected(action):
+    try:action()
+    except (SourceError,ValueError,KeyError):return 'rejected'
+    raise SourceError('A bounded control unexpectedly accepted')
+
+
+def control_suite(raw,pin):
+    valid=[['ADD',144,140,'1',794],ENTRY,R,['ADD',144,140,'-1',911],SPECTATOR,Y,EXIT]
+    def status(events):
+        sem=semantics(events);return predicate(sem,bind(sem))['status']
+    def require_match(events):need(status(events)=='MATCH','Synthetic conditional predicate')
+    positive=status(valid);need(positive=='MATCH','Exact valid synthetic conditional pattern')
+    # Independent three-row exact algebra for P,R,Q,Y, not a source lookup.
+    rows={140:[Q(1),Q(0),Q(0)],144:[Q(0),Q(1),Q(0)],438:[Q(0),Q(0),Q(1)]}
+    for e in [valid[0],R,valid[3],Y]:rows[e[1]]=[a+Q(e[3])*b for a,b in zip(rows[e[1]],rows[e[2]])]
+    need(rows[144]==[0,1,0] and rows[140]==[1,0,Q(-1,2)] and rows[438]==[0,0,1],'Exact synthetic arbitrary-input identity')
+    sign=[e[:] for e in valid];sign[3][3]='1'
+    role=[e[:] for e in valid];role[3][2]=141
+    observer=valid[:4]+[['COPY',743,144,'1',911]]+valid[4:]
+    write=valid[:3]+[['ADD',140,451,'1',794]]+valid[3:]
+    hwrite=valid[:3]+[['ADD',438,451,'1',794]]+valid[3:]
+    return {
+      'compressed_corruption_before_decode':rejected(lambda:authenticate_word(raw[:-1]+bytes([raw[-1]^1]),pin)),
+      'nearest_sign':rejected(lambda:require_match(sign)),
+      'nearest_role':rejected(lambda:require_match(role)),
+      'additional_owned_COPY_source_observer':rejected(lambda:require_match(observer)),
+      'additional_140_write':rejected(lambda:require_match(write)),
+      'additional_438_write':rejected(lambda:require_match(hwrite)),
+      'nonunique_anchor_context':rejected(lambda:bind(semantics(valid+[ENTRY,R]))),
+      'unexpected_opcode':rejected(lambda:grammar(['OBSERVE',144,911],743,9,4096)),
+      'decompression_abort_cap':rejected(lambda:read_capped(io.BytesIO(b'ab'),1)),
+      'valid_synthetic_conditional_pattern':{'outcome':'accepted','exact_identity':True,
+       'scope':'Pure semantic/algebra unit case, not an actual typed source/native program.'}}
+
+
+def route(word,program,semantic,r,spaces,deleted):
+    all_contacts=[dict(contact(x,r),frame=x['instruction'][-1]) for x in semantic if r in roles(x['instruction'])]
+    kept=[x for x in all_contacts if x['event'] not in deleted]
+    def path(cs):
+        required=[{'kind':'input','frame':word['initial'][r]}]+cs+[{'kind':'final','frame':word['final'][r]}]
+        visits=[]
+        for c in required:
+            if not visits or visits[-1]!=c['frame']:visits.append(c['frame'])
+        edges=[]
+        for a,b in zip(visits,visits[1:]):
+            need(strict(spaces[a],spaces[b]),'Direct required path is strictly increasing; no repair/intermediate search')
+            edges.append({'old':a,'new':b,'rank':len(spaces[b])-len(spaces[a])})
+        return {'required':required,'coalesced_frames':visits,'edges':edges,'histogram':shown(Counter(e['rank'] for e in edges))}
+    old,new=path(all_contacts),path(kept)
+    actual=[{'old':e[2],'new':e[3],'rank':len(spaces[e[3]])-len(spaces[e[2]])} for e in program if e[0]=='MOVE' and e[1]==r]
+    need(old['edges']==actual,'Complete old required-contact path equals every actual source MOVE for affected role')
+    old_h={int(k):v for k,v in old['histogram'].items()};new_h={int(k):v for k,v in new['histogram'].items()}
+    delta=Counter(new_h);delta.subtract(old_h)
+    return {'old':old,'new_contact_subchain':new,'actual_old_MOVE_chain':actual,'signed_local_delta':shown(delta)},set(old['coalesced_frames'])|set(new['coalesced_frames'])
+
+
+def main():
+    inputs=json.loads((HERE/'INPUTS.json').read_bytes())
+    for name,digest in inputs['files'].items():need(sha((ROOT/name).read_bytes())==digest,'Frozen input SHA '+name)
+    for name,digest in inputs['git_blobs'].items():need(blob((ROOT/name).read_bytes())==digest,'Published input Git blob '+name)
+    pin=json.loads((ROOT/inputs['word_custody']).read_bytes());raw=(ROOT/inputs['word']).read_bytes();authenticate_word(raw,pin)
+    nomination=json.loads((HERE/'NOMINATION.json').read_bytes())
+    need(nomination['source']['head']==HEAD and nomination['fixed_anchors']['R']['instruction']==R and nomination['fixed_anchors']['Y']['instruction']==Y and
+         nomination['missing_anchors']['P']['required_prefix']==P_PREFIX and nomination['missing_anchors']['Q']['required_prefix']==Q_PREFIX,'One fixed nomination binding')
+    witness=json.loads((ROOT/inputs['witness']).read_bytes());high=witness[0]
+    need((high['a'],high['b'],high['coefficient'],high['entry_frame'],high['exit_frame'])==(438,733,'-4',794,127) and
+         high['blocks'][0]['after']==[R] and high['blocks'][1]['after']==[SPECTATOR,Y] and high['start_block']==1090 and high['end_block']==1314,'Published source witness context; stage identifiers are provenance only')
+    controls=control_suite(raw,pin)
+    word,length,digest=decode(raw,pin);receipt=json.loads((ROOT/inputs['source_result']).read_bytes())
+    spaces,program,sem,desc=validate(word,receipt);bound=bind(sem);answer=predicate(sem,bound)
+    output={'schema':'pr5678-fixed-nearest-contact-prerequisite/v1','source_head':HEAD,'source_word_sha256':WORD_SHA,'source_word_git_blob':WORD_BLOB,
+      'decompressed_hard_cap':LIMIT,'decompressed_bytes_observed':length,'decompressed_source_sha256':digest,'instruction_count':len(program),
+      'source_descriptor_checks':desc,'unique_published_context':bound,'nearest_predicate':answer,'controls':controls,
+      'stage_indices_used_as_final_indices':False,'logical_observer_rule':'All ADD/COPY source reads and destination writes, SCALE reads+writes; owned interfaces included. MOVE excluded only from logical observation under the declared source invariant.',
+      'physical_native_limitation':'MOVE charts and lifetime descriptors are checked on the source. Excluding transport from logical observers is not native/global-phase/caller equivalence for a changed word.',
+      'changed_full_word_emitted':False,'source_modules_imported':False,'pricing_or_numeric_powers_evaluated':False,'new_kappa':None,'candidate_paid_invoice':None,
+      'fallback_search':False,'other_contact_pairs_queried':False,'native_admission':False,'endpoint_admission':False,'ordinary_or_compiler_admission':False}
+    if answer['status']=='NEAREST_MISMATCH':
+        output.update(status='COMPLETED_FIXED_NEAREST_CONTACT_FALSIFIER',stop_reason=answer['reason'],complete_affected_route_extraction_performed=False)
+        return output
+    if answer['status']!='MATCH':
+        output.update(status='COMPLETED_FIXED_CONTACT_PREDICATE_FALSIFIER',stop_reason=answer['reason'],complete_affected_route_extraction_performed=False)
+        return output
+    deleted={answer['P']['event'],answer['Q']['event'],bound['Y']['event']}
+    need(all(e['instruction'][0]=='ADD' and max(e['instruction'][1:3])<743 for e in [answer['P'],answer['Q'],bound['Y']]),'Only three public ADD contact deletions')
+    routes={};frames=set();total=Counter()
+    for r in (140,144,438):
+        row,used=route(word,program,sem,r,spaces,deleted);routes[str(r)]=row;frames|=used
+        total.update({int(k):n for k,n in row['signed_local_delta'].items()})
+    need(sum(r*n for r,n in total.items())==0,'Endpoint-fixed path deletion preserves rank mass')
+    output.update(status='COMPLETED_FIXED_NEAREST_CONTACT_CONDITIONAL_PACKET',stop_reason='The one logical prerequisite matches; contact-subchain/rank packet only. Separate full native/caller/ordinary/funding validation is required.',
+      complete_affected_route_extraction_performed=True,deleted_public_scalar_contact_indices=sorted(deleted),affected_role_routes=routes,
+      ordered_frame_bases={str(f):word['frames'][f] for f in sorted(frames)},signed_affected_local_rank_histogram=shown(total),
+      symbolic_cost='sum_r delta_r H_r(C), H_r(C)=r^(1-C); no powers or prices evaluated.',
+      retained_other_140_reads=answer['retained_other_140_reads'],conditional_target_delta=0,
+      target_transfer_status='Conditional only; original independent input/endpoints/targets/protected owned sequence and full caller must be realized and verified later.')
+    return output
+
+
+if __name__=='__main__':
+    try:output=main();code=0
+    except Exception as error:
+        output={'schema':'pr5678-fixed-nearest-contact-prerequisite/v1','status':'SOURCE_OR_BINDING_FAILURE',
+          'failure':type(error).__name__+': '+str(error),'new_kappa':None,'changed_full_word_emitted':False,
+          'source_modules_imported':False,'pricing_or_numeric_powers_evaluated':False,'fallback_search':False};code=2
+    print(json.dumps(output,sort_keys=True,separators=(',',':')));sys.exit(code)
diff --git a/research/p104-nearest-contact-verification/evidence/CORE-ADAPTATION.diff b/research/p104-nearest-contact-verification/evidence/CORE-ADAPTATION.diff
new file mode 100644
index 0000000000..07cb94bf04
--- /dev/null
+++ b/research/p104-nearest-contact-verification/evidence/CORE-ADAPTATION.diff
@@ -0,0 +1,11 @@
+--- original/check.py
++++ portable/check.py
+@@ -15,7 +15,7 @@
+ import sys
+ 
+ HERE=Path(__file__).resolve().parent
+-ROOT=HERE.parents[2]
++ROOT=HERE
+ HEAD='af814f6f3c477fdd13b8f04380a33cf32004966b'
+ WORD_SHA='b56281a67f84832198be2f2ad36d87b75244d424f1e0a6f4dda2df74f20cc08d'
+ WORD_BLOB='8be2b3e1c2d02034d4579bef5d36df7761d826ff'
diff --git a/research/p104-nearest-contact-verification/evidence/ORIGINAL-EXECUTION.json b/research/p104-nearest-contact-verification/evidence/ORIGINAL-EXECUTION.json
new file mode 100644
index 0000000000..2e8be9ff55
--- /dev/null
+++ b/research/p104-nearest-contact-verification/evidence/ORIGINAL-EXECUTION.json
@@ -0,0 +1,40 @@
+{
+  "all_immutable_bytes_modes_and_independent_approval_unchanged": true,
+  "guard": {
+    "elapsed_seconds": 1.0066231779928785,
+    "exit_code": 0,
+    "log_sha256": "11206a9197ce49df849fe139ec890c2c0895a4dee78224185971d6836e2a0829",
+    "memory_limit_mib": 512,
+    "rss_samples": 10,
+    "sampled_peak_descendant_rss_bytes": 52416512,
+    "termination": null,
+    "timeout_seconds": 150.0
+  },
+  "immutable_file_count_including_request": 26,
+  "modes": [
+    {
+      "exit_code": 0,
+      "mode": "normal",
+      "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "stdout_sha256": "18dac3a5092667ab5f5118ed6e953d65d558a8d11066e95cc728a069ec01f50f",
+      "timeout_seconds": 60
+    },
+    {
+      "exit_code": 0,
+      "mode": "optimized",
+      "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "stdout_sha256": "18dac3a5092667ab5f5118ed6e953d65d558a8d11066e95cc728a069ec01f50f",
+      "timeout_seconds": 60
+    }
+  ],
+  "original_guard_receipt_sha256": "ae69b5fef1c9b9b306acc6d2676987e1b4c6221c04afcb7c727e8bd3c6fbf328",
+  "original_pair_receipt_sha256": "c9744a9ddb011aba71088db8dd65e71a23ae1a5e5384be07102e25c6c20357e8",
+  "original_root_post_sha256": "f0ba392e518756bd1af4657443932a2d657e27c8051d8dda597d624b20df4f52",
+  "pair_elapsed_seconds": 0.9324073549942113,
+  "pair_status": "COMPLETED_IDENTICAL_PAIR",
+  "request_sha256": "31af46d73942c9dc1c16369d0d473b3afb194365df2e1baa54f78885394de2a1",
+  "result_sha256": "18dac3a5092667ab5f5118ed6e953d65d558a8d11066e95cc728a069ec01f50f",
+  "sanitization": "Absolute commands, cwd, human/plan fields and interpreter metadata omitted; this extract is not an original receipt byte string.",
+  "schema": "public-pr5678-execution-extract/v1",
+  "scientific_status": "COMPLETED_FIXED_NEAREST_CONTACT_FALSIFIER"
+}
diff --git a/research/p104-nearest-contact-verification/evidence/ORIGINAL-REQUEST.json b/research/p104-nearest-contact-verification/evidence/ORIGINAL-REQUEST.json
new file mode 100644
index 0000000000..d79aef173c
--- /dev/null
+++ b/research/p104-nearest-contact-verification/evidence/ORIGINAL-REQUEST.json
@@ -0,0 +1,66 @@
+{
+  "fixed_public_semantic_parameters": {
+    "fixed_anchors": {
+      "R": {
+        "instruction": [
+          "ADD",
+          140,
+          438,
+          "-1/2",
+          794
+        ]
+      },
+      "Y": {
+        "instruction": [
+          "ADD",
+          144,
+          438,
+          "-1/2",
+          911
+        ]
+      }
+    },
+    "missing_anchors": {
+      "P": {
+        "required_prefix": [
+          "ADD",
+          144,
+          140,
+          "1"
+        ]
+      },
+      "Q": {
+        "required_prefix": [
+          "ADD",
+          144,
+          140,
+          "-1"
+        ]
+      }
+    },
+    "source": {
+      "head": "af814f6f3c477fdd13b8f04380a33cf32004966b"
+    }
+  },
+  "original_checker_sha256": "2c747e340f4818a1064608323a877d693b5885bd58a1774e9b82315033649525",
+  "original_contract_sha256": "4cef230331ec8e1a78ab8402ffc9fd6702bb06361073465f61c7031a5ec5691e",
+  "original_inputs_sha256": "c2d933fb0bc24774b9714ee8ea0802b35e6d82dc7c9524350213d2ca4a08070a",
+  "original_request_sha256": "31af46d73942c9dc1c16369d0d473b3afb194365df2e1baa54f78885394de2a1",
+  "original_wrapper_sha256": "0b40b01c7ac74773685ad9ae746b4fde0561c11af71b995c584766639867eaf9",
+  "resource_contract": {
+    "child_seconds": 60,
+    "memory_mib": 512,
+    "retries": 0,
+    "serial": true,
+    "total_seconds": 150
+  },
+  "sanitization": "Public scientific fields only; not original request bytes. Local paths, human prompts and unrelated planning omitted.",
+  "schema": "public-pr5678-scientific-request-extract/v1",
+  "scope": "Exactly the two immediately preceding complete semantic contacts of 144 before uniquely bound Y. Stop at mismatch with no farther pair or corridor/route/price lookup.",
+  "source_word": {
+    "bytes": 120135,
+    "git_blob": "8be2b3e1c2d02034d4579bef5d36df7761d826ff",
+    "head": "af814f6f3c477fdd13b8f04380a33cf32004966b",
+    "sha256": "b56281a67f84832198be2f2ad36d87b75244d424f1e0a6f4dda2df74f20cc08d"
+  }
+}
diff --git a/research/p104-nearest-contact-verification/evidence/POST-REVIEW.json b/research/p104-nearest-contact-verification/evidence/POST-REVIEW.json
new file mode 100644
index 0000000000..5d520fabde
--- /dev/null
+++ b/research/p104-nearest-contact-verification/evidence/POST-REVIEW.json
@@ -0,0 +1,71 @@
+{
+  "candidate_paid_invoice": null,
+  "checks": {
+    "approval_hash_mode_unchanged": true,
+    "both_exit_zero_empty_stderr": true,
+    "complete_mode_output_bytes_equal": true,
+    "current_rootpre_file_hash_mode_pairs_checked": 26,
+    "file_pin_mismatches": 0,
+    "negative_controls_rejected": 9,
+    "positive_exact_synthetic_accepted": true,
+    "raw_guard_matches_rootpost": true,
+    "rootpre_grant_hash_link_matches": true,
+    "wrapper_before_after_immutable_hash_equal": true
+  },
+  "complete_affected_route_extraction_performed": false,
+  "complete_result_sha256": "18dac3a5092667ab5f5118ed6e953d65d558a8d11066e95cc728a069ec01f50f",
+  "decision": "ACCEPT_COMPLETED_SCOPED_NEAREST_CONTACT_FALSIFIER",
+  "global_novelty_or_obstruction": false,
+  "interpretation": "The exact two-nearest140 plus/minus pair is absent; actual nearest contacts both precedeR. Not a counterexample to the conditional identity or a whole-word obstruction.",
+  "native_endpoint_ordinary_caller_or_funding_admission": false,
+  "nearest_144_contacts": [
+    {
+      "event": 13344,
+      "instruction": [
+        "ADD",
+        144,
+        317,
+        "1",
+        356
+      ]
+    },
+    {
+      "event": 13463,
+      "instruction": [
+        "ADD",
+        144,
+        530,
+        "1",
+        1035
+      ]
+    }
+  ],
+  "new_kappa": null,
+  "original_sha256": "98ef0038c1ae382188535a8c96c1964ae91cf88f60c8368676a38cc921e38331",
+  "prices_powers_or_new_word": false,
+  "prior_222435_shear_189_relocation_exact_coverage": "UNKNOWN",
+  "publication_recommendation": "Keep as reproducible stopped-nomination checkpoint by default; standalone PR value not established. Separate owner-safe distinct-verification gate required before any note or package.",
+  "request_sha256": "31af46d73942c9dc1c16369d0d473b3afb194365df2e1baa54f78885394de2a1",
+  "reviewer_word_decode_parse_import_compile_scientific_execution_numeric_power_or_git_mutation": false,
+  "root_resources": {
+    "child_seconds": 60,
+    "elapsed_seconds": 1.0066231779928785,
+    "guard_exit": 0,
+    "memory_mib_limit": 512,
+    "sampled_peak_descendant_rss_bytes": 52416512,
+    "seconds_limit": 150,
+    "termination": null
+  },
+  "sanitization": "Selected public scientific review fields; no root plans, paths or follow-up authority. Not the original review byte string.",
+  "schema": "independent-saved-pr5678-nearest-result-review/v1",
+  "scientific_status": "COMPLETED_FIXED_NEAREST_CONTACT_FALSIFIER",
+  "source_corridor_queries_reached": false,
+  "source_head": "af814f6f3c477fdd13b8f04380a33cf32004966b",
+  "unique_context_indices": {
+    "R": 14893,
+    "Y": 15473,
+    "entry": 14891,
+    "exit": 15476,
+    "spectator": 15470
+  }
+}
diff --git a/research/p104-nearest-contact-verification/evidence/PUBLICATION-CONTEXT.json b/research/p104-nearest-contact-verification/evidence/PUBLICATION-CONTEXT.json
new file mode 100644
index 0000000000..bf5b10485d
--- /dev/null
+++ b/research/p104-nearest-contact-verification/evidence/PUBLICATION-CONTEXT.json
@@ -0,0 +1,20 @@
+{
+  "decision": "CLEAR_FOCUSED_INDEPENDENT_FIXED_PREDICATE_VERIFICATION_CERTIFICATE",
+  "fresh_base": "df0137efd35e11b4445734bf612bdd4c7ebc330c",
+  "neighboring_discussions": [
+    "https://github.com/CrocSwap/integer-mult-bounds/discussions/5125",
+    "https://github.com/CrocSwap/integer-mult-bounds/discussions/5645"
+  ],
+  "novelty_limit": "No matching public exact certificate observed in bounded review; no global novelty claim.",
+  "post_review_value_caveat": "Default stopped-nomination checkpoint recommendation retained; separate publication-value gate and root decision precede publication.",
+  "prior_released_screens": {
+    "absorbed_shear_placements": 222435,
+    "credit": "Ali Romman; released local screening evidence, not universal or independently replayed negative certificates.",
+    "exact_predicate_coverage": "UNKNOWN",
+    "whole_block_relocations": 189
+  },
+  "publication_value_gate_sha256": "899351e41e5b0d64b863500295ed57bbe3bc5e6d9bbb9e118a83f09017294fcd",
+  "scientific_replay_by_curator": false,
+  "source_gate_custody_sha256": "7eb9005c8a050967ad9246a15f7323ca9db7a69468d50ddf7fda433f9687472f",
+  "value": "Inspectably bound source, unique final contexts, exhaustive nearest semantic-contact definition and exact stopped result with portable independent replay. No new identity or global negative claim."
+}
diff --git a/research/p104-nearest-contact-verification/evidence/RESULT-normal.json b/research/p104-nearest-contact-verification/evidence/RESULT-normal.json
new file mode 100644
index 0000000000..6fce947b10
--- /dev/null
+++ b/research/p104-nearest-contact-verification/evidence/RESULT-normal.json
@@ -0,0 +1 @@
+{"candidate_paid_invoice":null,"changed_full_word_emitted":false,"complete_affected_route_extraction_performed":false,"controls":{"additional_140_write":"rejected","additional_438_write":"rejected","additional_owned_COPY_source_observer":"rejected","compressed_corruption_before_decode":"rejected","decompression_abort_cap":"rejected","nearest_role":"rejected","nearest_sign":"rejected","nonunique_anchor_context":"rejected","unexpected_opcode":"rejected","valid_synthetic_conditional_pattern":{"exact_identity":true,"outcome":"accepted","scope":"Pure semantic/algebra unit case, not an actual typed source/native program."}},"decompressed_bytes_observed":1844210,"decompressed_hard_cap":16777216,"decompressed_source_sha256":"8bd10c59f346fbd427afbfd5d88b1f8ce9d633151faf51cd41a058b4f4e576a3","endpoint_admission":false,"fallback_search":false,"instruction_count":25453,"logical_observer_rule":"All ADD/COPY source reads and destination writes, SCALE reads+writes; owned interfaces included. MOVE excluded only from logical observation under the declared source invariant.","native_admission":false,"nearest_predicate":{"certified_R":{"event":14893,"instruction":["ADD",140,438,"-1/2",794]},"certified_Y":{"event":15473,"instruction":["ADD",144,438,"-1/2",911]},"nearest_144_contacts":[{"access":["write"],"event":13344,"instruction":["ADD",144,317,"1",356]},{"access":["write"],"event":13463,"instruction":["ADD",144,530,"1",1035]}],"reason":"The fixed two immediately preceding semantic contacts do not equal the nominated P/Q opcode, roles and signs.","status":"NEAREST_MISMATCH"},"new_kappa":null,"ordinary_or_compiler_admission":false,"other_contact_pairs_queried":false,"physical_native_limitation":"MOVE charts and lifetime descriptors are checked on the source. Excluding transport from logical observers is not native/global-phase/caller equivalence for a changed word.","pricing_or_numeric_powers_evaluated":false,"schema":"pr5678-fixed-nearest-contact-prerequisite/v1","source_descriptor_checks":{"boundary_descriptor_sha256":"564caeb99e67d04a7194fe99e84f947329d4c01fc37226078f086ae38b0f84e2","helpers":535,"owned_fields":9,"owned_lifetimes":11,"peak_owned_fields":2,"protected_subsequence_sha256":"1afa800e329de0d600778f8f5de448cd3a06c391d0763b45922461d94b913a9b","public_inputs":743,"scope":"Chart/lifetime descriptors only; no endpoint rows, owned erasure-zero, native phases or physical caller admission."},"source_head":"af814f6f3c477fdd13b8f04380a33cf32004966b","source_modules_imported":false,"source_word_git_blob":"8be2b3e1c2d02034d4579bef5d36df7761d826ff","source_word_sha256":"b56281a67f84832198be2f2ad36d87b75244d424f1e0a6f4dda2df74f20cc08d","stage_indices_used_as_final_indices":false,"status":"COMPLETED_FIXED_NEAREST_CONTACT_FALSIFIER","stop_reason":"The fixed two immediately preceding semantic contacts do not equal the nominated P/Q opcode, roles and signs.","unique_published_context":{"R":{"event":14893,"instruction":["ADD",140,438,"-1/2",794]},"Y":{"event":15473,"instruction":["ADD",144,438,"-1/2",911]},"entry":{"event":14891,"instruction":["ADD",438,733,"-4",794]},"exit":{"event":15476,"instruction":["ADD",438,733,"4",127]},"spectator":{"event":15470,"instruction":["ADD",160,451,"-1/2",911]}}}
diff --git a/research/p104-nearest-contact-verification/evidence/RESULT-optimized.json b/research/p104-nearest-contact-verification/evidence/RESULT-optimized.json
new file mode 100644
index 0000000000..6fce947b10
--- /dev/null
+++ b/research/p104-nearest-contact-verification/evidence/RESULT-optimized.json
@@ -0,0 +1 @@
+{"candidate_paid_invoice":null,"changed_full_word_emitted":false,"complete_affected_route_extraction_performed":false,"controls":{"additional_140_write":"rejected","additional_438_write":"rejected","additional_owned_COPY_source_observer":"rejected","compressed_corruption_before_decode":"rejected","decompression_abort_cap":"rejected","nearest_role":"rejected","nearest_sign":"rejected","nonunique_anchor_context":"rejected","unexpected_opcode":"rejected","valid_synthetic_conditional_pattern":{"exact_identity":true,"outcome":"accepted","scope":"Pure semantic/algebra unit case, not an actual typed source/native program."}},"decompressed_bytes_observed":1844210,"decompressed_hard_cap":16777216,"decompressed_source_sha256":"8bd10c59f346fbd427afbfd5d88b1f8ce9d633151faf51cd41a058b4f4e576a3","endpoint_admission":false,"fallback_search":false,"instruction_count":25453,"logical_observer_rule":"All ADD/COPY source reads and destination writes, SCALE reads+writes; owned interfaces included. MOVE excluded only from logical observation under the declared source invariant.","native_admission":false,"nearest_predicate":{"certified_R":{"event":14893,"instruction":["ADD",140,438,"-1/2",794]},"certified_Y":{"event":15473,"instruction":["ADD",144,438,"-1/2",911]},"nearest_144_contacts":[{"access":["write"],"event":13344,"instruction":["ADD",144,317,"1",356]},{"access":["write"],"event":13463,"instruction":["ADD",144,530,"1",1035]}],"reason":"The fixed two immediately preceding semantic contacts do not equal the nominated P/Q opcode, roles and signs.","status":"NEAREST_MISMATCH"},"new_kappa":null,"ordinary_or_compiler_admission":false,"other_contact_pairs_queried":false,"physical_native_limitation":"MOVE charts and lifetime descriptors are checked on the source. Excluding transport from logical observers is not native/global-phase/caller equivalence for a changed word.","pricing_or_numeric_powers_evaluated":false,"schema":"pr5678-fixed-nearest-contact-prerequisite/v1","source_descriptor_checks":{"boundary_descriptor_sha256":"564caeb99e67d04a7194fe99e84f947329d4c01fc37226078f086ae38b0f84e2","helpers":535,"owned_fields":9,"owned_lifetimes":11,"peak_owned_fields":2,"protected_subsequence_sha256":"1afa800e329de0d600778f8f5de448cd3a06c391d0763b45922461d94b913a9b","public_inputs":743,"scope":"Chart/lifetime descriptors only; no endpoint rows, owned erasure-zero, native phases or physical caller admission."},"source_head":"af814f6f3c477fdd13b8f04380a33cf32004966b","source_modules_imported":false,"source_word_git_blob":"8be2b3e1c2d02034d4579bef5d36df7761d826ff","source_word_sha256":"b56281a67f84832198be2f2ad36d87b75244d424f1e0a6f4dda2df74f20cc08d","stage_indices_used_as_final_indices":false,"status":"COMPLETED_FIXED_NEAREST_CONTACT_FALSIFIER","stop_reason":"The fixed two immediately preceding semantic contacts do not equal the nominated P/Q opcode, roles and signs.","unique_published_context":{"R":{"event":14893,"instruction":["ADD",140,438,"-1/2",794]},"Y":{"event":15473,"instruction":["ADD",144,438,"-1/2",911]},"entry":{"event":14891,"instruction":["ADD",438,733,"-4",794]},"exit":{"event":15476,"instruction":["ADD",438,733,"4",127]},"spectator":{"event":15470,"instruction":["ADD",160,451,"-1/2",911]}}}
diff --git a/research/p104-nearest-contact-verification/evidence/STATIC-REVIEW.json b/research/p104-nearest-contact-verification/evidence/STATIC-REVIEW.json
new file mode 100644
index 0000000000..3a3309f653
--- /dev/null
+++ b/research/p104-nearest-contact-verification/evidence/STATIC-REVIEW.json
@@ -0,0 +1,21 @@
+{
+  "checker_sha256": "2c747e340f4818a1064608323a877d693b5885bd58a1774e9b82315033649525",
+  "controls_reviewed_not_executed": {
+    "negative": 9,
+    "positive_exact_synthetic_algebra": 1
+  },
+  "material_blockers": [],
+  "original_sha256": "4dd5bde3a8c84c2e680d9f311e2fd2b2aeb525efa80dc12cac8210cee8d62cba",
+  "request_sha256": "31af46d73942c9dc1c16369d0d473b3afb194365df2e1baa54f78885394de2a1",
+  "reviewer_word_or_scientific_execution": false,
+  "sanitization": "Selected public scientific fields; not original review bytes.",
+  "schema": "public-pr5678-static-review-extract/v1",
+  "scope": "One fixed nearest-contact prerequisite; no native, endpoint, ordinary, caller, compiler or funding admission.",
+  "static_pin_checks": {
+    "input_sha256": 21,
+    "mismatches": 0,
+    "request_sha256_and_modes": 25,
+    "text_git_blobs": 6
+  },
+  "verdict": "ACCEPT_ONE_EXACT_ROOT_ONLY_GUARDED_PREREQUISITE_PAIR"
+}
diff --git a/research/p104-nearest-contact-verification/evidence/original-check.py b/research/p104-nearest-contact-verification/evidence/original-check.py
new file mode 100644
index 0000000000..11fa701088
--- /dev/null
+++ b/research/p104-nearest-contact-verification/evidence/original-check.py
@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+"""One fixed PR5678 nearest-contact prerequisite; root-only bounded execution.
+
+Apache-2.0. Credit Ali Romman and retained P104/source/native/caller/compiler
+contributors; classical compensated-update identity; OpenAI Codex assistance.
+No source imports, constructor, changed full word, numeric powers or pricing.
+"""
+from collections import Counter
+from fractions import Fraction as Q
+import gzip
+import hashlib
+import io
+import json
+from pathlib import Path
+import sys
+
+HERE=Path(__file__).resolve().parent
+ROOT=HERE.parents[2]
+HEAD='af814f6f3c477fdd13b8f04380a33cf32004966b'
+WORD_SHA='b56281a67f84832198be2f2ad36d87b75244d424f1e0a6f4dda2df74f20cc08d'
+WORD_BLOB='8be2b3e1c2d02034d4579bef5d36df7761d826ff'
+LIMIT=16*1024*1024
+ENTRY=['ADD',438,733,'-4',794]
+R=['ADD',140,438,'-1/2',794]
+SPECTATOR=['ADD',160,451,'-1/2',911]
+Y=['ADD',144,438,'-1/2',911]
+EXIT=['ADD',438,733,'4',127]
+P_PREFIX=['ADD',144,140,'1']
+Q_PREFIX=['ADD',144,140,'-1']
+
+class SourceError(ValueError):pass
+
+
+def need(ok,message):
+    if not ok:raise SourceError(message)
+
+
+def sha(raw):return hashlib.sha256(raw).hexdigest()
+def blob(raw):return hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()
+def canonical(value):return json.dumps(value,sort_keys=True,separators=(',',':')).encode()
+def shown(h):return {str(r):n for r,n in sorted(h.items()) if n}
+def mass(h):return sum(r*n for r,n in h.items())
+def clean(h):return {r:n for r,n in h.items() if n}
+def isint(x):return type(x) is int
+
+
+def authenticate_word(raw,pin):
+    need(pin['head']==HEAD and pin['bytes']==120135 and pin['sha256']==WORD_SHA and pin['git_blob']==WORD_BLOB,
+         'Exact fixed source binding')
+    need(len(raw)==120135 and sha(raw)==WORD_SHA and blob(raw)==WORD_BLOB,'Compressed WORD byte/Git/SHA identity before decode')
+
+
+def integer_token(s):
+    need(len(s)<=11,'Bounded JSON integer token')
+    n=int(s);need(abs(n)<=2**31-1,'Bounded JSON integer value');return n
+
+
+def pairs_unique(pairs):
+    out={}
+    for k,v in pairs:
+        need(k not in out,'Duplicate JSON descriptor key');out[k]=v
+    return out
+
+
+def bad_constant(s):raise SourceError('Unexpected JSON numeric constant '+s)
+
+
+def read_capped(stream,limit):
+    decoded=stream.read(limit+1)
+    need(len(decoded)<=limit,'Decompressed WORD exceeds hard abort cap')
+    need(stream.read(1)==b'','Decompressed WORD has excess data')
+    return decoded
+
+
+def decode(raw,pin):
+    authenticate_word(raw,pin)
+    with gzip.GzipFile(fileobj=io.BytesIO(raw),mode='rb') as stream:
+        decoded=read_capped(stream,LIMIT)
+    word=json.loads(decoded,object_pairs_hook=pairs_unique,parse_int=integer_token,parse_constant=bad_constant)
+    stack=[(word,0)];nodes=0
+    while stack:
+        x,depth=stack.pop();nodes+=1
+        need(nodes<=500000 and depth<=16,'Descriptor node/depth cap')
+        if isinstance(x,dict):
+            need(len(x)<=64 and all(isinstance(k,str) and len(k)<=128 for k in x),'Descriptor field cap')
+            stack.extend((v,depth+1) for v in x.values())
+        elif isinstance(x,list):
+            need(len(x)<=26000,'Descriptor array cap');stack.extend((v,depth+1) for v in x)
+        elif isinstance(x,str):need(len(x)<=4096,'Descriptor string cap')
+        elif isinstance(x,float):need(x==x and abs(x)!=float('inf'),'Finite unused metadata number')
+        else:need(x is None or type(x) in (int,bool),'Unexpected descriptor value')
+    return word,len(decoded),sha(decoded)
+
+
+def reduced_basis(vectors):
+    pivots={}
+    for v in vectors:
+        need(isint(v) and 0<v<512,'Nine-axis binary frame vector')
+        x=v
+        for p,b in sorted(pivots.items(),reverse=True):
+            if x&(1<<p):x^=b
+        need(x!=0,'Independent frame basis')
+        pivots[x.bit_length()-1]=x
+    return sorted(pivots.items(),reverse=True)
+
+
+def included(a,b):
+    for _,v in a:
+        x=v
+        for p,w in b:
+            if x&(1<<p):x^=w
+        if x:return False
+    return True
+
+
+def strict(a,b):return len(a)<len(b) and included(a,b)
+
+
+def roles(e):return set(e[1:3]) if e[0] in ('ADD','COPY') else {e[1]}
+def access(e,r):
+    out=[]
+    if e[0] in ('ADD','COPY'):
+        if e[2]==r:out.append('read')
+        if e[1]==r:out.append('write')
+    elif e[0]=='SCALE' and e[1]==r:out=['read','write']
+    return out
+
+def grammar(e,n,owned,frame_count):
+    need(isinstance(e,list) and e and isinstance(e[0],str),'Instruction record')
+    op=e[0];width={'ADD':5,'COPY':5,'SCALE':4,'MOVE':5,'INIT':3,'CLEAR':3}
+    need(op in width and len(e)==width[op],'Known opcode and exact fail-closed width')
+    need(isint(e[1]) and 0<=e[1]<n+owned,'Destination role')
+    def frame(f):need(isint(f) and 0<=f<frame_count,'Frame index')
+    if op=='MOVE':
+        frame(e[2]);frame(e[3]);need(type(e[4]) is bool,'MOVE ownership flag')
+    elif op in ('INIT','CLEAR'):
+        need(e[1]>=n,'Public lifetime operation is unsupported/source failure');frame(e[2])
+    else:
+        frame(e[-1]);need(isinstance(e[-2],str) and len(e[-2])<=128,'Bounded exact scalar coefficient')
+        q=Q(e[-2]);need(q and q.numerator.bit_length()<=256 and q.denominator.bit_length()<=256 and
+            q.denominator&(q.denominator-1)==0 and abs(q)+1<2**16,'Bounded nonzero dyadic scalar')
+        if op=='SCALE':need(abs(q.numerator)&(abs(q.numerator)-1)==0,'Dyadic unit SCALE')
+        else:
+            need(isint(e[2]) and 0<=e[2]<n+owned and e[1]!=e[2],'Distinct valid scalar source')
+            if op=='COPY':need(e[1]>=n,'Public COPY is not the declared grammar')
+
+
+def validate(word,receipt):
+    need(isinstance(word,dict) and word.get('schema')=='p104-paid-interior-bases/1','Exact emitted source schema')
+    n,owned=word.get('public'),word.get('owned_fields')
+    need(n==743 and isint(n) and owned==9 and isint(owned),'Retained public/owned counts')
+    frames=word.get('frames');need(isinstance(frames,list) and 912<=len(frames)<=4096,'Bounded frame table')
+    need(all(isinstance(b,list) and len(b)<=9 for b in frames),'Nine-axis frame cap')
+    spaces=[reduced_basis(b) for b in frames]
+    need([len(spaces[f]) for f in (794,911,127)]==[6,7,9] and strict(spaces[794],spaces[911]) and strict(spaces[911],spaces[127]),'Published high-pair ordered strict frame chain')
+    for name in ('initial','final'):
+        need(isinstance(word.get(name),list) and len(word[name])==n and all(isint(f) and 0<=f<len(frames) for f in word[name]),'Complete public boundary descriptor')
+    live=word.get('live');need(isinstance(live,list) and len(live)==104 and all(isint(r) and 0<=r<n and r+112<n for r in live) and len(set(live))==104,'104 distinct live roles')
+    main=set(live)|{r+112 for r in live};need(len(main)==208,'Main role convention')
+    helper=Counter()
+    for r in range(n):
+        if r not in main:
+            a,b=word['initial'][r],word['final'][r];need(strict(spaces[a],spaces[b]),'Helper productive boundary')
+            helper[len(spaces[b])-len(spaces[a])]+=1
+    need(shown(helper)==receipt['local']['helpers'] and receipt['local']['public_inputs']==n and receipt['local']['owned_fields']==owned,'Authenticated source descriptor/target receipt')
+    program=word.get('program');need(isinstance(program,list) and 0<len(program)<=26000,'Hard instruction cap')
+    current=word['initial'][:]+[None]*owned;zero=[None]*owned;life=peak=0;semantic=[];protected=[]
+    for i,e in enumerate(program):
+        grammar(e,n,owned,len(frames));op,r=e[:2]
+        if r>=n or (op in ('ADD','COPY') and e[2]>=n):protected.append(e)
+        if op=='MOVE':
+            need(current[r]==e[2] and e[4] is (r>=n),'Exact MOVE source/ownership chronology')
+            need(strict(spaces[e[3]],spaces[e[2]]) if r>=n else strict(spaces[e[2]],spaces[e[3]]),'Typed old MOVE nesting')
+            current[r]=e[3];continue
+        semantic.append({'event':i,'instruction':e})
+        if op=='INIT':
+            need(current[r] is None,'Fresh owned lifetime');current[r]=e[2];zero[r-n]=True;life+=1
+            peak=max(peak,sum(f is not None for f in current[n:]))
+        elif op=='CLEAR':
+            need(current[r]==e[2] and zero[r-n] is not None,'Active owned CLEAR chart');current[r]=None;zero[r-n]=None
+        else:
+            need(all(current[a]==e[-1] for a in roles(e)),'Every scalar operand has its declared actual common chart')
+            if op=='COPY':
+                need(zero[r-n] is True,'COPY destination proven zero by conservative lifetime bookkeeping')
+                zero[r-n]=zero[e[2]-n] if e[2]>=n else False
+            elif op=='ADD' and r>=n:
+                if e[2]<n or zero[e[2]-n] is not True:zero[r-n]=False
+            # Nonzero SCALE preserves the conservative zero flag.
+    need(current[:n]==word['final'] and all(f is None for f in current[n:]),'All source public/owned exits')
+    need(life==receipt['local']['owned_lifetimes']==11 and peak==receipt['local']['peak_owned_fields']==2,'Owned lifetime/peak counts')
+    return spaces,program,semantic,{'public_inputs':n,'helpers':535,'owned_fields':owned,'owned_lifetimes':life,'peak_owned_fields':peak,
+      'protected_subsequence_sha256':sha(canonical(protected)),
+      'boundary_descriptor_sha256':sha(canonical({k:word[k] for k in ('public','owned_fields','initial','final','live')})),
+      'scope':'Chart/lifetime descriptors only; no endpoint rows, owned erasure-zero, native phases or physical caller admission.'}
+
+
+def unique(items,label):
+    need(len(items)==1,'Unique '+label+' context required');return items[0]
+
+
+def bind(semantic):
+    es=[x['instruction'] for x in semantic]
+    start=unique([i for i in range(len(es)-1) if es[i:i+2]==[ENTRY,R]],'entry/R')
+    end=unique([i for i in range(len(es)-2) if es[i:i+3]==[SPECTATOR,Y,EXIT]],'spectator/Y/exit')
+    bound={'entry':semantic[start],'R':semantic[start+1],'spectator':semantic[end],'Y':semantic[end+1],'exit':semantic[end+2]}
+    need(bound['entry']['event']<bound['R']['event']<bound['spectator']['event']<bound['Y']['event']<bound['exit']['event'],'Ordered published fixed contexts')
+    return bound
+
+
+def contact(row,r):
+    return {'event':row['event'],'instruction':row['instruction'],'access':access(row['instruction'],r)}
+
+
+def predicate(semantic,bound):
+    ri,yi=bound['R']['event'],bound['Y']['event']
+    previous=[contact(x,144) for x in semantic if x['event']<yi and 144 in roles(x['instruction'])]
+    nearest=previous[-2:]
+    answer={'nearest_144_contacts':nearest,'certified_R':bound['R'],'certified_Y':bound['Y']}
+    if len(nearest)!=2 or nearest[0]['instruction'][:4]!=P_PREFIX or nearest[1]['instruction'][:4]!=Q_PREFIX:
+        return dict(answer,status='NEAREST_MISMATCH',reason='The fixed two immediately preceding semantic contacts do not equal the nominated P/Q opcode, roles and signs.')
+    p,q=nearest;pi,qi=p['event'],q['event']
+    if not pi<ri<qi<yi:return dict(answer,status='CORRIDOR_MISMATCH',reason='The actual order is not P<R<Q<Y.')
+    observers=[contact(x,144) for x in semantic if pi<=x['event']<=yi and 144 in roles(x['instruction'])]
+    if [x['event'] for x in observers]!=[pi,qi,yi]:return dict(answer,status='CORRIDOR_MISMATCH',reason='An additional receiver observer exists.',observers=observers)
+    writes=[contact(x,140) for x in semantic if pi<x['event']<qi and 'write' in access(x['instruction'],140)]
+    if [x['event'] for x in writes]!=[ri]:return dict(answer,status='CORRIDOR_MISMATCH',reason='R is not the sole logical 140 write between P and Q.',writes_140=writes)
+    changed=[contact(x,438) for x in semantic if ri<x['event']<yi and 'write' in access(x['instruction'],438)]
+    if changed:return dict(answer,status='CORRIDOR_MISMATCH',reason='438 has another logical write between R and Y.',writes_438=changed)
+    return dict(answer,status='MATCH',P=p,Q=q,observers_144=observers,writes_140=writes,writes_438=changed,
+                retained_other_140_reads=[contact(x,140) for x in semantic if pi<x['event']<yi and 'read' in access(x['instruction'],140) and x['event'] not in (pi,qi)])
+
+
+def semantics(events):return [{'event':i,'instruction':e} for i,e in enumerate(events) if e[0]!='MOVE']
+
+def rejected(action):
+    try:action()
+    except (SourceError,ValueError,KeyError):return 'rejected'
+    raise SourceError('A bounded control unexpectedly accepted')
+
+
+def control_suite(raw,pin):
+    valid=[['ADD',144,140,'1',794],ENTRY,R,['ADD',144,140,'-1',911],SPECTATOR,Y,EXIT]
+    def status(events):
+        sem=semantics(events);return predicate(sem,bind(sem))['status']
+    def require_match(events):need(status(events)=='MATCH','Synthetic conditional predicate')
+    positive=status(valid);need(positive=='MATCH','Exact valid synthetic conditional pattern')
+    # Independent three-row exact algebra for P,R,Q,Y, not a source lookup.
+    rows={140:[Q(1),Q(0),Q(0)],144:[Q(0),Q(1),Q(0)],438:[Q(0),Q(0),Q(1)]}
+    for e in [valid[0],R,valid[3],Y]:rows[e[1]]=[a+Q(e[3])*b for a,b in zip(rows[e[1]],rows[e[2]])]
+    need(rows[144]==[0,1,0] and rows[140]==[1,0,Q(-1,2)] and rows[438]==[0,0,1],'Exact synthetic arbitrary-input identity')
+    sign=[e[:] for e in valid];sign[3][3]='1'
+    role=[e[:] for e in valid];role[3][2]=141
+    observer=valid[:4]+[['COPY',743,144,'1',911]]+valid[4:]
+    write=valid[:3]+[['ADD',140,451,'1',794]]+valid[3:]
+    hwrite=valid[:3]+[['ADD',438,451,'1',794]]+valid[3:]
+    return {
+      'compressed_corruption_before_decode':rejected(lambda:authenticate_word(raw[:-1]+bytes([raw[-1]^1]),pin)),
+      'nearest_sign':rejected(lambda:require_match(sign)),
+      'nearest_role':rejected(lambda:require_match(role)),
+      'additional_owned_COPY_source_observer':rejected(lambda:require_match(observer)),
+      'additional_140_write':rejected(lambda:require_match(write)),
+      'additional_438_write':rejected(lambda:require_match(hwrite)),
+      'nonunique_anchor_context':rejected(lambda:bind(semantics(valid+[ENTRY,R]))),
+      'unexpected_opcode':rejected(lambda:grammar(['OBSERVE',144,911],743,9,4096)),
+      'decompression_abort_cap':rejected(lambda:read_capped(io.BytesIO(b'ab'),1)),
+      'valid_synthetic_conditional_pattern':{'outcome':'accepted','exact_identity':True,
+       'scope':'Pure semantic/algebra unit case, not an actual typed source/native program.'}}
+
+
+def route(word,program,semantic,r,spaces,deleted):
+    all_contacts=[dict(contact(x,r),frame=x['instruction'][-1]) for x in semantic if r in roles(x['instruction'])]
+    kept=[x for x in all_contacts if x['event'] not in deleted]
+    def path(cs):
+        required=[{'kind':'input','frame':word['initial'][r]}]+cs+[{'kind':'final','frame':word['final'][r]}]
+        visits=[]
+        for c in required:
+            if not visits or visits[-1]!=c['frame']:visits.append(c['frame'])
+        edges=[]
+        for a,b in zip(visits,visits[1:]):
+            need(strict(spaces[a],spaces[b]),'Direct required path is strictly increasing; no repair/intermediate search')
+            edges.append({'old':a,'new':b,'rank':len(spaces[b])-len(spaces[a])})
+        return {'required':required,'coalesced_frames':visits,'edges':edges,'histogram':shown(Counter(e['rank'] for e in edges))}
+    old,new=path(all_contacts),path(kept)
+    actual=[{'old':e[2],'new':e[3],'rank':len(spaces[e[3]])-len(spaces[e[2]])} for e in program if e[0]=='MOVE' and e[1]==r]
+    need(old['edges']==actual,'Complete old required-contact path equals every actual source MOVE for affected role')
+    old_h={int(k):v for k,v in old['histogram'].items()};new_h={int(k):v for k,v in new['histogram'].items()}
+    delta=Counter(new_h);delta.subtract(old_h)
+    return {'old':old,'new_contact_subchain':new,'actual_old_MOVE_chain':actual,'signed_local_delta':shown(delta)},set(old['coalesced_frames'])|set(new['coalesced_frames'])
+
+
+def main():
+    inputs=json.loads((HERE/'INPUTS.json').read_bytes())
+    for name,digest in inputs['files'].items():need(sha((ROOT/name).read_bytes())==digest,'Frozen input SHA '+name)
+    for name,digest in inputs['git_blobs'].items():need(blob((ROOT/name).read_bytes())==digest,'Published input Git blob '+name)
+    pin=json.loads((ROOT/inputs['word_custody']).read_bytes());raw=(ROOT/inputs['word']).read_bytes();authenticate_word(raw,pin)
+    nomination=json.loads((HERE/'NOMINATION.json').read_bytes())
+    need(nomination['source']['head']==HEAD and nomination['fixed_anchors']['R']['instruction']==R and nomination['fixed_anchors']['Y']['instruction']==Y and
+         nomination['missing_anchors']['P']['required_prefix']==P_PREFIX and nomination['missing_anchors']['Q']['required_prefix']==Q_PREFIX,'One fixed nomination binding')
+    witness=json.loads((ROOT/inputs['witness']).read_bytes());high=witness[0]
+    need((high['a'],high['b'],high['coefficient'],high['entry_frame'],high['exit_frame'])==(438,733,'-4',794,127) and
+         high['blocks'][0]['after']==[R] and high['blocks'][1]['after']==[SPECTATOR,Y] and high['start_block']==1090 and high['end_block']==1314,'Published source witness context; stage identifiers are provenance only')
+    controls=control_suite(raw,pin)
+    word,length,digest=decode(raw,pin);receipt=json.loads((ROOT/inputs['source_result']).read_bytes())
+    spaces,program,sem,desc=validate(word,receipt);bound=bind(sem);answer=predicate(sem,bound)
+    output={'schema':'pr5678-fixed-nearest-contact-prerequisite/v1','source_head':HEAD,'source_word_sha256':WORD_SHA,'source_word_git_blob':WORD_BLOB,
+      'decompressed_hard_cap':LIMIT,'decompressed_bytes_observed':length,'decompressed_source_sha256':digest,'instruction_count':len(program),
+      'source_descriptor_checks':desc,'unique_published_context':bound,'nearest_predicate':answer,'controls':controls,
+      'stage_indices_used_as_final_indices':False,'logical_observer_rule':'All ADD/COPY source reads and destination writes, SCALE reads+writes; owned interfaces included. MOVE excluded only from logical observation under the declared source invariant.',
+      'physical_native_limitation':'MOVE charts and lifetime descriptors are checked on the source. Excluding transport from logical observers is not native/global-phase/caller equivalence for a changed word.',
+      'changed_full_word_emitted':False,'source_modules_imported':False,'pricing_or_numeric_powers_evaluated':False,'new_kappa':None,'candidate_paid_invoice':None,
+      'fallback_search':False,'other_contact_pairs_queried':False,'native_admission':False,'endpoint_admission':False,'ordinary_or_compiler_admission':False}
+    if answer['status']=='NEAREST_MISMATCH':
+        output.update(status='COMPLETED_FIXED_NEAREST_CONTACT_FALSIFIER',stop_reason=answer['reason'],complete_affected_route_extraction_performed=False)
+        return output
+    if answer['status']!='MATCH':
+        output.update(status='COMPLETED_FIXED_CONTACT_PREDICATE_FALSIFIER',stop_reason=answer['reason'],complete_affected_route_extraction_performed=False)
+        return output
+    deleted={answer['P']['event'],answer['Q']['event'],bound['Y']['event']}
+    need(all(e['instruction'][0]=='ADD' and max(e['instruction'][1:3])<743 for e in [answer['P'],answer['Q'],bound['Y']]),'Only three public ADD contact deletions')
+    routes={};frames=set();total=Counter()
+    for r in (140,144,438):
+        row,used=route(word,program,sem,r,spaces,deleted);routes[str(r)]=row;frames|=used
+        total.update({int(k):n for k,n in row['signed_local_delta'].items()})
+    need(sum(r*n for r,n in total.items())==0,'Endpoint-fixed path deletion preserves rank mass')
+    output.update(status='COMPLETED_FIXED_NEAREST_CONTACT_CONDITIONAL_PACKET',stop_reason='The one logical prerequisite matches; contact-subchain/rank packet only. Separate full native/caller/ordinary/funding validation is required.',
+      complete_affected_route_extraction_performed=True,deleted_public_scalar_contact_indices=sorted(deleted),affected_role_routes=routes,
+      ordered_frame_bases={str(f):word['frames'][f] for f in sorted(frames)},signed_affected_local_rank_histogram=shown(total),
+      symbolic_cost='sum_r delta_r H_r(C), H_r(C)=r^(1-C); no powers or prices evaluated.',
+      retained_other_140_reads=answer['retained_other_140_reads'],conditional_target_delta=0,
+      target_transfer_status='Conditional only; original independent input/endpoints/targets/protected owned sequence and full caller must be realized and verified later.')
+    return output
+
+
+if __name__=='__main__':
+    try:output=main();code=0
+    except Exception as error:
+        output={'schema':'pr5678-fixed-nearest-contact-prerequisite/v1','status':'SOURCE_OR_BINDING_FAILURE',
+          'failure':type(error).__name__+': '+str(error),'new_kappa':None,'changed_full_word_emitted':False,
+          'source_modules_imported':False,'pricing_or_numeric_powers_evaluated':False,'fallback_search':False};code=2
+    print(json.dumps(output,sort_keys=True,separators=(',',':')));sys.exit(code)
diff --git a/research/p104-nearest-contact-verification/source/NOTICE b/research/p104-nearest-contact-verification/source/NOTICE
new file mode 100644
index 0000000000..fa0bd1401f
--- /dev/null
+++ b/research/p104-nearest-contact-verification/source/NOTICE
@@ -0,0 +1,42 @@
+Four paid interior public-basis changes.
+Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0.
+No subagents.
+
+The following exact notice is retained from PR5660.
+
+New helper-subspace construction, proof and replay:
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+The same assistant performed the construction and author-side checks.
+
+Retained contributions:
+flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613
+relay/split compositions.
+Scratch-net: PR5606 prepared-helper identities and target debit.
+Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source.
+Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame
+change, PR5580 contact step,
+and PR5544/5545 complete P104 caller.
+Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff.
+DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools.
+thu-nmrc: PR5551 contact improvements.
+Gareth Davidson (bitplane): PR2305 source composition.
+David Arias: PR2152 coalesced P104 word.
+Cinna Davis: PR2219 private reuse and the controller lineage.
+Jacob Alan Sussman: productive mixed-target recursion.
+zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage.
+GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept.
+The retained source notices preserve earlier geometry, BIT and analytic credit.
+
+The elementary rank-one basis identity is not claimed as a new general
+linear-algebra theorem. The contribution is its explicit independent-target
+use on this P104 word and the complete conditional kappa improvement.
+
+New contribution: Ali Romman, with substantial OpenAI Codex assistance.
+The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644.
+The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit.
+The compensated triangle method retains Cinna Davis PR4692 credit.
+No subagents were used for this contribution. Apache-2.0.
+
+Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by
+Ali Romman corroborates it. This package credits that released composition
+and contributes the further four-gate placement.
diff --git a/research/p104-nearest-contact-verification/source/PROOF.md b/research/p104-nearest-contact-verification/source/PROOF.md
new file mode 100644
index 0000000000..77ef428c1a
--- /dev/null
+++ b/research/p104-nearest-contact-verification/source/PROOF.md
@@ -0,0 +1,111 @@
+# Exact construction and complete price
+
+## 1. One temporary basis
+
+Let `a` and `b` be distinct public registers. Set `R = I + c E_ab` for a
+nonzero dyadic scalar `c`. Then `R^-1 = I - c E_ab`.
+
+Choose two internal cuts where both registers can reach one common chart.
+Insert `R` at the first cut. Between the cuts, replace each scalar block
+`M_j` by `R M_j R^-1`. Insert `R^-1` at the second cut. The complete interval
+is unchanged:
+
+```text
+R^-1 (R M_k R^-1) ... (R M_1 R^-1) R = M_k ... M_1.
+```
+
+A block that does not use either register commutes with `R`. The same is
+true for each owned initialization and erasure, since `a` and `b` are public.
+The checker requires one certificate for every affected block. It checks
+the exact old event list and every rational matrix coefficient. It also
+rejects extra certificates. Thus this is an identity for arbitrary inputs,
+not a test on selected vectors.
+
+Each scalar block has one physical chart. The compiler moves each operand
+to that chart before it is used. At every step, its physical value is the
+declared native chart applied to its logical value. A scalar basis change
+at a common chart therefore implements the same rational matrix `R`.
+Native transport changes the chart and preserves the logical value.
+The final basis removal restores the original logical interval.
+
+## 2. Fixed witnesses
+
+The four certificates are applied in the order in WITNESS.json. Block
+indices refer to the complete word produced by the preceding step.
+
+| Public pair | Coefficient | Local paid delta |
+| --- | ---: | --- |
+| 438, 733 | -4 | `-H1-H2+H3` |
+| 119, 125 | -1 | `-2H1+H2` |
+| 125, 128 | -1 | `-2H1+H2` |
+| 128, 139 | -1 | `-2H1+H2` |
+
+There are eight changed scalar blocks. Each certificate gives the full
+before and after lists. The new contact graph permits four fewer local
+native calls. The transport builder includes both meeting charts and all
+remaining scalar contacts. It does not assign free movement to a basis
+operation. All public paths remain nested.
+
+The separate endpoint checks cover 743 arbitrary public inputs and nine
+owned register slots. There are eleven owned lifetimes and peak occupancy
+two. Every owned instruction and transport stays in the same order. All
+535 productive helper targets and all public boundary charts stay fixed.
+
+## 3. Native and caller binding
+
+The retained compiler lowers each chart change to a signed Gaussian-dyadic
+recipe. A separate interpreter checks every signed Pauli image and the
+global phase. It checks 2,918 distinct maps and 208 main endpoint adapters.
+The helper normalizers retain the exact productive target profile.
+
+The p16/a7 caller is unchanged. Its physical binding checks all 7,488
+contacts and all 53,248 central-square columns. It has 18 full forward
+calls, 15 thin query shears and 3,120 paid whole-idle jobs. The 3,328 main
+targets and 9,630 helper targets give 12,958 productive fields.
+
+These exact finite identities use the retained factorwise tensor rule.
+They do not add a new analytic or all-size admission assumption. The five
+existing framework assumptions and helper endpoint contract remain.
+
+## 4. Complete cost
+
+For `H_r(t) = r^t` and `0 < t < 1`, the paid change per local call is
+
+```text
+delta P = -7 H1 + 2 H2 + H3,
+delta T = 0.
+```
+
+Strict concavity gives `1+2^t>3^t` and `2>2^t`. Thus the complete signed
+moment increases by `18 * (7 - 2*2^t - 3^t) > 0` throughout that interval.
+The new bill has 66,402 paid calls and rank surplus 760. The local paid rank
+mass remains 5,986; the helper rank mass remains 4,266. Their difference is
+the 1,664 main progress plus 56 owned descent debt.
+
+Two rational interval engines verify the full moment and put its unique
+raw crossing in `(0.00310815850980, 0.00310815850981)`. The claim is
+`0.00310815849`, and the tested saving is `0.003108158495`.
+
+All scalar changes are priced. The local scalar allowance is 220,290 and
+the route allowance is 5,167,000. The retained complete raw ordinary bound
+is 184,647,552, below its 1,000,000,000 budget. The power-1024 compiler,
+cutoff 17, floor 18, tail parameter 1/5, reserve 10^-12 and decay 39/40 are
+unchanged. All 54 strict and four functional outer conditions pass.
+
+## 5. Verification limits
+
+The full source archive is authenticated before any retained module is
+loaded. The nested predecessor archive is authenticated again before its
+local or native checker is loaded. The new checker verifies the source
+word and every intermediate complete word. Its separate dense transpose
+engine checks 565,504 entries.
+
+False basis signs, false block coefficients, a missing block certificate,
+a missing native transport, a missing owned erasure, an unpaid query and
+extra target credit are rejected. The inherited phase, caller and price
+controls also run.
+
+The huge uniform word and rounded multiplier are algorithm-defined and
+are not materialized. These are author checks, not independent scientific
+acceptance or a proof-kernel theorem. The numerical improvement is small.
+No large gain or global optimum is established.
diff --git a/research/p104-nearest-contact-verification/source/RESULT.json b/research/p104-nearest-contact-verification/source/RESULT.json
new file mode 100644
index 0000000000..d5a73ee8ec
--- /dev/null
+++ b/research/p104-nearest-contact-verification/source/RESULT.json
@@ -0,0 +1,481 @@
+{
+  "authenticated_nested_files": 36,
+  "authenticated_outer_files": 23,
+  "complete_cost": {
+    "compiler": {
+      "H": 80511200000000000,
+      "N": "2^80511200000000000",
+      "eta": {
+        "lower": "0.000000131687557081252595606387",
+        "upper": "0.000000131687557081252595606388"
+      },
+      "gap": "1/1400000000000",
+      "integer_test_exponent": 57508,
+      "logarithm_power": 1024,
+      "theta": "63/64",
+      "uniform_saving": "1087855473/350000000000",
+      "word_materialized": false
+    },
+    "full_forward_calls": 18,
+    "gain": "34879/25000000000",
+    "kappa": "310815849/100000000000",
+    "kappa_decimal": ".00310815849",
+    "margin_at_previous": {
+      "lower": "0.338879531362370820661965404439",
+      "upper": "0.338879531362370820661965404440"
+    },
+    "negative_controls": {
+      "old_BIT": "Rejected by outer inequalities",
+      "old_cutoff": "Rejected by completion-tail ratio greater than one"
+    },
+    "nonrecursive": {
+      "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.",
+      "local_paid_rank_mass": 5986,
+      "local_routes": 5167000,
+      "local_scalar": 220290,
+      "peak_owned_fields": 2,
+      "raw_budget": 1000000000,
+      "raw_scalar_upper": 184647552,
+      "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word."
+    },
+    "ordinary_BIT": {
+      "admitted": "17/5000",
+      "after_cover": "69/20000",
+      "atom": "1/250",
+      "before_cover": "3459/1000000",
+      "ordinary_saving": "8590884599/2500000000000",
+      "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses"
+    },
+    "outer": {
+      "functional_checks": {
+        "actual_new_BIT_stock_sublinear": "348599999999253/350000000000000",
+        "fixed_halo_explicit_metadata_branch": "26950000000001/350000000000",
+        "new_BIT_row_stock_sublinear_in_active_group": "1395799999997009/1400000000000000",
+        "new_semantic_group_guard": "3/1400000000000"
+      },
+      "margins": {
+        "boundary_algebraic_matrix": "6091990645995648578111/1960000000000000000000000",
+        "fused_gaussian": "6091990645986945734333/1960000000000000000000000",
+        "global_coordinate_router": "435142189/140000000000",
+        "group_bit_router": "609199064738694573433/196000000000000000000000",
+        "group_scans": "699999999999/700000000000",
+        "main_transform": "6091990644595648578111/1960000000000000000000000",
+        "microbox_face_corrections": "26950000000001/350000000000",
+        "polynomial_products": "1399999999999/1400000000000",
+        "sparse_union_movement": "802341990645995648578111/1960000000000000000000000"
+      },
+      "parameters": {
+        "a": "435142189/140000000000",
+        "b": "4351421891/1400000000000",
+        "beta": "1399999999997/1400000000000",
+        "bit_saving": "17/5000",
+        "cap_xi": "1782341990644595648578111/1960000000000000000000000",
+        "complex_uniform_saving": "1087855473/350000000000",
+        "d": "1/1400000000000",
+        "epsilon": "1399999999999/1400000000000",
+        "kappa": "310815849/100000000000",
+        "lambda_": "398756736603/400000000000",
+        "lambda_prime": "1395648578111/1400000000000",
+        "layout": "1/1400000000000",
+        "q": "4351421889/1400000000000",
+        "r0": "1/14000000000000",
+        "stop": "1/1400000000000",
+        "tested_saving": "621631699/200000000000"
+      },
+      "strict_checks": {
+        "actual_bit_above_effective": "40857811/140000000000",
+        "actual_logarithmic_gamma_guard": "1/1400000000000",
+        "actual_logarithmic_group_guard": "177658009357504351421889/980000000000000000000000",
+        "alpha_logarithm_absorption": "1/14000000000000",
+        "boundary_algebraic_matrix_above_kappa": "5595648578111/1960000000000000000000000",
+        "cap_above_band": "802341990644595648578111/1960000000000000000000000",
+        "cap_below_cell": "177658009354004351421889/1960000000000000000000000",
+        "cap_below_phase_cell_power": "2137658009355404351421889/1960000000000000000000000",
+        "complex_above_effective": "1/1400000000000",
+        "complex_below_one_over_32": "39398578109/1400000000000",
+        "complex_endpoint": "1/700000000000",
+        "epsilon_below_one": "1/1400000000000",
+        "epsilon_positive": "1399999999999/1400000000000",
+        "fine_prime_halo_umbrella": "7/2",
+        "fused_gaussian_above_kappa": "5586945734333/1960000000000000000000000",
+        "gaussian_above_main": "695648578111/980000000000000000000000",
+        "global_coordinate_router_above_kappa": "1/350000000000",
+        "global_gamma_power_slack": "9/14000000000000",
+        "group_below_dimension": "1/700000000000",
+        "group_bit_router_above_kappa": "698694573433/196000000000000000000000",
+        "group_gauge_power_slack": "177658009357434351421889/980000000000000000000000",
+        "group_key_fits_record": "1/700000000000",
+        "group_positive": "1399999999997/1400000000000",
+        "group_scans_above_kappa": "21807009033/21875000000",
+        "halo_covers_generic_inverse_radius": "5",
+        "improvement_over_user_baseline": "688594035400418148631/500000000000000000000000",
+        "lambda_above_internal": "1/2800000000000",
+        "lambda_above_sigma": "3/2800000000000",
+        "lambda_above_tau": "1/2800000000000",
+        "lambda_prime_above_lambda": "1/2800000000000",
+        "lambda_prime_above_leaf": "2795648578109/1960000000000000000000000",
+        "leaf_saving_above_effective": "1395648578109/1960000000000000000000000",
+        "main_transform_above_kappa": "4195648578111/1960000000000000000000000",
+        "membership_arithmetic_fits_record": "1/1400000000000",
+        "microbox_face_corrections_above_kappa": "53897824289059/700000000000",
+        "microbox_halo_volume": "110600000000003/1400000000000",
+        "new_complex_uniform_saving_above_b": "1/1400000000000",
+        "new_semantic_guard_with_C1_one": "1/1400000000000",
+        "polynomial_products_above_kappa": "1395648578113/1400000000000",
+        "positive_layout_slack": "1/1400000000000",
+        "q_below_effective": "1/1400000000000",
+        "q_below_internal": "1/1400000000000",
+        "q_below_leaf": "2795648578109/1960000000000000000000000",
+        "q_positive": "4351421889/1400000000000",
+        "short_record_fallback": "1395648578109/1400000000000",
+        "source_axis_superpolynomial": "1/1400000000000",
+        "sparse_union_movement_above_kappa": "796250000005595648578111/1960000000000000000000000",
+        "stop_below_one": "1399999999999/1400000000000",
+        "stop_positive": "1/1400000000000",
+        "strassen_integer_power_gap": "1951441519231",
+        "support_router_span": "3/1400000000000",
+        "theta_positive_polynomial_power": "2",
+        "union_header_fits_record": "3/1400000000000",
+        "union_tag_work_per_visit_fits_record": "3/1400000000000"
+      }
+    },
+    "paid": {
+      "1": 40944,
+      "16": 416,
+      "2": 8280,
+      "24": 416,
+      "3": 8892,
+      "32": 416,
+      "4": 1638,
+      "40": 416,
+      "48": 416,
+      "5": 2862,
+      "56": 416,
+      "6": 396,
+      "64": 416,
+      "7": 270,
+      "72": 208
+    },
+    "paid_calls": 66402,
+    "previous_open_pr5660": "310676333/100000000000",
+    "productive_fields": 12958,
+    "query_shears": 15,
+    "rank_mass_surplus": 760,
+    "raw_ceiling": {
+      "derivative_upper": "-739773215192878821828754385468986974565929261970286747281917233/3138550867693340381917894711603833208051177722232017256448",
+      "interval": [
+        "0",
+        "17/5000"
+      ]
+    },
+    "raw_headroom": [
+      "99/5000000000000",
+      "1981/100000000000000"
+    ],
+    "raw_root_interval": [
+      "15540792549/5000000000000",
+      "310815850981/100000000000000"
+    ],
+    "relative_gain_percent": "13951600/310676333",
+    "strictification": {
+      "alpha": {
+        "lower": "0.999999999984953241363199004691",
+        "upper": "0.999999999984953241363199004692"
+      },
+      "cutoff": 17,
+      "delta": {
+        "lower": "0.967532018342092943007295114144",
+        "upper": "0.967532018342092943007295114145"
+      },
+      "floor": 18,
+      "gamma": {
+        "lower": "0.968220587948865237654067176469",
+        "upper": "0.968220587948865237654067176470"
+      },
+      "normalized_paid_upper": "1048576000976562501/1048576001073741824",
+      "power": 1024,
+      "reserve": "1/1000000000000",
+      "tail_block": 128,
+      "tail_decay": "39/40",
+      "tail_offset": "1/5",
+      "tested": "621631699/200000000000"
+    },
+    "targets": {
+      "1": 36,
+      "145": 208,
+      "17": 416,
+      "2": 72,
+      "25": 416,
+      "33": 416,
+      "4": 1638,
+      "41": 416,
+      "49": 416,
+      "5": 108,
+      "57": 416,
+      "65": 416,
+      "7": 90,
+      "73": 208,
+      "8": 288,
+      "9": 7398
+    },
+    "whole_idle_jobs": 3120
+  },
+  "limits": [
+    "The five inherited assumptions and helper endpoint contract remain.",
+    "The huge uniform word and complete rounded multiplier are not materialized.",
+    "Author checks do not establish independent scientific acceptance.",
+    "This gain is small. The requested large gain and a global optimum remain unproved."
+  ],
+  "local": {
+    "endpoint_coefficients": 565504,
+    "helpers": {
+      "1": 2,
+      "2": 4,
+      "4": 91,
+      "5": 6,
+      "7": 5,
+      "8": 16,
+      "9": 411
+    },
+    "owned_fields": 9,
+    "owned_lifetimes": 11,
+    "paid": {
+      "1": 2188,
+      "2": 460,
+      "3": 494,
+      "4": 91,
+      "5": 159,
+      "6": 22,
+      "7": 15
+    },
+    "paid_rank_mass": 5986,
+    "peak_owned_fields": 2,
+    "public_inputs": 743,
+    "real_scalar_allowance": 220290
+  },
+  "local_helper_delta": {},
+  "local_paid_delta": {
+    "1": -7,
+    "2": 2,
+    "3": 1
+  },
+  "native": {
+    "distinct_maps": 2918,
+    "helper_normalizers": 1070,
+    "helpers": {
+      "1": 2,
+      "2": 4,
+      "4": 91,
+      "5": 6,
+      "7": 5,
+      "8": 16,
+      "9": 411
+    },
+    "main_adapters": 208,
+    "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width",
+    "recipe_payload_sha256": "b49a78ea62c2a3bae7f5d2d0ae02900ce52bb17870d488d7959dcc4b4f867915",
+    "wrong_phase_rejected": true
+  },
+  "negative_controls": {
+    "extra_target": "Every productive helper has a native target",
+    "missing_central_translation": "Rejected by the complete Laurent endpoint",
+    "missing_conjugated_block": "Every affected block has a certificate",
+    "missing_native_transport": "Scalar destination and coefficient",
+    "missing_owned_erasure": "All public and owned exits",
+    "unpaid_query": "Complete field and call counts",
+    "wrong_basis_sign": "Exact conjugation of the complete scalar block",
+    "wrong_scalar_block": "Exact conjugation of the complete scalar block"
+  },
+  "physical_caller": {
+    "central_square_columns": 53248,
+    "full_calls": 18,
+    "main_targets": {
+      "145": 208,
+      "17": 416,
+      "25": 416,
+      "33": 416,
+      "41": 416,
+      "49": 416,
+      "57": 416,
+      "65": 416,
+      "73": 208
+    },
+    "new_paid_jobs": 0,
+    "physical_contacts": 7488,
+    "ports": 104,
+    "route_payload_sha256": "7f4f0ca768ffbc4f93dcff575592c4c67411f46b4289e45b73f715a2ad47b142",
+    "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.",
+    "whole_idle_jobs": {
+      "16": 416,
+      "24": 416,
+      "32": 416,
+      "40": 416,
+      "48": 416,
+      "56": 416,
+      "64": 416,
+      "72": 208
+    },
+    "wrapper_sites": [
+      1,
+      3,
+      5,
+      7,
+      9,
+      11,
+      13,
+      15,
+      17,
+      19,
+      21,
+      23,
+      25,
+      27,
+      29,
+      31
+    ]
+  },
+  "separate_columns": {
+    "arithmetic": "Dense integer rows with binary denominators; reverse chronology",
+    "coefficients": 565504,
+    "columns": 752
+  },
+  "source_commit": "3b0b4f37d5005f381ed9cfcccebfbe1ab35c71aa",
+  "source_local": {
+    "endpoint_coefficients": 565504,
+    "helpers": {
+      "1": 2,
+      "2": 4,
+      "4": 91,
+      "5": 6,
+      "7": 5,
+      "8": 16,
+      "9": 411
+    },
+    "owned_fields": 9,
+    "owned_lifetimes": 11,
+    "paid": {
+      "1": 2195,
+      "2": 458,
+      "3": 493,
+      "4": 91,
+      "5": 159,
+      "6": 22,
+      "7": 15
+    },
+    "paid_rank_mass": 5986,
+    "peak_owned_fields": 2,
+    "public_inputs": 743,
+    "real_scalar_allowance": 220220
+  },
+  "status": "PASS_P104_PAID_INTERIOR_BASES_KAPPA_00310815849",
+  "steps": [
+    {
+      "endpoint_coefficients": 565504,
+      "helpers": {
+        "1": 2,
+        "2": 4,
+        "4": 91,
+        "5": 6,
+        "7": 5,
+        "8": 16,
+        "9": 411
+      },
+      "owned_fields": 9,
+      "owned_lifetimes": 11,
+      "paid": {
+        "1": 2194,
+        "2": 457,
+        "3": 494,
+        "4": 91,
+        "5": 159,
+        "6": 22,
+        "7": 15
+      },
+      "paid_rank_mass": 5986,
+      "peak_owned_fields": 2,
+      "public_inputs": 743,
+      "real_scalar_allowance": 220224
+    },
+    {
+      "endpoint_coefficients": 565504,
+      "helpers": {
+        "1": 2,
+        "2": 4,
+        "4": 91,
+        "5": 6,
+        "7": 5,
+        "8": 16,
+        "9": 411
+      },
+      "owned_fields": 9,
+      "owned_lifetimes": 11,
+      "paid": {
+        "1": 2192,
+        "2": 458,
+        "3": 494,
+        "4": 91,
+        "5": 159,
+        "6": 22,
+        "7": 15
+      },
+      "paid_rank_mass": 5986,
+      "peak_owned_fields": 2,
+      "public_inputs": 743,
+      "real_scalar_allowance": 220246
+    },
+    {
+      "endpoint_coefficients": 565504,
+      "helpers": {
+        "1": 2,
+        "2": 4,
+        "4": 91,
+        "5": 6,
+        "7": 5,
+        "8": 16,
+        "9": 411
+      },
+      "owned_fields": 9,
+      "owned_lifetimes": 11,
+      "paid": {
+        "1": 2190,
+        "2": 459,
+        "3": 494,
+        "4": 91,
+        "5": 159,
+        "6": 22,
+        "7": 15
+      },
+      "paid_rank_mass": 5986,
+      "peak_owned_fields": 2,
+      "public_inputs": 743,
+      "real_scalar_allowance": 220268
+    },
+    {
+      "endpoint_coefficients": 565504,
+      "helpers": {
+        "1": 2,
+        "2": 4,
+        "4": 91,
+        "5": 6,
+        "7": 5,
+        "8": 16,
+        "9": 411
+      },
+      "owned_fields": 9,
+      "owned_lifetimes": 11,
+      "paid": {
+        "1": 2188,
+        "2": 460,
+        "3": 494,
+        "4": 91,
+        "5": 159,
+        "6": 22,
+        "7": 15
+      },
+      "paid_rank_mass": 5986,
+      "peak_owned_fields": 2,
+      "public_inputs": 743,
+      "real_scalar_allowance": 220290
+    }
+  ]
+}
diff --git a/research/p104-nearest-contact-verification/source/SOURCES.json b/research/p104-nearest-contact-verification/source/SOURCES.json
new file mode 100644
index 0000000000..5c13f25a07
--- /dev/null
+++ b/research/p104-nearest-contact-verification/source/SOURCES.json
@@ -0,0 +1,43 @@
+{
+  "schema_version": 1,
+  "base_commit": "df0137efd35e11b4445734bf612bdd4c7ebc330c",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8",
+      "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602",
+      "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72"
+    },
+    {
+      "path": "research/p104-paid-interior-bases/inputs/pr5660-source.tar",
+      "usage": "input",
+      "pin": "head:89c7e069d6b93b7802f946d01886d92970303f86:research/p104-paid-interior-bases/inputs/pr5660-source.tar",
+      "git_blob": "5b84cf23231082376660b7295744b64655039d8c",
+      "sha256": "397b1f99061f670ed904198d0458808769c0a8693394bee0d9648f1f280d88d3"
+    }
+  ],
+  "source_export": {
+    "commit": "3b0b4f37d5005f381ed9cfcccebfbe1ab35c71aa",
+    "files": 23,
+    "git_blob": "5b84cf23231082376660b7295744b64655039d8c",
+    "sha256": "397b1f99061f670ed904198d0458808769c0a8693394bee0d9648f1f280d88d3",
+    "local_path": "inputs/pr5660-source.tar",
+    "package": "research/p104-contact-rewrite",
+    "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5660"
+  },
+  "predecessors": {
+    "PR5627": "ed4dc88a09a7d201971f6603b8c2074e95dd9c32",
+    "PR5643": "a3ff5c628bfc8825553d62d913f3e91f75d6825f",
+    "PR5644": "c5871955d89bf73506fd68b0a5bf1cf2b3153c02",
+    "PR5650": "7916490124ac946704339a6a332bb76f06e5db5c",
+    "PR5651": "853192167b27d44aea0d4bc2b0d52d695fadc7c6",
+    "PR5660": "3b0b4f37d5005f381ed9cfcccebfbe1ab35c71aa"
+  },
+  "attribution": "PR5660 supplies the complete input word and retains the P104, helper, scalar, native, caller and compiler source chain. Four paid interior basis changes and their exact certificates are new work by Ali Romman with substantial OpenAI Codex assistance. No subagents."
+}
diff --git a/research/p104-nearest-contact-verification/source/WITNESS.json b/research/p104-nearest-contact-verification/source/WITNESS.json
new file mode 100644
index 0000000000..d3554cd80f
--- /dev/null
+++ b/research/p104-nearest-contact-verification/source/WITNESS.json
@@ -0,0 +1,501 @@
+[
+  {
+    "a": 438,
+    "b": 733,
+    "coefficient": "-4",
+    "start_block": 1090,
+    "end_block": 1314,
+    "entry_frame": 794,
+    "exit_frame": 127,
+    "blocks": [
+      {
+        "index": 1090,
+        "before": [
+          [
+            "ADD",
+            140,
+            733,
+            "2",
+            794
+          ],
+          [
+            "ADD",
+            140,
+            438,
+            "-1/2",
+            794
+          ]
+        ],
+        "after": [
+          [
+            "ADD",
+            140,
+            438,
+            "-1/2",
+            794
+          ]
+        ]
+      },
+      {
+        "index": 1313,
+        "before": [
+          [
+            "ADD",
+            160,
+            451,
+            "-1/2",
+            911
+          ],
+          [
+            "ADD",
+            144,
+            733,
+            "2",
+            911
+          ],
+          [
+            "ADD",
+            144,
+            438,
+            "-1/2",
+            911
+          ]
+        ],
+        "after": [
+          [
+            "ADD",
+            160,
+            451,
+            "-1/2",
+            911
+          ],
+          [
+            "ADD",
+            144,
+            438,
+            "-1/2",
+            911
+          ]
+        ]
+      }
+    ]
+  },
+  {
+    "a": 119,
+    "b": 125,
+    "coefficient": "-1",
+    "start_block": 703,
+    "end_block": 705,
+    "entry_frame": 3,
+    "exit_frame": 602,
+    "blocks": [
+      {
+        "index": 703,
+        "before": [
+          [
+            "ADD",
+            119,
+            706,
+            "2",
+            594
+          ],
+          [
+            "ADD",
+            125,
+            706,
+            "2",
+            594
+          ],
+          [
+            "ADD",
+            128,
+            706,
+            "2",
+            594
+          ],
+          [
+            "ADD",
+            139,
+            706,
+            "2",
+            594
+          ],
+          [
+            "ADD",
+            213,
+            706,
+            "2",
+            594
+          ]
+        ],
+        "after": [
+          [
+            "ADD",
+            213,
+            706,
+            "2",
+            594
+          ],
+          [
+            "ADD",
+            139,
+            706,
+            "2",
+            594
+          ],
+          [
+            "ADD",
+            128,
+            706,
+            "2",
+            594
+          ],
+          [
+            "ADD",
+            125,
+            706,
+            "2",
+            594
+          ]
+        ]
+      },
+      {
+        "index": 704,
+        "before": [
+          [
+            "ADD",
+            119,
+            708,
+            "-2",
+            602
+          ],
+          [
+            "ADD",
+            125,
+            708,
+            "2",
+            602
+          ],
+          [
+            "ADD",
+            127,
+            708,
+            "2",
+            602
+          ],
+          [
+            "ADD",
+            128,
+            708,
+            "-2",
+            602
+          ],
+          [
+            "ADD",
+            139,
+            708,
+            "2",
+            602
+          ],
+          [
+            "ADD",
+            154,
+            708,
+            "-2",
+            602
+          ]
+        ],
+        "after": [
+          [
+            "ADD",
+            119,
+            125,
+            "1",
+            602
+          ],
+          [
+            "ADD",
+            119,
+            708,
+            "-2",
+            602
+          ],
+          [
+            "ADD",
+            125,
+            708,
+            "2",
+            602
+          ],
+          [
+            "ADD",
+            127,
+            708,
+            "2",
+            602
+          ],
+          [
+            "ADD",
+            128,
+            708,
+            "-2",
+            602
+          ],
+          [
+            "ADD",
+            139,
+            708,
+            "2",
+            602
+          ],
+          [
+            "ADD",
+            154,
+            708,
+            "-2",
+            602
+          ],
+          [
+            "ADD",
+            119,
+            125,
+            "-1",
+            602
+          ]
+        ]
+      }
+    ]
+  },
+  {
+    "a": 125,
+    "b": 128,
+    "coefficient": "-1",
+    "start_block": 703,
+    "end_block": 705,
+    "entry_frame": 3,
+    "exit_frame": 602,
+    "blocks": [
+      {
+        "index": 703,
+        "before": [
+          [
+            "ADD",
+            119,
+            125,
+            "-1",
+            3
+          ]
+        ],
+        "after": [
+          [
+            "ADD",
+            125,
+            128,
+            "1",
+            3
+          ],
+          [
+            "ADD",
+            119,
+            125,
+            "-1",
+            3
+          ],
+          [
+            "ADD",
+            125,
+            128,
+            "-1",
+            3
+          ]
+        ]
+      },
+      {
+        "index": 704,
+        "before": [
+          [
+            "ADD",
+            213,
+            706,
+            "2",
+            594
+          ],
+          [
+            "ADD",
+            139,
+            706,
+            "2",
+            594
+          ],
+          [
+            "ADD",
+            128,
+            706,
+            "2",
+            594
+          ],
+          [
+            "ADD",
+            125,
+            706,
+            "2",
+            594
+          ]
+        ],
+        "after": [
+          [
+            "ADD",
+            213,
+            706,
+            "2",
+            594
+          ],
+          [
+            "ADD",
+            139,
+            706,
+            "2",
+            594
+          ],
+          [
+            "ADD",
+            128,
+            706,
+            "2",
+            594
+          ]
+        ]
+      }
+    ]
+  },
+  {
+    "a": 128,
+    "b": 139,
+    "coefficient": "-1",
+    "start_block": 703,
+    "end_block": 705,
+    "entry_frame": 3,
+    "exit_frame": 602,
+    "blocks": [
+      {
+        "index": 703,
+        "before": [
+          [
+            "ADD",
+            125,
+            128,
+            "-1",
+            3
+          ],
+          [
+            "ADD",
+            125,
+            128,
+            "1",
+            3
+          ],
+          [
+            "ADD",
+            119,
+            125,
+            "-1",
+            3
+          ],
+          [
+            "ADD",
+            125,
+            128,
+            "-1",
+            3
+          ]
+        ],
+        "after": [
+          [
+            "ADD",
+            128,
+            139,
+            "1",
+            3
+          ],
+          [
+            "ADD",
+            125,
+            128,
+            "-1",
+            3
+          ],
+          [
+            "ADD",
+            125,
+            128,
+            "1",
+            3
+          ],
+          [
+            "ADD",
+            119,
+            125,
+            "-1",
+            3
+          ],
+          [
+            "ADD",
+            125,
+            128,
+            "-1",
+            3
+          ],
+          [
+            "ADD",
+            128,
+            139,
+            "-1",
+            3
+          ]
+        ]
+      },
+      {
+        "index": 704,
+        "before": [
+          [
+            "ADD",
+            213,
+            706,
+            "2",
+            594
+          ],
+          [
+            "ADD",
+            139,
+            706,
+            "2",
+            594
+          ],
+          [
+            "ADD",
+            128,
+            706,
+            "2",
+            594
+          ]
+        ],
+        "after": [
+          [
+            "ADD",
+            213,
+            706,
+            "2",
+            594
+          ],
+          [
+            "ADD",
+            139,
+            706,
+            "2",
+            594
+          ]
+        ]
+      }
+    ]
+  }
+]
diff --git a/research/p104-nearest-contact-verification/source/WORD-CUSTODY.json b/research/p104-nearest-contact-verification/source/WORD-CUSTODY.json
new file mode 100644
index 0000000000..31bac5c57d
--- /dev/null
+++ b/research/p104-nearest-contact-verification/source/WORD-CUSTODY.json
@@ -0,0 +1,6 @@
+{
+  "bytes": 120135,
+  "git_blob": "8be2b3e1c2d02034d4579bef5d36df7761d826ff",
+  "head": "af814f6f3c477fdd13b8f04380a33cf32004966b",
+  "sha256": "b56281a67f84832198be2f2ad36d87b75244d424f1e0a6f4dda2df74f20cc08d"
+}
diff --git a/research/p104-nearest-contact-verification/source/WORD.json.gz b/research/p104-nearest-contact-verification/source/WORD.json.gz
new file mode 100644
index 0000000000..8be2b3e1c2
Binary files /dev/null and b/research/p104-nearest-contact-verification/source/WORD.json.gz differ
diff --git a/research/p104-nearest-contact-verification/source/construct.py b/research/p104-nearest-contact-verification/source/construct.py
new file mode 100644
index 0000000000..ff4d7701fc
--- /dev/null
+++ b/research/p104-nearest-contact-verification/source/construct.py
@@ -0,0 +1,147 @@
+"""Apply four checked changes of the public register basis.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+from copy import deepcopy
+from fractions import Fraction as Q
+from sources import need
+
+
+def blocks(word):
+    result, block, frame = [], [], None
+    for event in word['program']:
+        if event[0] == 'MOVE':
+            continue
+        if event[0] in ('INIT', 'CLEAR'):
+            if block:
+                result.append(block)
+            result.append([event])
+            block, frame = [], None
+        elif frame != event[-1]:
+            if block:
+                result.append(block)
+            block, frame = [event], event[-1]
+        else:
+            block.append(event)
+    if block:
+        result.append(block)
+    return result
+
+
+def add(dst, src, coefficient):
+    for column, value in tuple(src.items()):
+        value = dst.get(column, Q(0)) + coefficient * value
+        if value:
+            dst[column] = value
+        else:
+            dst.pop(column, None)
+
+
+def matrix(events, roles, frame):
+    rows = {r: {r: Q(1)} for r in roles}
+    for event in events:
+        op, r = event[:2]
+        need(op in ('ADD', 'SCALE') and event[-1] == frame,
+             'One ordinary scalar block at one chart')
+        coefficient = Q(event[-2])
+        need(r in roles and coefficient != 0, 'Declared scalar destination')
+        if op == 'SCALE':
+            rows[r] = {j: coefficient * value for j, value in rows[r].items()}
+        else:
+            need(event[2] in roles and event[2] != r, 'Declared scalar source')
+            add(rows[r], rows[event[2]], coefficient)
+    return rows
+
+
+def protected(word):
+    n = word['public']
+    return [e for e in word['program'] if e[1] >= n
+            or (e[0] in ('ADD', 'COPY') and e[2] >= n)]
+
+
+def rebuild(word, scalar):
+    result = deepcopy(word)
+    frames = word['initial'][:] + [None] * word['owned_fields']
+    program = []
+
+    def move(r, frame):
+        if frames[r] != frame:
+            need(frames[r] is not None, 'Live transport source')
+            program.append(['MOVE', r, frames[r], frame, r >= word['public']])
+            frames[r] = frame
+
+    for event in scalar:
+        op, r = event[:2]
+        if op == 'INIT':
+            need(frames[r] is None, 'Unused owned field')
+            frames[r] = event[2]
+        elif op == 'CLEAR':
+            move(r, event[2])
+            frames[r] = None
+        else:
+            move(r, event[-1])
+            if op in ('ADD', 'COPY'):
+                move(event[2], event[-1])
+        program.append(event[:])
+    for r in range(word['public']):
+        move(r, word['final'][r])
+    result['program'] = program
+    return result
+
+
+def step(word, witness, local):
+    source = blocks(word)
+    a, b, q = witness['a'], witness['b'], Q(witness['coefficient'])
+    start, end = witness['start_block'], witness['end_block']
+    entry, exit_frame = witness['entry_frame'], witness['exit_frame']
+    need(0 <= a < word['public'] and 0 <= b < word['public'] and a != b,
+         'Two distinct public fields')
+    need(q and q.denominator & (q.denominator - 1) == 0, 'Nonzero dyadic basis')
+    need(0 < start < end < len(source), 'Internal interval of scalar blocks')
+    need(0 <= entry < len(word['frames']) and 0 <= exit_frame < len(word['frames']),
+         'Declared basis charts')
+    replacements = {row['index']: row for row in witness['blocks']}
+    need(len(replacements) == len(witness['blocks']), 'Distinct replacement blocks')
+    expected = set()
+    scalar = []
+    for index, block in enumerate(source):
+        if index == start:
+            scalar.append(['ADD', a, b, str(q), entry])
+        roles = {e[1] for e in block} | {
+            e[2] for e in block if e[0] in ('ADD', 'COPY')}
+        if start <= index < end and roles & {a, b}:
+            expected.add(index)
+            need(index in replacements, 'Every affected block has a certificate')
+            row = replacements[index]
+            need(block == row['before'], 'Exact preceding scalar block')
+            frame = block[0][-1]
+            roles |= {a, b}
+            roles |= {e[1] for e in row['after']} | {
+                e[2] for e in row['after'] if e[0] == 'ADD'}
+            original = matrix(block, roles, frame)
+            # R = I + q E_ab. The two operations form R M R^-1.
+            add(original[a], original[b], q)
+            for vector in original.values():
+                add(vector, {b: Q(1)}, -q * vector.get(a, 0))
+            need(matrix(row['after'], roles, frame) == original,
+                 'Exact conjugation of the complete scalar block')
+            scalar.extend(row['after'])
+        else:
+            scalar.extend(block)
+        if index + 1 == end:
+            scalar.append(['ADD', a, b, str(-q), exit_frame])
+    need(set(replacements) == expected, 'No extra replacement certificate')
+    result = rebuild(word, scalar)
+    need(protected(result) == protected(word), 'Every owned instruction and transport stays fixed')
+    need(result['initial'] == word['initial'] and result['final'] == word['final'],
+         'All public boundaries stay fixed')
+    return result, local.replay(result)
+
+
+def construct(source, witnesses, local):
+    word, receipts = source, []
+    for witness in witnesses:
+        word, receipt = step(word, witness, local)
+        receipts.append(receipt)
+    word['schema'] = 'p104-paid-interior-bases/1'
+    return word, receipts
diff --git a/research/p104-nearest-contact-verification/source/local-grammar.py b/research/p104-nearest-contact-verification/source/local-grammar.py
new file mode 100644
index 0000000000..e72cb02dba
--- /dev/null
+++ b/research/p104-nearest-contact-verification/source/local-grammar.py
@@ -0,0 +1,208 @@
+"""Check the complete P104 word with an independent helper inventory.
+
+Adapted from Ali Romman's PR5544/5545. David Arias supplied the word;
+Cinna Davis supplied private reuse; Gareth Davidson supplied composition.
+Prepared by Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+from collections import Counter
+from fractions import Fraction as Q
+from functools import lru_cache
+from hashlib import sha256
+from pathlib import Path
+import gzip
+import importlib.util
+import json
+import sys
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+
+def need(ok, why):
+    if not ok:
+        raise ValueError(why)
+
+def read(path):
+    raw = path.read_bytes()
+    return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw)
+
+def load(path, name):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+def add(dst, src, q):
+    for k, v in tuple(src.items()):
+        value = dst.get(k, 0) + q*v
+        if value:
+            dst[k] = value
+        else:
+            dst.pop(k, None)
+
+def span(basis):
+    out = {0}
+    for v in basis:
+        need(type(v) is int and 0 < v < 512 and v not in out, 'Independent binary basis')
+        out |= {x ^ v for x in tuple(out)}
+    return frozenset(out)
+
+def replay(w):
+    public = w['public']
+    owned = w.get('owned_fields', 8)
+    need(type(owned) is int and 8 <= owned <= 9, 'Owned inventory bound')
+    need(type(public) is int and 735 <= public <= 750, 'Public inventory bound')
+    need(len(w['initial']) == len(w['final']) == public, 'Public boundary size')
+    need(len(w['program']) < 26000, 'Fixed operation bound')
+    frames = [span(x) for x in w['frames']]
+    rows = [{r:Q(1)} for r in range(public+owned)]
+    current = list(w['initial']) + [None]*owned
+    paid, scalar, live_owned, peak = Counter(), 0, set(), 0
+    lifetimes = 0
+    for e in w['program']:
+        op, r = e[:2]
+        need(0 <= r < public+owned, 'Role index')
+        if op == 'MOVE':
+            _, r, a, b, private = e
+            need(current[r] == a and (r in live_owned) == private, 'Transport source and ownership')
+            need(frames[b] < frames[a] if private else frames[a] < frames[b], 'Nested chronological transport')
+            paid[abs(len(w['frames'][b])-len(w['frames'][a]))] += 1
+            current[r] = b
+        elif op == 'INIT':
+            need(r >= public and r not in live_owned, 'Owned initialization')
+            live_owned.add(r)
+            lifetimes += 1
+            peak = max(peak, len(live_owned))
+            rows[r] = {}
+            current[r] = e[2]
+            scalar += 2
+        elif op == 'CLEAR':
+            need(r in live_owned and current[r] == e[2], 'Owned erasure at declared frame')
+            rows[r] = {}
+            current[r] = None
+            live_owned.remove(r)
+            scalar += 2
+        else:
+            q, f = Q(e[-2]), e[-1]
+            need(q and current[r] == f, 'Scalar destination and coefficient')
+            n, d = abs(q.numerator), q.denominator
+            need(d & (d-1) == 0, 'Dyadic scalar coefficient')
+            need(abs(q)+1 < 2**16, 'Fixed scalar growth bound')
+            if op == 'SCALE':
+                need(n & (n-1) == 0, 'Dyadic unit SCALE')
+                rows[r] = {k:q*x for k,x in rows[r].items()}
+                scalar += 2*(abs(n.bit_length()-d.bit_length()) + int(q < 0))
+            else:
+                s = e[2]
+                need(s != r and 0 <= s < public+owned and current[s] == f, 'Common scalar chart')
+                if op == 'COPY':
+                    need(r in live_owned and not rows[r], 'COPY into cleared owned field')
+                    rows[r] = {k:q*x for k,x in rows[s].items()}
+                else:
+                    need(op == 'ADD', 'Scalar opcode')
+                    add(rows[r], rows[s], q)
+                scalar += 2*(3+n.bit_length()-1+n.bit_count()+d.bit_length()-1)
+    need(not live_owned and 0 < peak <= 2 and current[:public] == w['final'], 'All public and owned exits')
+    live = set(w['live'])
+    for r,row in enumerate(rows):
+        expected = {r:Q(1)} if r < public else {}
+        if r-112 in live:
+            expected[r-112] = Q(1)
+        need(row == expected, 'All public and owned rows')
+    main = live | {r+112 for r in live}
+    helpers = Counter(len(w['frames'][w['final'][r]])-len(w['frames'][w['initial'][r]]) for r in range(public) if r not in main)
+    need(len(live) == len(w['ports']) == 104 and len(main) == 208 and min(helpers) > 0, 'Independent productive inputs')
+    return {'paid':dict(paid), 'helpers':dict(helpers), 'public_inputs':public, 'owned_fields':owned, 'owned_lifetimes':lifetimes,
+            'peak_owned_fields':peak, 'real_scalar_allowance':scalar, 'endpoint_coefficients':(public+owned)*(public+owned),
+            'paid_rank_mass':sum(r*count for r,count in paid.items())}
+
+def reverse_columns(w):
+    """Check the transpose with dense dyadic rows and the reverse chronology."""
+    public = w['public']
+    n = public+w.get('owned_fields', 8)
+    rows = [[int(i == j) for j in range(n)] for i in range(n)]
+    exponents = [0]*n
+    for e in reversed(w['program']):
+        op,r = e[:2]
+        if op == 'MOVE':
+            continue
+        if op in ('INIT','CLEAR'):
+            rows[r] = [0]*n
+            exponents[r] = 0
+            continue
+        q = Q(e[-2])
+        qe = q.denominator.bit_length()-1
+        if op == 'SCALE':
+            rows[r] = [q.numerator*x for x in rows[r]]
+            exponents[r] += qe
+        else:
+            s = e[2]
+            level = max(exponents[s], exponents[r]+qe)
+            a, b = 1 << (level-exponents[s]), q.numerator << (level-exponents[r]-qe)
+            rows[s] = [a*x+b*y for x,y in zip(rows[s],rows[r])]
+            exponents[s] = level
+            if op == 'COPY':
+                rows[r] = [0]*n
+                exponents[r] = 0
+            r = s
+        while exponents[r] and not any(x & 1 for x in rows[r]):
+            rows[r] = [x//2 for x in rows[r]]
+            exponents[r] -= 1
+    for r,row in enumerate(rows):
+        expected = [0]*n
+        if r < public:
+            expected[r] = 1 << exponents[r]
+        if r in w['live']:
+            expected[r+112] = 1 << exponents[r]
+        need(row == expected, 'Independent dense transpose columns')
+    return {'columns':n, 'coefficients':n*n, 'arithmetic':'Dense integer rows with binary denominators; reverse chronology'}
+
+def native(w):
+    n = w['public']
+    C = load(ROOT/'research/p104-native-channel/vendor/clifford_exact.py', 'p104_productive_clifford')
+    V = load(ROOT/'research/p104-native-channel/vendor/native_verify.py', 'p104_productive_gaussian')
+    @lru_cache(None)
+    def chart(i):
+        return C.canonical_frame(9, tuple(w['frames'][i]))
+    recipes = {}
+    def check(a,b):
+        if (a,b) not in recipes:
+            recipe,_ = C.lower_child(chart(a).adjoint().then(chart(b)))
+            expected = V.adjoint(V.frame(w['frames'][a],9)) + V.frame(w['frames'][b],9)
+            V.equal(V.recipe(recipe),expected,'Native chart change and exact global phase')
+            need(recipe['rank'] == abs(len(w['frames'][a])-len(w['frames'][b])), 'Native boundary rank')
+            recipes[a,b] = recipe
+        return recipes[a,b]
+    for e in w['program']:
+        if e[0] == 'MOVE':
+            check(e[2],e[3])
+    main = set(w['live']) | {r+112 for r in w['live']}
+    helper_profile = Counter()
+    for r in range(n):
+        if r not in main:
+            helper_profile[check(w['initial'][r],w['final'][r])['rank']] += 1
+    adapters = []
+    for r,q in zip(w['live'],w['ports']):
+        need(w['frames'][w['initial'][r]] == [q], 'Literal central port')
+        need(span(w['frames'][w['final'][r+112]]) == frozenset(x for x in range(512) if not (x&q).bit_count()%2), 'Literal output hyperplane')
+        tests = [
+            (C.cgate(9,q,1).adjoint().then(chart(w['initial'][r])), V.adjoint((('C',q,1),))+V.frame(w['frames'][w['initial'][r]],9)),
+            (chart(w['final'][r+112]).adjoint().then(C.cgate(9,q,-1).then(C.fourier(9))), V.adjoint(V.frame(w['frames'][w['final'][r+112]],9))+(('C',q,-1),)+V.fourier(9))]
+        for actual,expected in tests:
+            recipe,_ = C.lower_child(actual)
+            need(recipe['rank'] == 0, 'Free intrinsic main adapter')
+            V.equal(V.recipe(recipe),expected,'Main endpoint phase')
+            adapters.append(recipe)
+    bad = json.loads(json.dumps(next(iter(recipes.values()))))
+    bad['left']['phase'] = (bad['left']['phase']+1)%4
+    a,b = next(iter(recipes))
+    try:
+        V.equal(V.recipe(bad),V.adjoint(V.frame(w['frames'][a],9))+V.frame(w['frames'][b],9),'Wrong phase control')
+    except ValueError:
+        pass
+    else:
+        raise ValueError('Wrong native phase accepted')
+    payload = [[a,b,recipes[a,b]] for a,b in sorted(recipes)] + adapters
+    return {'distinct_maps':len(recipes),'main_adapters':len(adapters),'helper_normalizers':2*sum(helper_profile.values()),
+            'helpers':dict(helper_profile),'recipe_payload_sha256':sha256(json.dumps(payload,sort_keys=True,separators=(',',':')).encode()).hexdigest(),
+            'wrong_phase_rejected':True, 'proof':'Every signed Pauli image and exact global phase; frame induction at every positive tensor width'}
diff --git a/research/p104-nearest-contact-verification/verify.py b/research/p104-nearest-contact-verification/verify.py
new file mode 100644
index 0000000000..7e51f21e49
--- /dev/null
+++ b/research/p104-nearest-contact-verification/verify.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Replay one fixed PR5678 nearest-contact falsifier. Apache-2.0."""
+import hashlib
+import json
+import os
+from pathlib import Path, PurePosixPath
+import subprocess
+import sys
+import tempfile
+HERE=Path(__file__).resolve().parent
+EXPECTED='18dac3a5092667ab5f5118ed6e953d65d558a8d11066e95cc728a069ec01f50f'
+ORIGINAL_CORE='2c747e340f4818a1064608323a877d693b5885bd58a1774e9b82315033649525'
+WORD_SHA='b56281a67f84832198be2f2ad36d87b75244d424f1e0a6f4dda2df74f20cc08d'
+WORD_BLOB='8be2b3e1c2d02034d4579bef5d36df7761d826ff'
+
+def need(ok,message):
+    if not ok:raise ValueError(message)
+def sha(raw):return hashlib.sha256(raw).hexdigest()
+def safe(name):
+    p=PurePosixPath(name);need(not p.is_absolute() and '..' not in p.parts and p.as_posix()==name,'Canonical local payload path')
+    f=HERE
+    for bit in p.parts:f=f/bit;need(not f.is_symlink(),'No payload symlink')
+    need(f.is_file(),'Missing payload '+name);return f
+
+def check_bytes(raw,row):
+    need(len(raw)==row['bytes'] and sha(raw)==row['sha256'],'Payload size/SHA256')
+    if 'git_blob' in row:need(hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()==row['git_blob'],'Payload Git blob')
+
+def rejected(action):
+    try:action()
+    except ValueError:return 'rejected'
+    raise ValueError('Integrity control accepted altered bytes')
+
+def main():
+    inventory=json.loads((HERE/'PORTABLE.json').read_bytes())
+    need(inventory['original_result_sha256']==EXPECTED and inventory['original_checker_sha256']==ORIGINAL_CORE,'Original evidence binding')
+    for name,row in inventory['payloads'].items():check_bytes(safe(name).read_bytes(),row)
+    old=safe('evidence/original-check.py').read_bytes();core=safe('check.py').read_bytes()
+    need(sha(old)==ORIGINAL_CORE and old.count(b'ROOT=HERE.parents[2]')==1 and old.replace(b'ROOT=HERE.parents[2]',b'ROOT=HERE')==core,'Exactly one ROOT adaptation; scientific core otherwise unchanged')
+    normal=safe('evidence/RESULT-normal.json').read_bytes()
+    need(sha(normal)==EXPECTED and normal==safe('evidence/RESULT-optimized.json').read_bytes(),'Entire original result pair')
+    word=safe('source/WORD.json.gz').read_bytes();row=inventory['payloads']['source/WORD.json.gz']
+    need(row['bytes']==120135 and row['sha256']==WORD_SHA and row['git_blob']==WORD_BLOB,'Exact published compressed WORD')
+    controls={'corrupt_compressed_bytes':rejected(lambda:check_bytes(word[:-1]+bytes([word[-1]^1]),row)),
+              'corrupt_scientific_core':rejected(lambda:check_bytes(core+b'\n',inventory['payloads']['check.py']))}
+    with tempfile.TemporaryDirectory(prefix='pr5678-nearest-cache-') as cache:
+        command=[sys.executable,'-I','-B','-X','pycache_prefix='+cache]
+        if sys.flags.optimize:command.append('-O' if sys.flags.optimize==1 else '-OO')
+        command.append(str(HERE/'check.py'));env=dict(os.environ);env.pop('PYTHONOPTIMIZE',None)
+        done=subprocess.run(command,cwd=HERE,env=env,capture_output=True,timeout=55,check=False)
+    need(done.returncode==0 and not done.stderr,'Core must complete without source/binding/resource failure')
+    need(sha(done.stdout)==EXPECTED,'Entire scientific result must match original SHA256, no excluded fields')
+    value=json.loads(done.stdout)
+    need(value['status']=='COMPLETED_FIXED_NEAREST_CONTACT_FALSIFIER' and value['nearest_predicate']['status']=='NEAREST_MISMATCH','Strict completed nearest-contact falsifier')
+    expected=[{'access':['write'],'event':13344,'instruction':['ADD',144,317,'1',356]},
+              {'access':['write'],'event':13463,'instruction':['ADD',144,530,'1',1035]}]
+    need(value['nearest_predicate']['nearest_144_contacts']==expected,'Exact two immediately preceding semantic contacts')
+    bound=value['unique_published_context']
+    need(bound['R']=={'event':14893,'instruction':['ADD',140,438,'-1/2',794]} and
+         bound['Y']=={'event':15473,'instruction':['ADD',144,438,'-1/2',911]},'Unique exact published R/Y contexts')
+    need(value['complete_affected_route_extraction_performed'] is False and value['candidate_paid_invoice'] is None and
+         value['pricing_or_numeric_powers_evaluated'] is False and value['new_kappa'] is None and
+         value['changed_full_word_emitted'] is False and value['other_contact_pairs_queried'] is False,'Stop before corridor/routes/prices/construction or another pair')
+    need('affected_role_routes' not in value and 'signed_affected_local_rank_histogram' not in value,'No conditional route branch ran')
+    need(value['instruction_count']==25453 and value['decompressed_hard_cap']==16777216,'Exact corpus count and original abort cap')
+    c=value['controls'];need(len(c)==10 and c['valid_synthetic_conditional_pattern']['outcome']=='accepted' and
+        c['valid_synthetic_conditional_pattern']['exact_identity'] is True and
+        all(v=='rejected' for k,v in c.items() if k!='valid_synthetic_conditional_pattern'),'Nine original rejections and exact positive semantic/algebra case')
+    print(json.dumps({'status':'PASS_PR5678_FIXED_NEAREST_CONTACT_VERIFICATION','scientific_status':value['status'],
+      'source_head':value['source_head'],'complete_scientific_output_sha256':sha(done.stdout),'nearest_contacts':expected,
+      'core_executions':1,'original_negative_controls_rejected':9,'original_positive_control_accepted':True,
+      'portable_integrity_controls':controls,'candidate_paid_invoice':None,'new_kappa':None,
+      'core_adaptation':'One ROOT assignment only; source modules never imported.'},sort_keys=True,separators=(',',':')))
+
+if __name__=='__main__':
+    try:main()
+    except Exception as error:
+        print(json.dumps({'status':'FAIL_PR5678_NEAREST_CONTACT_REPLAY','failure':type(error).__name__+': '+str(error)},sort_keys=True,separators=(',',':')));sys.exit(1)