diff --git a/research/longer-coupled-port-caller/CERTIFICATE-SUMMARY.json b/research/longer-coupled-port-caller/CERTIFICATE-SUMMARY.json
new file mode 100644
index 0000000000..4d4738071f
--- /dev/null
+++ b/research/longer-coupled-port-caller/CERTIFICATE-SUMMARY.json
@@ -0,0 +1,11 @@
+{
+  "orders": 75600,
+  "degree_counts": {
+    "2": 72020,
+    "3": 3580
+  },
+  "largest_witness_terms": 77,
+  "uncompressed_bytes": 6472926,
+  "compressed_bytes": 108057,
+  "sha256": "2e9279611423b0fc0488780e10cc8ac4ce3397f9c3f1809dd0ab294f4987ed1a"
+}
diff --git a/research/longer-coupled-port-caller/DISCOVERY-RESULTS.json.gz b/research/longer-coupled-port-caller/DISCOVERY-RESULTS.json.gz
new file mode 100644
index 0000000000..2d36583fe9
Binary files /dev/null and b/research/longer-coupled-port-caller/DISCOVERY-RESULTS.json.gz differ
diff --git a/research/longer-coupled-port-caller/DISCOVERY.md b/research/longer-coupled-port-caller/DISCOVERY.md
new file mode 100644
index 0000000000..a1ba8e1a79
--- /dev/null
+++ b/research/longer-coupled-port-caller/DISCOVERY.md
@@ -0,0 +1,93 @@
+# Longer coupled-port search
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+
+This file records discovery steps. The final result is in PROOF.md.
+No new kappa is established.
+Base: 6cf7a683f447b9f1e2333791907fd92be5009a63.
+Claim: https://github.com/CrocSwap/integer-mult-bounds/discussions/5593#discussioncomment-19186397
+
+## A useful necessary condition
+
+Work in characteristic two. Let R_i be square-zero matrices and let their
+sum be a diagonal projector E. Let P_i be diagonal coordinate projectors
+with P_i R_i = R_i P_i = R_i. A coordinate on which E is one must occur in
+at least three P_i.
+
+Proof: zero occurrences fail the diagonal equation. With one occurrence,
+the row and column of that R_i are those of E, so its square has diagonal
+entry one. With two occurrences, call their row vectors a and e_j+a,
+and their column vectors b and e_j+b. Square zero gives a*b=0 and
+(e_j+a)*(e_j+b)=0. But a_j=b_j, so the latter expression is 1+a*b=1.
+Both cases are contradictions.
+
+For full rank-q queries in rank-2q coordinate supports, 3*rank(E) is at
+most 2*q*L. The proof does not assume separate ports or any chronology.
+If every full call has a private stage axis, the target basis makes its
+projector diagonal. Thus this condition applies at every coupled rank.
+
+A second consequence applies when each stage occurs twice and has no
+rank loss. Its two rank-2q projectors sum to a rank-4q idempotent. The
+projectors are orthogonal. The sum of the two compatible queries is
+square zero and is supported on the diagonal target stage projector.
+The same three-occurrence argument applies to these grouped queries.
+It rules out full stage capacity whenever 3*N > 2*q*L, at all lengths
+and all coupled ranks. No chronological assumption is needed for this
+necessary condition. Rank losses and noncommuting local projectors need
+further work.
+
+## Query frame complement
+
+For sum R_i = I_N, equal rank q, write R_i=U_i V_i with V_i U_i=0.
+Set U=[U_i], V=[V_i]^T, K=VU. Then UV=I and C=I-K is an idempotent
+of rank h=q*L-N, with q by q identity diagonal blocks.
+Factor C=A B, BA=I_h. Each B_i A_i is a rank-q idempotent and their sum
+is I_h. When L is even, the complementary idempotents I_h-B_i A_i
+have rank h-q and also sum to I_h. Therefore L*(h-q)>=h. In particular,
+N<=q*L-q-ceil(q/(L-1)). The trace condition also requires N even over F2.
+These are necessary frame conditions, not a caller construction.
+
+## Numerical discovery screens
+
+The initial screen used the pinned PR5599 local invoice. It assumed all
+2*q*L stage incidences could be used and distributed them as evenly as
+possible. For q=104, eight calls on 720 fields appeared to have a raw
+crossing near .00348661. That frame is impossible: h=112, while the
+complement inequality requires 8*(112-104)>=112. Other paired-stage
+screens also lose capacity before an operator is built. These floating
+numbers are rejected discovery hypotheses, not kappa claims.
+
+## Next experiments
+
+The remaining construction must use noncommuting local stage projectors
+and pay for lost stage capacity, or change another stated hypothesis.
+The current search keeps the local P104 supplier and independent helpers.
+Use PR5631's mixed chronology condition before a full word replay.
+
+## Completed continuation
+
+The initial finite search checked 24^3 coupled splits in each of 144
+two-sweep orders: 1,990,656 assignments, with no chronology survivor.
+The rank-two coupled search used Z3 5.3.2.0 on 144 orders and found all
+unsatisfiable; this result alone was not used as a proof. Exact free-algebra
+witnesses then covered all 75,600 order types, with no matrix-size bound.
+The final theorem and its reduction are in PROOF.md.
+
+DISCOVERY-RESULTS.json.gz preserves all five JSON discovery reports. Its
+SHA256 is ec6fbe62a74cb05750db45c24c2a14ca18cb6b4f6bfb88a8151b76df40120ef8. The retained scripts
+can regenerate these reports. The registered checker uses only the exact
+order witnesses and standard-library matrix checks.
+
+Commands, from the repository root:
+
+```sh
+python3 -B research/longer-coupled-port-caller/search_star.py
+python3 -B research/longer-coupled-port-caller/search_orders.py --degree 2
+python3 -B research/longer-coupled-port-caller/nc_star.py --degree 3 --limit 144
+python3 -B research/longer-coupled-port-caller/build_certificates.py
+```
+
+The optional search_coupled.py command requires z3-solver==5.3.2.0. It is
+not a verification dependency. Its finite negative output is superseded
+by the exact algebra certificates. The numeric invoice screens do not
+supply an operator, compiler or kappa result.
diff --git a/research/longer-coupled-port-caller/ORDER-CERTIFICATES.json.gz b/research/longer-coupled-port-caller/ORDER-CERTIFICATES.json.gz
new file mode 100644
index 0000000000..045480c58a
Binary files /dev/null and b/research/longer-coupled-port-caller/ORDER-CERTIFICATES.json.gz differ
diff --git a/research/longer-coupled-port-caller/PROOF.md b/research/longer-coupled-port-caller/PROOF.md
new file mode 100644
index 0000000000..7df31b1dac
--- /dev/null
+++ b/research/longer-coupled-port-caller/PROOF.md
@@ -0,0 +1,197 @@
+# All-order exclusion of the coupled star query frame
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+
+## 1. Result and scope
+
+The constant-loss frame in PR5631 passes the earlier stage-rank and
+intersection cuts at arbitrarily large sizes. This package permits arbitrary
+matrix coupling inside every good stage pair. It excludes every call order,
+every coupled channel dimension, and every odd leaf count g>=3 for this
+frame. It also supplies a small exact proof format for other matrix searches.
+
+This is a theorem in the binary normalized model. It is not a reduction of
+all complex or dyadic native callers to that model. It gives no new kappa.
+Other query frames and connector contracts remain open.
+
+Let F be any field of characteristic two. Let W have positive dimension d.
+The main space is W_0 plus W_1 plus ... plus W_g, with W_0 the core. Let
+E_j select W_0 and W_j. On these two blocks put
+
+    T_j = [[I,I],[I,I]].
+
+All other blocks of T_j are zero. Split each good stage into two calls.
+Their projectors P_j and P'_j have sum E_j, are orthogonal, and their
+queries R_j and R'_j have sum T_j. Require P_j R_j = R_j P_j = R_j and
+P'_j R'_j = R'_j P'_j = R'_j. These conditions cover every compatible
+split at full stage rank. No separate-port restriction is imposed.
+
+The four remaining queries are F_C, G_C, F_(I+C), G_(I+C), where C is any
+idempotent on W. F_H has block H from each leaf input to the core output.
+G_H has block H from the core input to each leaf output. All other blocks
+are zero. These are the connector queries of the source star frame, after
+an arbitrary common channel basis change. Their stage projectors are not
+used in the exclusion. They can be thin calls. There can be arbitrary
+constant basis changes already absorbed into the displayed matrices.
+
+For odd g, the sum of all queries is I: the sum of the T_j has identity
+diagonal and identity core/leaf cross blocks; the four connectors cancel
+the cross blocks. Thus the frame passes the query-sum condition.
+
+For the native equal-rank instance, d=2q, rank A_j=rank C=q. Each good
+projector has rank 2q, each query has rank q, N=2q(g+1), and L=2g+4.
+The theorem is stronger than that instance: its algebra does not use the
+ranks of A_j or C.
+
+**Theorem.** No order of these calls has an endpoint with the central
+involution Q on every main field and the declared independent good-stage
+projectors E_j, if g>=3 is odd. This holds for every d>0 and every F of
+characteristic two. Failure already occurs in a mixed first derivative.
+
+## 2. All coupled splits have a matrix parameterization
+
+Since the two projectors are orthogonal and sum to E_j, both act inside
+W_0 plus W_j. Also P_j T_j = T_j P_j = R_j. The centralizer of T_j has
+block form
+
+    P_j  = [[A_j+B_j, B_j], [B_j, A_j+B_j]],
+    R_j  = [[A_j, A_j],     [A_j, A_j]],
+    P'_j = E_j + P_j,        R'_j = T_j + R_j.
+
+To see completeness, write a general four-block matrix and equate its
+products with T_j on the two sides. Its two diagonal blocks are equal,
+and its two off-diagonal blocks are equal. Idempotence is equivalent to
+
+    A_j^2 = A_j,
+    A_j B_j + B_j A_j = B_j.
+
+For example, in a basis with T_j=[[0,I],[0,0]], the projector is
+[[A_j,B_j],[0,A_j]]. This also gives rank P_j=2 rank A_j. These are full
+matrix parameters. Their entries can mix every channel. They are not
+scalar choices or copies of a one-port calculation.
+
+## 3. Necessary chronology equations
+
+Put Q=1+e and z_j=1+d_j, with e^2=d_j^2=0. After normalization a good
+call is (I+d_j P)(I+e R). Calls act in listed order, with later factors
+on the left. The query sum is I. The coefficient of e*d_j is
+
+    E_j + sum_(i in stage j) [P_i, sum_(k later than i) R_k].
+
+The desired endpoint has coefficient E_j. Therefore its defect must be
+zero. This is PR5631's mixed chronology condition. The bracket is AB+BA
+in characteristic two. An exact local matrix word supplies a separate
+check of this formula in the verifier.
+
+For each good stage j, retain only defect blocks whose row and column
+are not both in {0,j}. A nonzero retained block involves stage j and
+one other leaf k. A query at a third leaf contributes zero to this block:
+its only nonzero rows and columns are at the core and that third leaf.
+A connector contributes H or zero, independent of the number of leaves.
+Thus these retained equations depend only on the relative order of the
+two good stages and the four connectors.
+
+Choose any three good stages. Delete every other good call from the order.
+The retained equations on those three stages do not change. Rename the
+three stages in order of first occurrence. If a stage's second labelled
+call occurs first, replace A_j by I+A_j and leave B_j unchanged. This
+preserves all local equations and exchanges the two calls. Consequently
+there are exactly
+
+    10! / (2^3 * 3!) = 75600
+
+order types to check. This finite reduction is independent of g and d.
+It is the step that turns a finite order certificate into an unbounded
+length and matrix-size theorem.
+
+## 4. Exact certificates in a free algebra
+
+Use the free associative algebra F2<A0,B0,A1,B1,A2,B2,C>. A word records
+the order of its factors. In particular A0*B1 and B1*A0 are different
+words. The equations are the six local relations in Section 2, C^2+C,
+and the retained chronology blocks from Section 3.
+
+For each of the 75600 order types, ORDER-CERTIFICATES.json.gz gives
+explicit finite words u_l,v_l and equation indices i_l such that
+
+    sum_l u_l * equation_(i_l) * v_l = 1.
+
+The separate checker expands this sum and cancels equal words modulo two.
+There are 72020 witnesses of degree at most two and 3580 of degree at most
+three. The largest has 77 terms. No SAT or numerical solver is needed to
+check them. The search code uses finite linear algebra on words to find
+these identities; the checker does not import that code.
+
+If a tuple of matrices solved the equations, evaluation of each witness
+would give 0=I_d. This is impossible for d>0. Evaluation preserves word
+order, so no commutativity of the matrices is assumed. Since F contains
+F2, the same identities work over every characteristic-two field.
+This proves the theorem.
+
+For a short example, put all first good calls before all connectors, and
+put second good calls in reverse order. Four retained equations are
+
+    I + A0 + A1 + B1 = 0,
+    B1 = 0,
+    I + A0 + A2 + B2 = 0,
+    I + A1 + A2 + B2 = 0.
+
+Their sum is I=0. The other order types need the certificates above;
+this example is not used as a substitute for their complete coverage.
+
+## 5. What the search removes
+
+The source relaxed profile has 2q jobs of rank 1+8g and 2gq jobs of rank
+9, against 2g+4 full calls and their complete independent helper bill.
+For q=104 and g=1023, the PR5599 bill gives a positive relaxed moment at
+saving .003125. The exact integer-power enclosure is in RESULT.json.
+This exceeds the selected .00310045 but is not an attainable caller.
+The theorem excludes every coupled split and every order of this frame,
+including large cases that were not individually instantiated.
+
+The preliminary eight-call, 720-field price screen also failed a frame
+condition. If rank-q square-zero queries sum to I_N, their Gram complement
+has rank h=qL-N and identity q by q diagonal blocks. Factoring it gives
+rank-q idempotents E_i on an h-dimensional space with sum I_h. For even L,
+the complements I_h-E_i also sum to I_h. Hence L(h-q)>=h. The proposed
+q=104,L=8,N=720 has h=112 and 8(h-q)=64, so it is impossible.
+
+A separate useful test is the three-occurrence lemma. If square-zero
+matrices R_i sum to a diagonal projector E and are supported on diagonal
+projectors P_i, each coordinate where E=1 must occur in at least three
+P_i. With two occurrences, their rows are a and e_j+a and their columns
+are b and e_j+b. Square zero gives a*b=0, but
+(e_j+a)*(e_j+b)=1+a*b because a_j=b_j. This is a contradiction. One
+occurrence also contradicts square zero. Thus 3 rank E <= sum rank P_i.
+This covers arbitrary coupled queries whose local projectors commute.
+For paired stages at full rank, group the two orthogonally supported
+queries. Their sum is square zero and supported on the target stage
+projector. The same test applies. Rank loss requires another argument;
+the star theorem above supplies one for the declared frame.
+
+## 6. Verification boundary and next routes
+
+The order reduction and free-algebra evaluation argument are written
+proofs. The executable checker verifies the complete finite order cover
+and every exact identity. A different matrix implementation checks the
+local identities, query frame and mixed coefficient formula on coupled
+noncommuting examples. The one-leaf case is a genuine full polynomial
+word and is retained as a positive control. Corrupted certificates and
+changed query data must fail. No proof assistant or independent human
+acceptance is claimed.
+
+This theorem does not exclude a different query Gram frame, a different
+connector map, more connector queries interleaved with good calls, nonfull
+stage ranks, different main outputs, noninvolutive stages, helper feedback,
+or arbitrary complex/dyadic callers. It does not price or certify a new
+native multiplication algorithm. A future search can change one of these
+premises, or use the same free-algebra certificate format on another exact
+frame before it allocates large matrices and a complete native bill.
+
+Credit Cinna Davis / 1337isnot1337 for the controller, simplex and private
+projector lineage; PR5617 for stage/intersection cuts; PR5631 for the
+constant-loss star and mixed chronology equation; and the P104, helper,
+native, compiler and outer-framework authors retained by those sources.
+Free associative algebras and linear combinations of polynomial equations
+are standard tools. The all-order coupled-frame reduction and its exact
+witnesses are the contribution of this package.
diff --git a/research/longer-coupled-port-caller/README.md b/research/longer-coupled-port-caller/README.md
new file mode 100644
index 0000000000..accdaed16e
--- /dev/null
+++ b/research/longer-coupled-port-caller/README.md
@@ -0,0 +1,74 @@
+# An all-order obstruction for coupled star callers
+
+The constant-loss star frame cannot be repaired by port coupling or by a
+longer order. In the binary normalized model, this package excludes every
+odd leaf count g>=3, every coupled channel dimension and every order of
+its calls. It keeps the star query frame and four complementary connector
+queries fixed. **No new kappa is claimed.**
+
+[PROOF.md](PROOF.md) gives the complete contract and the three-stage
+reduction. There are only 75,600 relative order types after that reduction.
+For each type, an exact identity in a free noncommutative algebra proves
+0=I. The identities apply to matrices of every size. This is stronger than
+a bounded search over matrix entries or port counts.
+
+[RESULT.json](RESULT.json) records the independent replay. The compressed
+[certificates](ORDER-CERTIFICATES.json.gz) contain every witness. The
+[checker](check_certificates.py) expands them without importing the search
+code or using a solver. There are 72,020 witnesses of degree at most two
+and 3,580 of degree at most three. None has more than 77 terms.
+
+The package also checks actual coupled matrices, the mixed coefficient
+formula, a complete one-leaf positive word, and corrupted data. The pinned
+PR5599 bill gives a positive relaxed moment at saving 1/320 for g=1023;
+the theorem shows why that price screen cannot become a caller in this
+frame. The selected record advanced upstream to .00310045 during this
+work. It was not changed by this contribution.
+
+## Reproduce
+
+Use Python 3.12 and the standard library:
+
+```sh
+python3 scripts/research_package.py --package research/longer-coupled-port-caller --check-only
+python3.12 scripts/research_package.py --package research/longer-coupled-port-caller
+python3.12 -I -O -B research/longer-coupled-port-caller/verify.py
+```
+
+The registered check uses the saved exact witnesses. To rebuild witnesses:
+
+```sh
+python3.12 -B research/longer-coupled-port-caller/build_certificates.py
+```
+
+The optional discovery searches and their complete receipts are described
+in [DISCOVERY.md](DISCOVERY.md). Their Z3 results are not proof inputs.
+Exact source commits, Git blobs and SHA256 hashes are in
+[SOURCES.json](SOURCES.json). The package began at canonical main
+6cf7a683f447b9f1e2333791907fd92be5009a63; the refresh at
+df0137efd35e11b4445734bf612bdd4c7ebc330c changed the selected record but
+not the priority or working instructions.
+
+## Open next questions
+
+- Change the query Gram frame. Test its chronological matrix equations
+  before any full native construction or favorable price claim.
+- Change the connector maps or add interleaved paid queries. Recompute
+  every equation and keep the complete bill.
+- Establish a valid characteristic-zero statement for a concrete caller.
+  General dyadic coefficients cannot be reduced modulo two.
+
+Other frames, connector contracts, nonfull stage ranks, noninvolutive
+stages, changed targets and productive helper feedback remain outside the
+theorem. No native replay, proof-assistant proof, independent human review
+or global obstruction to improving kappa is claimed.
+
+## Credit
+
+Ali Romman with substantial OpenAI Codex assistance; no subagents.
+Apache-2.0. Credit Cinna Davis / 1337isnot1337 for the controller and simplex
+lineage, PR5617 for the stage/intersection cuts, PR5631 for the star frame
+and mixed chronology condition, and all P104/helper/native/compiler/outer
+source authors retained by those packages. Free-algebra identities and
+finite linear algebra are standard tools. The new work is the coupled
+parameterization, the all-order reduction and its exact certificates.
diff --git a/research/longer-coupled-port-caller/REFRESH.json b/research/longer-coupled-port-caller/REFRESH.json
new file mode 100644
index 0000000000..0ffe8709e9
--- /dev/null
+++ b/research/longer-coupled-port-caller/REFRESH.json
@@ -0,0 +1,17 @@
+{
+  "checked_at_utc": "2026-10-26T01:59:00Z",
+  "main": "df0137efd35e11b4445734bf612bdd4c7ebc330c",
+  "selected": "0.00310045",
+  "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5",
+  "priorities_or_working_instructions_changed": false,
+  "active_claims_checked": [
+    5600,
+    5636,
+    5638,
+    5642,
+    5125,
+    1166
+  ],
+  "own_scope": "Global caller with fixed supplier; no overlap with local contact/history/G20 construction",
+  "coverage": "Live latest Discussion updates plus the initial full open-PR and Discussion overlap cache; sparse local notes remain a limitation"
+}
diff --git a/research/longer-coupled-port-caller/RESULT.json b/research/longer-coupled-port-caller/RESULT.json
new file mode 100644
index 0000000000..8a16db2123
--- /dev/null
+++ b/research/longer-coupled-port-caller/RESULT.json
@@ -0,0 +1,64 @@
+{
+  "authenticated_inputs": 2,
+  "certificate_check": {
+    "certificate_sha256": "2e9279611423b0fc0488780e10cc8ac4ce3397f9c3f1809dd0ab294f4987ed1a",
+    "corruptions_rejected": [
+      "empty_witness",
+      "extra_nonzero_equation"
+    ],
+    "degree_counts": {
+      "2": 72020,
+      "3": 3580
+    },
+    "largest_witness_terms": 77,
+    "order_sha256": "1c50783fff7ff426b0aac677f1d59a7b605affd72f66ee18ef678a2e303170f0",
+    "orders": 75600
+  },
+  "limits": [
+    "No native or characteristic-zero reduction",
+    "No new kappa",
+    "Other query frames and connector contracts are not excluded",
+    "No proof-assistant or independent human acceptance"
+  ],
+  "matrix_controls": {
+    "coupled_frames": 24,
+    "deleted_query_rejected": true,
+    "mixed_coefficients": 96,
+    "noncommuting_local_controls": 91,
+    "one_leaf_full_word_coefficients": 4,
+    "symbolic_blocks_checked": 206,
+    "three_leaf_restriction_blocks": 432,
+    "three_occurrence_row_controls": 1365
+  },
+  "pricing": {
+    "excluded_relaxation": {
+      "denominator": "281474976710656",
+      "full_calls": 2050,
+      "g": 1023,
+      "main_fields": 212992,
+      "main_targets": {
+        "8185": 208,
+        "9": 212784
+      },
+      "moment_interval_numerators": [
+        "582017993691966270",
+        "582017993695381362"
+      ],
+      "q": 104,
+      "saving": "1/320",
+      "status": "POSITIVE_PRICE_SCREEN_BUT_NO_CALLER_IN_THE_DECLARED_FRAME"
+    },
+    "net_rank_mass": 1720,
+    "rejected_eight_call_frame": {
+      "L": 8,
+      "N": 720,
+      "h": 112,
+      "left": 64,
+      "q": 104,
+      "right": 112
+    },
+    "supplier": "PR5599 09dd0965711ca7eeb169057a420abab1c9052137"
+  },
+  "scope": "All odd g>=3, all positive channel dimensions, all characteristic-two fields, all call orders; fixed star queries and four complementary connectors",
+  "status": "PASS_ALL_ORDER_COUPLED_STAR_EXCLUSION"
+}
diff --git a/research/longer-coupled-port-caller/SOURCES.json b/research/longer-coupled-port-caller/SOURCES.json
new file mode 100644
index 0000000000..a4bdb5b8cb
--- /dev/null
+++ b/research/longer-coupled-port-caller/SOURCES.json
@@ -0,0 +1,52 @@
+{
+  "schema_version": 1,
+  "base_commit": "6cf7a683f447b9f1e2333791907fd92be5009a63",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "fc3d4ba105e1f097d0d7d051a308281e86ab1446",
+      "sha256": "66974efdced4083c00025f97d95d83909a226cdf801edb9301c195c6641f6903"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602",
+      "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72"
+    },
+    {
+      "path": "research/p104-helper-subspace-splits/RESULT.json",
+      "usage": "input",
+      "git_blob": "35f75c8555193c6e845cd52cc562ca23fd5924cb",
+      "sha256": "1d92e587915052110dfb3aca8890df5afdaf496164efa5a4a52e69ceeb3c70f3"
+    },
+    {
+      "path": "research/productive-controller-basis-search/algebra.py",
+      "usage": "input",
+      "pin": "head:6cf7a683f447b9f1e2333791907fd92be5009a63:research/productive-controller-basis-search/algebra.py",
+      "git_blob": "2f0d4f290c280cfdfc17714009a2ae0f220556d4",
+      "sha256": "ab85b113cd70e20c38f6b0c0e0501876b751206bcd2a7ea5a61054ce3b92f2b2"
+    },
+    {
+      "path": "research/productive-controller-basis-search/GLOBAL-PROOF.md",
+      "usage": "provenance",
+      "pin": "head:6cf7a683f447b9f1e2333791907fd92be5009a63:research/productive-controller-basis-search/GLOBAL-PROOF.md",
+      "git_blob": "74b67e22e6c063193a83825207cdec19a8fef7a4",
+      "sha256": "adc377b13924701bf5b0b50b091d8b69c90195d50ce0f6808f7fb4c7e0b16457"
+    },
+    {
+      "path": "research/shortest-controller-stage-capacity/PROOF.md",
+      "usage": "provenance",
+      "pin": "head:6c088037e13b87faf7cfe3233c53d0ae51850dd8:research/shortest-controller-stage-capacity/PROOF.md",
+      "git_blob": "3e1a1f6b1f773780927f01e20be6719fe08ca5f3",
+      "sha256": "df8c53e3b04fdfa9ea10dd02a8bf770ba3111c7fa2d561075e7dd00d2297613e"
+    },
+    {
+      "path": "research/paired-stage-chronology-cut/PROOF.md",
+      "usage": "provenance",
+      "pin": "head:533a5f463e89e6fb74287ffe93c815fe83da10bb:research/paired-stage-chronology-cut/PROOF.md",
+      "git_blob": "c4bb728b8584144a0e1d58910fbc0ef7c2614ed1",
+      "sha256": "f93d3e62a9b3f41f49833575d95097777eb112d1068dc7035ee6b7d5304ce2d9"
+    }
+  ]
+}
diff --git a/research/longer-coupled-port-caller/TASK.json b/research/longer-coupled-port-caller/TASK.json
new file mode 100644
index 0000000000..fc389f9481
--- /dev/null
+++ b/research/longer-coupled-port-caller/TASK.json
@@ -0,0 +1,102 @@
+{
+  "schema_version": 1,
+  "task_id": "joint-query-controller",
+  "priority_revision": 7,
+  "base_commit": "6cf7a683f447b9f1e2333791907fd92be5009a63",
+  "original_card": {
+    "id": "joint-query-controller",
+    "question": "Can the installed QQ16 caller win a complete matched protocol bill, or can a changed demand eliminate actual paid work?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "research/qq16-caller-install/README.md"
+    ],
+    "methods": [
+      "Derive the matched whole-caller physical bill for installed and baseline protocols.",
+      "Change the actual demanded observations and prove a cheaper legal producer/consumer contract."
+    ],
+    "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read #4166 COST.md and ADMISSION.json. An actual caller connection is now proposed. Its native-component profile loses; parent park/restore versus external-call costs remain unresolved. Retain the producer and recovery lineage rather than rebuild it.",
+      "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately."
+    },
+    "first_experiment": "At the actual installed cut, compare matched complete parent park/restore and external input/return protocols at the same bank/packet geometry, including every later root call and service cost. Alternatively pin both bridge observations and derive a genuinely smaller source-compatible demand. Stop if the complete necessary inequality fails or an essential cost is unknown; no larger decoder scan from a local tape-action saving.",
+    "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.",
+    "allowed_variations": [
+      "One paid query, one changed first pair, or one precisely specified affine helper state.",
+      "A counterexample or lower bound for that exact proposed repair.",
+      "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain."
+    ],
+    "scope_change_triggers": [
+      "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.",
+      "Treating cover-map counts as zero-cost physical address operations.",
+      "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.",
+      "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate.",
+      "Recreating completed-output recovery or caller wiring already supplied by #4166 without new independent coverage.",
+      "Dropping retained later root calls or claiming native-profile dominance from the isolated publication saving."
+    ],
+    "overlap_terms": [
+      "QQ16",
+      "joint-query",
+      "changing-chart controller",
+      "selected observation",
+      "1969",
+      "2540",
+      "early record",
+      "output-bank retention",
+      "complete native decoder",
+      "2965",
+      "producer defect",
+      "dirty-helper range",
+      "F17 consumer",
+      "4166",
+      "qq16-caller-install"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.",
+        "evidence": "research/qq16-caller-install/README.md",
+        "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.",
+        "status": "author-checked",
+        "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      }
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "An all-order, all-dimension obstruction for the coupled constant-loss star query frame; exact noncommutative rejection certificates for future caller searches",
+  "scope_change_reason": "The user assigned a longer coupled-port caller search after PR5617 and PR5631. This does not reroll the catalogue card.",
+  "bottleneck_link": "A better global caller must turn the full local interface into enough independent Gaussian targets to pay its complete recursive bill.",
+  "budget_minutes": 60,
+  "stop_rule": "Complete the all-order reduction, replay every exact witness independently, retain a full positive word and fault controls, and publish the scope with exact sources.",
+  "outcome": "negative-result",
+  "evidence": "PROOF.md, ORDER-CERTIFICATES.json.gz, check_certificates.py, model_checks.py and RESULT.json",
+  "author": "Ali Romman with substantial OpenAI Codex assistance",
+  "ai_assistance": "Substantial OpenAI Codex assistance; no subagents.",
+  "open_questions": [
+    {
+      "question": "Can a different Gram frame support a profitable longer coupled-port caller?",
+      "why_it_matters": "The theorem fixes the star grouped query maps, not all rank-q callers.",
+      "first_step": "Generate a complement frame that is not conjugate to the star; test the mixed chronology equations before full word replay.",
+      "blocked_by": "A positive relaxed invoice does not supply a compatible ordered word."
+    },
+    {
+      "question": "Can a changed connector map or more interleaved connector queries evade these identities?",
+      "why_it_matters": "The four complementary connector queries are part of the excluded contract.",
+      "first_step": "Write the changed block query matrices, preserve their complete cost, and generate new free-algebra equations.",
+      "blocked_by": "The current certificates cannot be reused after an equation changes."
+    },
+    {
+      "question": "Can the binary obstruction be related to a stated characteristic-zero caller contract?",
+      "why_it_matters": "General dyadic coefficients do not reduce modulo two.",
+      "first_step": "Identify an integral invariant or a valid denominator-preserving reduction for a concrete caller.",
+      "blocked_by": "No general reduction is supplied here."
+    }
+  ]
+}
diff --git a/research/longer-coupled-port-caller/VALIDATION.json b/research/longer-coupled-port-caller/VALIDATION.json
new file mode 100644
index 0000000000..632e52fcc3
--- /dev/null
+++ b/research/longer-coupled-port-caller/VALIDATION.json
@@ -0,0 +1,33 @@
+{
+  "status": "LOCAL_AND_GIT_FREE_REPLAY_PASSED",
+  "python": "CPython 3.12.13",
+  "registered_normal": "PASS_REGISTERED_RESEARCH_PACKAGE research/longer-coupled-port-caller outcome=negative-result",
+  "optimized": "python3.12 -I -O -B research/longer-coupled-port-caller/verify.py; byte-identical RESULT.json",
+  "metadata_and_pins": "PASS_PACKAGE_METADATA_AND_PINS",
+  "exact_certificates": 75600,
+  "matrix_controls": "24 frames, 96 literal mixed coefficients, 206 symbolic blocks, 432 three-leaf restrictions, a full one-leaf word and 1365 parity controls",
+  "not_run": [
+    "Native P104 replay",
+    "Characteristic-zero reduction",
+    "Proof-assistant verification",
+    "Independent human review"
+  ],
+  "proof_commit": "67f12b6bef1e25f649bd62edae36cd144fe19899",
+  "committed_bytes": "PASS_RESEARCH_COMMIT_BYTES; 22 files",
+  "git_free_export": "PASS_RESEARCH_EXPORT; 22 files; read-only optimized replay with PATH=/nonexistent; identical result",
+  "source_corruption": "Changed invoice bytes rejected before computation, then restored",
+  "github_proof_objects": "Proof, result, sources and independent checker match exact Git blobs at the proof commit",
+  "publication": {
+    "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/5649",
+    "rendered_and_read_back": true,
+    "proof_links_checked_against_github_blobs": true,
+    "canonical_discussion_read_back": true
+  },
+  "hosted_ci": {
+    "head": "b904e2748d2374082ceb1a95bdfcfd4b528742db",
+    "run": 40258944381,
+    "planner": "Failed two upstream selected-record navigation tests",
+    "package_replay": "Skipped"
+  },
+  "cleanup": "Removed one unused import and two unused discovery helpers after replay; matrix controls still match the result."
+}
diff --git a/research/longer-coupled-port-caller/VERIFY.json b/research/longer-coupled-port-caller/VERIFY.json
new file mode 100644
index 0000000000..46bda421dc
--- /dev/null
+++ b/research/longer-coupled-port-caller/VERIFY.json
@@ -0,0 +1,21 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/p104-helper-subspace-splits/RESULT.json",
+    "research/productive-controller-basis-search/algebra.py"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 300,
+      "checks": "Authenticate inputs; independently expand all 75600 free-algebra witnesses; check coupled matrices, a complete positive word, corruption controls and an exact positive relaxed bill."
+    }
+  ]
+}
diff --git a/research/longer-coupled-port-caller/build_certificates.py b/research/longer-coupled-port-caller/build_certificates.py
new file mode 100644
index 0000000000..93caf39361
--- /dev/null
+++ b/research/longer-coupled-port-caller/build_certificates.py
@@ -0,0 +1,32 @@
+"""Build exact rejection witnesses. Verification does not import this file.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+import gzip
+import hashlib
+import json
+from pathlib import Path
+import time
+import nc_star as N
+import search_orders as S
+
+
+def main():
+    N.equations=S.pair_equations
+    records=[];counts={2:0,3:0};maximum=0;start=time.monotonic()
+    for index,order in enumerate(S.orders()):
+        result=N.certificate(3,order,2)
+        if 'one' not in result['certificates']:result=N.certificate(3,order,3)
+        if 'one' not in result['certificates']:raise ValueError(('Unproved order',order))
+        witness=result['certificates']['one'];degree=result['degree']
+        records.append([degree,witness]);counts[degree]+=1;maximum=max(maximum,len(witness))
+        if (index+1)%10000==0:print(index+1,round(time.monotonic()-start,2),flush=True)
+    raw=(json.dumps({'schema':1,'order_rule':'search_orders.orders; first good occurrences 0,1,2','witnesses':records},separators=(',',':'))+'\n').encode()
+    payload=gzip.compress(raw,compresslevel=9,mtime=0)
+    folder=Path(__file__).resolve().parent
+    (folder/'ORDER-CERTIFICATES.json.gz').write_bytes(payload)
+    summary={'orders':len(records),'degree_counts':counts,'largest_witness_terms':maximum,'uncompressed_bytes':len(raw),'compressed_bytes':len(payload),'sha256':hashlib.sha256(payload).hexdigest()}
+    (folder/'CERTIFICATE-SUMMARY.json').write_text(json.dumps(summary,indent=2)+'\n')
+    print(json.dumps(summary),flush=True)
+
+if __name__=='__main__':main()
diff --git a/research/longer-coupled-port-caller/check_certificates.py b/research/longer-coupled-port-caller/check_certificates.py
new file mode 100644
index 0000000000..ce0ef0f873
--- /dev/null
+++ b/research/longer-coupled-port-caller/check_certificates.py
@@ -0,0 +1,152 @@
+"""Check free-algebra witnesses without the search or solver code.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+from collections import Counter
+import gzip
+import hashlib
+import itertools
+import json
+from pathlib import Path
+
+
+def require(condition,message):
+    if not condition:raise ValueError(message)
+
+# A polynomial is a dictionary of words with coefficient one over F2.
+def toggle(out,word):
+    if word in out:del out[word]
+    else:out[word]=1
+
+def xor(*polys):
+    out={}
+    for p in polys:
+        for word in p:toggle(out,word)
+    return out
+
+def times(p,q):
+    out={}
+    for left in p:
+        for right in q:toggle(out,left+right)
+    return out
+
+ONE={():1}
+
+def letter(k):return {(k,):1}
+
+def zeros():return [[{} for _ in range(4)] for _ in range(4)]
+
+def matrix_sum(a,b):return [[xor(a[i][j],b[i][j]) for j in range(4)] for i in range(4)]
+
+def matrix_product(a,b):
+    return [[xor(*(times(a[i][k],b[k][j]) for k in range(4))) for j in range(4)] for i in range(4)]
+
+
+def setup():
+    gates=[];base=[]
+    for s in range(3):
+        a,b=letter(2*s),letter(2*s+1)
+        p,r,e,all_r=zeros(),zeros(),zeros(),zeros()
+        for i in (0,s+1):
+            e[i][i]=ONE
+            for j in (0,s+1):
+                p[i][j]=xor(a,b) if i==j else b
+                r[i][j]=a;all_r[i][j]=ONE
+        gates.extend(((p,r),(matrix_sum(p,e),matrix_sum(r,all_r))))
+        base.extend((xor(times(a,a),a),xor(times(a,b),times(b,a),b)))
+    c=letter(6);base.append(xor(times(c,c),c))
+    for h in (c,xor(ONE,c)):
+        p,forward,backward=zeros(),zeros(),zeros()
+        p[0][0]=h
+        for i in range(1,4):
+            forward[0][i]=h;backward[i][0]=h
+            for j in range(1,4):p[i][j]=h
+        gates.extend(((p,forward),(p,backward)))
+    # Compute ordered-pair contributions once. This uses pair sums, not the
+    # search program's suffix accumulator.
+    commutators={}
+    for i in range(6):
+        for j in range(10):
+            commutators[i,j]=matrix_sum(matrix_product(gates[i][0],gates[j][1]),matrix_product(gates[j][1],gates[i][0]))
+    return base,commutators
+
+
+def equations(order,base,commutators,with_labels=False):
+    out=[zeros() for _ in range(3)]
+    for earlier,i in enumerate(order):
+        if i>=6:continue
+        for j in order[earlier+1:]:out[i//2]=matrix_sum(out[i//2],commutators[i,j])
+    result=list(base);labels=[None]*len(base)
+    for s,mat in enumerate(out):
+        for r in range(4):
+            for c in range(4):
+                if r in (0,s+1) and c in (0,s+1):continue
+                if mat[r][c]:
+                    result.append(mat[r][c]);labels.append((s,r,c))
+    return (result,labels) if with_labels else result
+
+
+def all_orders():
+    # Build the order list independently from permutations of six good slots.
+    # Canonical first occurrences remove exactly the six good-stage renamings.
+    good=[]
+    def extend(prefix,counts):
+        if len(prefix)==6:
+            good.append(tuple(prefix));return
+        for s in range(3):
+            if counts[s]==2:continue
+            if counts[s]==0 and any(counts[t]==0 for t in range(s)):continue
+            updated=counts.copy();updated[s]+=1
+            extend(prefix+[s],updated)
+    extend([], [0,0,0])
+    for word in good:
+        for occupied in itertools.combinations(range(10),6):
+            positions=set(occupied)
+            for extra in itertools.permutations((6,7,8,9)):
+                ni=nj=0;seen=[0,0,0];order=[]
+                for k in range(10):
+                    if k in positions:
+                        s=word[ni];ni+=1;order.append(2*s+seen[s]);seen[s]+=1
+                    else:order.append(extra[nj]);nj+=1
+                yield tuple(order)
+
+
+def check_witness(eqs,witness,degree):
+    total={}
+    for index,left,right in witness:
+        require(type(index) is int and 0<=index<len(eqs),'Equation index')
+        require(all(type(v) is int and 0<=v<7 for v in left+right),'Variable index')
+        for term in eqs[index]:
+            word=tuple(left)+term+tuple(right)
+            require(len(word)<=degree,'Degree bound')
+            toggle(total,word)
+    require(total==ONE,'The witness does not expand to one')
+
+
+def verify(path=None):
+    path=Path(path) if path else Path(__file__).with_name('ORDER-CERTIFICATES.json.gz')
+    data=path.read_bytes();certificate=json.loads(gzip.decompress(data))
+    require(certificate['schema']==1,'Certificate schema')
+    witnesses=certificate['witnesses'];require(len(witnesses)==75600,'Order coverage')
+    base,commutators=setup();counts=Counter();seen=set();digest=hashlib.sha256();largest=0
+    for order,record in zip(all_orders(),witnesses,strict=True):
+        require(order not in seen,'Duplicate order');seen.add(order)
+        degree,witness=record
+        require(degree in (2,3),'Unexpected witness degree')
+        check_witness(equations(order,base,commutators),witness,degree)
+        counts[degree]+=1;largest=max(largest,len(witness));digest.update(bytes(order))
+    require(len(seen)==75600,'Order enumeration')
+    # A different enumeration counts all labelled orders before the quotient.
+    require(75600*6==3628800//8,'Labelled-order count')
+    first_order=next(all_orders());first_eq=equations(first_order,base,commutators)
+    first_witness=witnesses[0][1]
+    try:check_witness(first_eq,[],2)
+    except ValueError:pass
+    else:raise ValueError('An empty witness was accepted')
+    corrupted=first_witness+[[0,[],[]]]
+    try:check_witness(first_eq,corrupted,witnesses[0][0])
+    except ValueError:pass
+    else:raise ValueError('A changed witness was accepted')
+    return {'orders':len(seen),'degree_counts':{str(k):v for k,v in sorted(counts.items())},'largest_witness_terms':largest,'certificate_sha256':hashlib.sha256(data).hexdigest(),'order_sha256':digest.hexdigest(),'corruptions_rejected':['empty_witness','extra_nonzero_equation']}
+
+if __name__=='__main__':print(json.dumps(verify(),indent=2))
diff --git a/research/longer-coupled-port-caller/model_checks.py b/research/longer-coupled-port-caller/model_checks.py
new file mode 100644
index 0000000000..3091733bc4
--- /dev/null
+++ b/research/longer-coupled-port-caller/model_checks.py
@@ -0,0 +1,194 @@
+"""Independent matrix and polynomial controls for the star theorem.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+import random
+
+
+def require(test,message):
+    if not test:raise ValueError(message)
+
+
+def eye(n):return tuple(1<<i for i in range(n))
+def zero(n):return (0,)*n
+def add(a,b):return tuple(x^y for x,y in zip(a,b))
+
+def mul(a,b):
+    out=[]
+    for row in a:
+        value=0
+        while row:
+            low=row&-row;value^=b[low.bit_length()-1];row^=low
+        out.append(value)
+    return tuple(out)
+
+def rank(a):
+    pivots={}
+    for row in a:
+        while row:
+            p=row.bit_length()-1
+            if p not in pivots:pivots[p]=row;break
+            row^=pivots[p]
+    return len(pivots)
+
+def inverse(a):
+    n=len(a);rows=[a[i]|(1<<(n+i)) for i in range(n)]
+    for j in range(n):
+        pivot=next(i for i in range(j,n) if rows[i]>>j&1)
+        rows[j],rows[pivot]=rows[pivot],rows[j]
+        for i in range(n):
+            if i!=j and rows[i]>>j&1:rows[i]^=rows[j]
+    require(tuple(x&((1<<n)-1) for x in rows)==eye(n),'Matrix inverse')
+    return tuple(x>>n for x in rows)
+
+def choose(q,rng):
+    d=2*q;g=list(eye(d))
+    for _ in range(8*d):
+        i,j=rng.sample(range(d),2);g[i]^=g[j]
+    gi=inverse(g);diagonal=tuple(1<<i if i<q else 0 for i in range(d))
+    off=tuple(sum((rng.randrange(2)<<j) for j in range(d) if (i<q)!=(j<q)) for i in range(d))
+    return mul(mul(g,diagonal),gi),mul(mul(g,off),gi)
+
+def block_put(rows,block,rr,cc,d):
+    for i,row in enumerate(block):rows[rr*d+i]^=row<<(cc*d)
+
+
+def frame(q,g,rng):
+    d=2*q;n=d*(g+1);calls=[];target=[];noncommuting=0;parameters=[]
+    for j in range(g):
+        a,b=choose(q,rng);p=[0]*n;r=[0]*n;e=[0]*n;t=[0]*n
+        parameters.extend((a,b))
+        noncommuting+=mul(a,b)!=mul(b,a)
+        for row in (0,j+1):
+            block_put(e,eye(d),row,row,d)
+            for col in (0,j+1):
+                block_put(p,add(a,b) if row==col else b,row,col,d)
+                block_put(r,a,row,col,d);block_put(t,eye(d),row,col,d)
+        calls.extend(((j,tuple(p),tuple(r)),(j,add(e,p),add(t,r))))
+        target.append(tuple(e))
+    c,_=choose(q,rng)
+    parameters.append(c)
+    for half,h in enumerate((c,add(eye(d),c))):
+        p=[0]*n;ra=[0]*n;rb=[0]*n
+        block_put(p,h,0,0,d)
+        for j in range(1,g+1):
+            block_put(ra,h,0,j,d);block_put(rb,h,j,0,d)
+            for k in range(1,g+1):block_put(p,h,j,k,d)
+        calls.extend(((g+half,tuple(p),tuple(ra)),(g+half,tuple(p),tuple(rb))))
+        target.append(zero(n))
+    total=zero(n)
+    for _,p,r in calls:
+        require(mul(p,p)==p and rank(p)==2*q,'Native projector')
+        require(mul(r,r)==zero(n) and rank(r)==q,'Native query')
+        require(mul(p,r)==r and mul(r,p)==r,'Native compatibility')
+        total=add(total,r)
+    require(total==eye(n),'Query sum')
+    return calls,target,noncommuting,parameters
+
+
+def polynomial_product(a,b):
+    n=len(next(iter(a.values())));out={}
+    for x,ax in a.items():
+        for y,by in b.items():
+            if x&y:continue
+            key=x|y;out[key]=add(out.get(key,zero(n)),mul(ax,by))
+    return {key:mat for key,mat in out.items() if any(mat)}
+
+
+def literal(calls,order,stage=None):
+    n=len(calls[0][1]);out={0:eye(n)}
+    for index in order:
+        group,p,r=calls[index]
+        gate={0:eye(n),1:r}
+        if stage is None or group==stage:
+            bit=1<<(group+1) if stage is None else 2
+            gate[bit]=p;gate[bit|1]=r
+        out=polynomial_product(gate,out)
+    return out
+
+
+def defects(calls,order,group):
+    result=zero(len(calls[0][1]))
+    for i,left in enumerate(order):
+        if calls[left][0]!=group:continue
+        p=calls[left][1]
+        for right in order[i+1:]:
+            r=calls[right][2];result=add(result,add(mul(p,r),mul(r,p)))
+    return result
+
+
+def submatrix(matrix,indices):
+    return tuple(sum(((matrix[i]>>j)&1)<<k for k,j in enumerate(indices)) for i in indices)
+
+
+def evaluate(poly,parameters):
+    n=len(parameters[0]);result=zero(n)
+    for word in poly:
+        term=eye(n)
+        for letter in word:term=mul(term,parameters[letter])
+        result=add(result,term)
+    return result
+
+
+def run(checker=None):
+    rng=random.Random(20261026);cases=0;checked=0;noncommuting=0;symbolic_blocks=0;restriction_blocks=0
+    for q in (1,2,3,4):
+        for g in (3,5):
+            for _ in range(3):
+                calls,targets,nc,parameters=frame(q,g,rng);noncommuting+=nc
+                order=list(range(len(calls)));rng.shuffle(order);n=len(calls[0][1]);failed=0
+                numeric=[]
+                for group in range(g):
+                    defect=defects(calls,order,group);numeric.append(defect)
+                    actual=literal(calls,order,group).get(3,zero(n))
+                    require(actual==add(targets[group],defect),'Literal mixed coefficient')
+                    failed+=bool(any(defect));checked+=1
+                require(failed>0,'Excluded frame passed all necessary equations');cases+=1
+                d=2*q
+                if g==3 and checker is not None:
+                    base,commutators=checker.setup()
+                    eqs,labels=checker.equations(order,base,commutators,with_labels=True)
+                    for polynomial,label in zip(eqs,labels):
+                        actual=evaluate(polynomial,parameters)
+                        if label is None:require(actual==zero(d),'Local symbolic equation')
+                        else:
+                            stage,row,col=label
+                            expected=tuple((numeric[stage][row*d+i]>>(col*d))&((1<<d)-1) for i in range(d))
+                            require(actual==expected,'Symbolic equation matches the literal matrix defect');symbolic_blocks+=1
+                if g==5:
+                    chosen=sorted(rng.sample(range(g),3));indices=list(range(d))
+                    for stage in chosen:indices.extend(range((stage+1)*d,(stage+2)*d))
+                    selected=[i for i,(stage,_,_) in enumerate(calls) if stage in chosen or stage>=g]
+                    mapping={old:new for new,old in enumerate(selected)}
+                    reduced=[(chosen.index(stage) if stage<g else stage-g+3,submatrix(p,indices),submatrix(r,indices)) for i in selected for stage,p,r in (calls[i],)]
+                    reduced_order=[mapping[i] for i in order if i in mapping]
+                    for small,large in enumerate(chosen):
+                        full=submatrix(numeric[large],indices);cut=defects(reduced,reduced_order,small)
+                        for row in range(4):
+                            for col in range(4):
+                                if row in (0,small+1) and col in (0,small+1):continue
+                                for i in range(d):
+                                    mask=((1<<d)-1)<<(col*d)
+                                    require((full[row*d+i]&mask)==(cut[row*d+i]&mask),'Three-leaf restriction')
+                                restriction_blocks+=1
+    require(noncommuting>0,'Coupled controls must include noncommuting matrices')
+    # An actual one-leaf word: each channel uses its three-query identity.
+    calls,targets,_,_=frame(1,1,random.Random(37));order=list(range(6));n=4
+    result=literal(calls,order)
+    expected={0:eye(n),1:eye(n),2:eye(n),3:eye(n)}
+    require(result==expected,'One-leaf positive word')
+    changed=list(calls);group,p,r=changed[0];changed[0]=(group,p,zero(n))
+    require(literal(changed,order)!=expected,'Deleted query control')
+    # The two-row argument can be checked without a matrix inventory.
+    row_cases=0
+    for dimension in range(1,7):
+        for a in range(1<<dimension):
+            for b in range(1<<dimension):
+                if (a&1)!=(b&1) or (a&b).bit_count()%2:continue
+                require(((a^1)&(b^1)).bit_count()%2==1,'Three-occurrence parity')
+                row_cases+=1
+    return {'coupled_frames':cases,'mixed_coefficients':checked,'noncommuting_local_controls':noncommuting,'symbolic_blocks_checked':symbolic_blocks,'three_leaf_restriction_blocks':restriction_blocks,'one_leaf_full_word_coefficients':len(result),'three_occurrence_row_controls':row_cases,'deleted_query_rejected':True}
+
+if __name__=='__main__':
+    import json
+    print(json.dumps(run(),indent=2))
diff --git a/research/longer-coupled-port-caller/nc_star.py b/research/longer-coupled-port-caller/nc_star.py
new file mode 100644
index 0000000000..f9eb610002
--- /dev/null
+++ b/research/longer-coupled-port-caller/nc_star.py
@@ -0,0 +1,116 @@
+"""Exact free-algebra tests for the coupled star frame.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+import argparse
+import itertools
+import json
+from pathlib import Path
+import time
+
+ZERO=frozenset();ONE=frozenset(((),))
+
+def var(x): return frozenset(((x,),))
+
+def prod(a,b):
+    out=set()
+    for x in a:
+        for y in b:
+            z=x+y
+            if z in out:out.remove(z)
+            else:out.add(z)
+    return frozenset(out)
+
+def add(a,b):return [[x^y for x,y in zip(ar,br)] for ar,br in zip(a,b)]
+
+def mul(a,b):
+    n=len(a);out=[[ZERO]*n for _ in range(n)]
+    for i in range(n):
+        for k in range(n):
+            for j in range(n):
+                if a[i][k] and b[k][j]:out[i][j]^=prod(a[i][k],b[k][j])
+    return out
+
+def equations(g,order):
+    n=g+1;c=var(2*g);gates=[];eq=[]
+    names=[name+str(i) for i in range(g) for name in ('A','B')]+['C']
+    for j in range(g):
+        a=var(2*j);b=var(2*j+1)
+        p=[[ZERO]*n for _ in range(n)];r=[[ZERO]*n for _ in range(n)];e=[[ZERO]*n for _ in range(n)];rg=[[ZERO]*n for _ in range(n)]
+        for i,k in ((0,0),(0,j+1),(j+1,0),(j+1,j+1)):
+            p[i][k]=(a^b) if i==k else b
+            r[i][k]=a;rg[i][k]=ONE
+        e[0][0]=e[j+1][j+1]=ONE
+        gates.append(((p,r),(add(p,e),add(r,rg))))
+        eq.append((f'A{j} idempotent',prod(a,a)^a))
+        eq.append((f'B{j} centralizer',prod(a,b)^prod(b,a)^b))
+    eq.append(('C idempotent',prod(c,c)^c))
+    bad=[]
+    for h in (c,ONE^c):
+        p=[[ZERO]*n for _ in range(n)];a=[[ZERO]*n for _ in range(n)];b=[[ZERO]*n for _ in range(n)]
+        p[0][0]=h
+        for j in range(1,n):
+            a[0][j]=h;b[j][0]=h
+            for k in range(1,n):p[j][k]=h
+        bad.extend(((p,a),(p,b)))
+    out=[[[ZERO]*n for _ in range(n)] for _ in range(g+2)]
+    tail=[[ZERO]*n for _ in range(n)]
+    for j,k in reversed(order):
+        p,r=gates[j][k] if j<g else bad[2*(j-g)+k]
+        out[j]=add(out[j],add(mul(p,tail),mul(tail,p)));tail=add(tail,r)
+    for j,mat in enumerate(out):
+        for row,values in enumerate(mat):
+            for col,p in enumerate(values):
+                if p:eq.append((f'chronology {j}:{row},{col}',p))
+    return names,eq
+
+
+def certificate(g,order,degree=3):
+    names,eq=equations(g,order);alphabet=range(len(names))
+    words=[()]
+    for d in range(1,degree+1):words.extend(itertools.product(alphabet,repeat=d))
+    index={w:i for i,w in enumerate(words)};basis={};generators=[];tested={}
+    def encode(p):return sum(1<<index[w] for w in p)
+    for ei,(_,p) in enumerate(eq):
+        deg=max(map(len,p),default=0)
+        for length in range(degree-deg+1):
+            for leftsize in range(length+1):
+                for word in itertools.product(alphabet,repeat=length):
+                    left=word[:leftsize];right=word[leftsize:]
+                    shifted=frozenset(left+w+right for w in p)
+                    value=encode(shifted);rep=1<<len(generators)
+                    generators.append((ei,left,right))
+                    while value:
+                        pivot=value.bit_length()-1
+                        if pivot not in basis:
+                            basis[pivot]=(value,rep);break
+                        row,combo=basis[pivot];value^=row;rep^=combo
+    for label,p in [('one',ONE),('C',var(2*g)),('one_plus_C',ONE^var(2*g))]:
+        value=encode(p);rep=0
+        while value:
+            pivot=value.bit_length()-1
+            if pivot not in basis:break
+            row,combo=basis[pivot];value^=row;rep^=combo
+        if value==0:
+            terms=[generators[i] for i in range(len(generators)) if rep>>i&1]
+            # Independent literal expansion of the relation.
+            check=ZERO
+            for ei,left,right in terms:check^=frozenset(tuple(left)+w+tuple(right) for w in eq[ei][1])
+            if check!=p:raise ValueError('Bad ideal certificate')
+            tested[label]=terms
+    return {'g':g,'order':order,'degree':degree,'names':names,'equations':[(label,[list(w) for w in sorted(p)]) for label,p in eq],'monomials':len(words),'rows':len(generators),'rank':len(basis),'certificates':tested}
+
+
+def main():
+    ap=argparse.ArgumentParser();ap.add_argument('--degree',type=int,default=3);ap.add_argument('--limit',type=int,default=1);args=ap.parse_args()
+    g=3;records=[];start=time.monotonic()
+    for second in itertools.permutations(range(g)):
+        for bad in itertools.permutations(((3,0),(3,1),(4,0),(4,1))):
+            order=[(j,0) for j in range(g)]+list(bad)+[(j,1) for j in second]
+            r=certificate(g,order,args.degree);records.append(r)
+            print(json.dumps({k:r[k] for k in ('order','rows','rank','monomials')}|{'certificates':{k:len(v) for k,v in r['certificates'].items()},'seconds':round(time.monotonic()-start,2)}),flush=True)
+            if len(records)>=args.limit:break
+        if len(records)>=args.limit:break
+    Path(__file__).with_name(f'NC-STAR-D{args.degree}.json').write_text(json.dumps(records,indent=2)+'\n')
+
+if __name__=='__main__':main()
diff --git a/research/longer-coupled-port-caller/search_coupled.py b/research/longer-coupled-port-caller/search_coupled.py
new file mode 100644
index 0000000000..296daa8d50
--- /dev/null
+++ b/research/longer-coupled-port-caller/search_coupled.py
@@ -0,0 +1,135 @@
+"""Solve chronology constraints for a coupled star frame.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+Discovery only. A solver result is not a native endpoint.
+"""
+import argparse
+import itertools
+import json
+from pathlib import Path
+import time
+import z3
+import search_star as S
+
+# A polynomial is a set of square-free Boolean monomials. An integer gives
+# the variable set of one monomial. Zero denotes its constant term.
+def prod(a,b):
+    out=set()
+    for x in a:
+        for y in b:
+            z=x|y
+            if z in out: out.remove(z)
+            else: out.add(z)
+    return frozenset(out)
+
+ZERO=frozenset();ONE=frozenset((0,))
+
+def madd(a,b): return [[x^y for x,y in zip(ar,br)] for ar,br in zip(a,b)]
+
+def mmul(a,b):
+    n=len(a);out=[[ZERO for _ in range(n)] for _ in range(n)]
+    for i in range(n):
+        for k in range(n):
+            if not a[i][k]: continue
+            for j in range(n):
+                if b[k][j]:out[i][j]=out[i][j]^prod(a[i][k],b[k][j])
+    return out
+
+def mcomm(a,b):return madd(mmul(a,b),mmul(b,a))
+
+def constant(rows):return [[ONE if row>>j&1 else ZERO for j in range(len(rows))] for row in rows]
+
+
+def model(q,g):
+    d=2*q;n=d*(g+1);nextvar=0;As=[];Bs=[];vars=[]
+    for c in range(g):
+        local=[]
+        for label in ('a','b'):
+            mat=[]
+            for i in range(d):
+                row=[]
+                for j in range(d):
+                    row.append(frozenset((1<<nextvar,)))
+                    vars.append(z3.Bool(f'{label}{c}_{i}_{j}'));nextvar+=1
+                mat.append(row)
+            local.append(mat)
+        As.append(local[0]);Bs.append(local[1])
+    gates=[]
+    for c,(a,b) in enumerate(zip(As,Bs)):
+        p=[[ZERO for _ in range(n)] for _ in range(n)]
+        r=[[ZERO for _ in range(n)] for _ in range(n)]
+        e=[[ZERO for _ in range(n)] for _ in range(n)]
+        off=d*(c+1)
+        for i in range(d):
+            e[i][i]=ONE;e[off+i][off+i]=ONE
+            for j in range(d):
+                p[i][j]=p[off+i][off+j]=a[i][j]^b[i][j]
+                p[i][off+j]=p[off+i][j]=b[i][j]
+                r[i][j]=r[i][off+j]=r[off+i][j]=r[off+i][off+j]=a[i][j]
+        group=tuple(sum(1<<j for j in (i%d,off+i%d)) if i<d or off<=i<off+d else 0 for i in range(n))
+        gates.append(((p,r),(madd(e,p),madd(constant(group),r))))
+    bad=[]
+    for half in range(2):
+        p=(0,)*n;ra=(0,)*n;rb=(0,)*n
+        for k in range(half*q,(half+1)*q):
+            c=1<<k;w=sum(1<<(d*(j+1)+k) for j in range(g))
+            p=S.add(p,S.add(S.outer(c,c,n),S.outer(w,w,n)))
+            ra=S.add(ra,S.outer(c,w,n));rb=S.add(rb,S.outer(w,c,n))
+        bad.extend(((constant(p),constant(ra)),(constant(p),constant(rb))))
+    mono_cache={0:z3.BoolVal(True)}
+    def expr(poly):
+        terms=[]
+        for m in poly:
+            if m not in mono_cache:
+                indices=[];x=m
+                while x:
+                    bit=x&-x;indices.append(vars[bit.bit_length()-1]);x^=bit
+                mono_cache[m]=z3.And(indices)
+            terms.append(mono_cache[m])
+        if not terms:return z3.BoolVal(False)
+        out=terms[0]
+        for term in terms[1:]:out=z3.Xor(out,term)
+        return out
+    base=[]
+    for a,b in zip(As,Bs):
+        for matrix in (madd(mmul(a,a),a),madd(mcomm(a,b),b)):
+            base.extend(z3.Not(expr(p)) for row in matrix for p in row if p)
+        # For q=2, enumerate all 560 rank-two projectors on four coordinates.
+        if q==2:
+            projectors=sorted(set(p for p,_ in S.old.FULL))
+            bits=[expr(x) for row in a for x in row]
+            base.append(z3.Or([z3.And([bit if rows[i]>>j&1 else z3.Not(bit) for i in range(d) for j,bit in enumerate(bits[i*d:(i+1)*d])]) for rows in projectors]))
+        else:raise ValueError('Use q=2 for this discovery entry point.')
+    return n,gates,bad,vars,base,expr
+
+
+def solve(q,g,order,timeout):
+    n,gates,bad,variables,base,expr=model(q,g)
+    defects=[[[ZERO for _ in range(n)] for _ in range(n)] for _ in range(g+2)]
+    tail=[[ZERO for _ in range(n)] for _ in range(n)]
+    for c,k in reversed(order):
+        p,r=gates[c][k] if c<g else bad[2*(c-g)+k]
+        defects[c]=madd(defects[c],mcomm(p,tail));tail=madd(tail,r)
+    polys=set(p for mat in defects for row in mat for p in row if p)
+    solver=z3.Solver();solver.set(timeout=timeout);solver.add(base)
+    solver.add([z3.Not(expr(p)) for p in polys])
+    started=time.monotonic();status=solver.check()
+    record={'q':q,'g':g,'fields':n,'calls':2*g+4,'order':order,'status':str(status),'seconds':round(time.monotonic()-started,3),'nonzero_equations':len(polys)}
+    if status==z3.sat:
+        m=solver.model();record['bits']=[int(z3.is_true(m.eval(v,model_completion=True))) for v in variables]
+    if status==z3.unknown:record['reason']=solver.reason_unknown()
+    return record
+
+
+def main():
+    ap=argparse.ArgumentParser();ap.add_argument('--limit',type=int,default=144);ap.add_argument('--timeout-ms',type=int,default=10000);args=ap.parse_args()
+    records=[];g=3
+    for second in itertools.permutations(range(g)):
+        for connectors in itertools.permutations(((3,0),(3,1),(4,0),(4,1))):
+            order=[(j,0) for j in range(g)]+list(connectors)+[(j,1) for j in second]
+            record=solve(2,g,order,args.timeout_ms);records.append(record);print(json.dumps(record),flush=True)
+            if len(records)>=args.limit:break
+        if len(records)>=args.limit:break
+    Path(__file__).with_name('COUPLED-SEARCH.json').write_text(json.dumps({'z3':z3.get_version_string(),'records':records},indent=2)+'\n')
+
+if __name__=='__main__':main()
diff --git a/research/longer-coupled-port-caller/search_orders.py b/research/longer-coupled-port-caller/search_orders.py
new file mode 100644
index 0000000000..afbdb06c55
--- /dev/null
+++ b/research/longer-coupled-port-caller/search_orders.py
@@ -0,0 +1,56 @@
+"""Search all order types of three leaves and four fixed connectors.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+import argparse
+import itertools
+import json
+from pathlib import Path
+import time
+import nc_star as N
+
+_original=N.equations
+
+def pair_equations(g,order):
+    names,eq=_original(g,order);out=[]
+    for label,p in eq:
+        if not label.startswith('chronology'):
+            out.append((label,p));continue
+        head,rc=label.split(':');c=int(head.split()[1]);r,col=map(int,rc.split(','))
+        if c>=g:continue
+        if r in (0,c+1) and col in (0,c+1):continue
+        out.append((label,p))
+    return names,out
+
+
+def orders():
+    good_words=sorted(set(itertools.permutations((0,0,1,1,2,2))))
+    good_words=[w for w in good_words if w.index(0)<w.index(1)<w.index(2)]
+    for good in good_words:
+        for slots in itertools.combinations(range(10),6):
+            slots=set(slots)
+            for connectors in itertools.permutations(((3,0),(3,1),(4,0),(4,1))):
+                giter=iter(good);biter=iter(connectors);seen=set();out=[]
+                for i in range(10):
+                    if i in slots:
+                        c=next(giter);out.append((c,int(c in seen)));seen.add(c)
+                    else:out.append(next(biter))
+                yield out
+
+
+def main():
+    ap=argparse.ArgumentParser();ap.add_argument('--limit',type=int,default=75600);ap.add_argument('--degree',type=int,default=2);args=ap.parse_args()
+    N.equations=pair_equations;start=time.monotonic();hits=0;misses=[];examples=[]
+    for i,order in enumerate(orders()):
+        if i>=args.limit:break
+        r=N.certificate(3,order,args.degree)
+        if 'one' in r['certificates']:
+            hits+=1
+            if len(examples)<3:examples.append(r)
+        else:misses.append(order)
+        if (i+1)%1000==0:print(json.dumps({'orders':i+1,'certificates':hits,'unresolved':len(misses),'seconds':round(time.monotonic()-start,2)}),flush=True)
+    report={'scope':'All order types of three good pairs and the four fixed connectors; no matrix size bound','degree':args.degree,'orders':hits+len(misses),'certificates':hits,'unresolved':misses,'examples':examples}
+    Path(__file__).with_name(f'ORDER-SEARCH-D{args.degree}.json').write_text(json.dumps(report,indent=2)+'\n')
+    print(json.dumps({k:report[k] for k in ('scope','degree','orders','certificates')}|{'unresolved':len(misses)}),flush=True)
+
+if __name__=='__main__':main()
diff --git a/research/longer-coupled-port-caller/search_star.py b/research/longer-coupled-port-caller/search_star.py
new file mode 100644
index 0000000000..3091607d92
--- /dev/null
+++ b/research/longer-coupled-port-caller/search_star.py
@@ -0,0 +1,155 @@
+"""Search the coupled split of the constant-loss star frame.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+This is a binary necessary-condition search, not a native caller.
+"""
+import importlib.util
+import itertools
+import json
+from pathlib import Path
+import time
+
+ROOT = Path(__file__).resolve().parents[2]
+spec = importlib.util.spec_from_file_location('predecessor', ROOT/'research/productive-controller-basis-search/algebra.py')
+old = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(old)
+
+def mul(a, b):
+    out = []
+    for row in a:
+        value = 0
+        while row:
+            bit = row & -row
+            value ^= b[bit.bit_length()-1]
+            row ^= bit
+        out.append(value)
+    return tuple(out)
+
+def add(a, b):
+    return tuple(x^y for x,y in zip(a,b))
+
+def comm(a, b):
+    return add(mul(a,b),mul(b,a))
+
+def packed(a):
+    n=len(a)
+    return sum(x << (n*i) for i,x in enumerate(a))
+
+def outer(a,b,n):
+    return tuple(b if a>>i&1 else 0 for i in range(n))
+
+def embed(a, indices, n):
+    out=[0]*n
+    for i,row in enumerate(a):
+        out[indices[i]]=sum((1<<indices[j]) for j in range(len(indices)) if row>>j&1)
+    return tuple(out)
+
+
+def frame(g):
+    if g<3 or g%2!=1:
+        raise ValueError('Use an odd leaf count at least three.')
+    n=2*(g+1)
+    # Two core coordinates, then two coordinates for each leaf.
+    local=(5,10,5,10)
+    identity=(1,2,4,8)
+    ps=sorted(set(p for p,_ in old.FULL))
+    options=[]
+    for p in ps:
+        if mul(p,local)!=mul(local,p): continue
+        r=mul(p,local)
+        if old.rank(r)!=1: continue
+        other=add(identity,p)
+        options.append(((p,r),(other,add(local,r))))
+    good=[]
+    for j in range(g):
+        indices=(0,1,2+2*j,3+2*j)
+        good.append([tuple((embed(p,indices,n),embed(r,indices,n)) for p,r in pair) for pair in options])
+    bad=[]
+    for k in range(2):
+        c=1<<k
+        w=sum(1<<(2+2*j+k) for j in range(g))
+        p=add(outer(c,c,n),outer(w,w,n))
+        bad.extend([(p,outer(c,w,n)),(p,outer(w,c,n))])
+    total=(0,)*n
+    for choices in good: total=add(total,add(choices[0][0][1],choices[0][1][1]))
+    for _,r in bad: total=add(total,r)
+    if total!=tuple(1<<i for i in range(n)): raise ValueError('Bad query frame')
+    return good,bad
+
+
+def defects(good,bad,order,choice):
+    n=len(bad[0][0]); g=len(good)
+    out=[(0,)*n for _ in range(g+2)]
+    tail=(0,)*n
+    for c,k in reversed(order):
+        p,r=good[c][choice[c]][k] if c<g else bad[2*(c-g)+k]
+        out[c]=add(out[c],comm(p,tail))
+        tail=add(tail,r)
+    return tuple(packed(x) for x in out)
+
+
+def tables(good,bad,order):
+    g=len(good); z=[0]*g
+    base=defects(good,bad,order,z)
+    singles=[]
+    for c in range(g):
+        table=[]
+        for x in range(len(good[c])):
+            ch=z.copy();ch[c]=x
+            table.append(tuple(a^b for a,b in zip(defects(good,bad,order,ch),base)))
+        singles.append(table)
+    pairs={}
+    for c,d in itertools.combinations(range(g),2):
+        tab=[]
+        for x in range(len(good[c])):
+            row=[]
+            for y in range(len(good[d])):
+                ch=z.copy();ch[c]=x;ch[d]=y
+                val=defects(good,bad,order,ch)
+                row.append(tuple(a^b^u^v for a,b,u,v in zip(val,base,singles[c][x],singles[d][y])))
+            tab.append(row)
+        pairs[c,d]=tab
+    return base,singles,pairs
+
+
+def search_order(good,bad,order):
+    base,singles,pairs=tables(good,bad,order)
+    g=len(good)
+    # Concatenate all stage defects. Every bit must be zero.
+    n=len(bad[0][0]); stride=n*n
+    join=lambda x:sum(v<<(stride*j) for j,v in enumerate(x))
+    b=join(base)
+    s=[[join(x) for x in tab] for tab in singles]
+    p={cd:[[join(x) for x in row] for row in tab] for cd,tab in pairs.items()}
+    survivors=[]
+    if g==3:
+        for x in range(len(s[0])):
+            for y in range(len(s[1])):
+                val=b^s[0][x]^s[1][y]^p[0,1][x][y]
+                for z in range(len(s[2])):
+                    if val^s[2][z]^p[0,2][x][z]^p[1,2][y][z]==0:
+                        survivors.append((x,y,z))
+        return survivors
+    raise ValueError('This exhaustive entry point uses three leaves.')
+
+
+def main():
+    good,bad=frame(3);g=3; start=time.monotonic()
+    print(json.dumps({'options_per_stage':len(good[0]),'frame_fields':8,'calls':10}),flush=True)
+    records=[]
+    first=[(j,0) for j in range(g)]
+    bad_calls=[(3,0),(3,1),(4,0),(4,1)]
+    # First occurrences are in canonical order. Test all second sweeps and all
+    # connector orders between the sweeps. This does not cover every order.
+    for second in itertools.permutations(range(g)):
+        for connectors in itertools.permutations(bad_calls):
+            order=first+list(connectors)+[(j,1) for j in second]
+            survivors=search_order(good,bad,order)
+            rec={'order':order,'chronology_survivors':len(survivors),'examples':survivors[:4]}
+            records.append(rec)
+            if survivors: print(json.dumps(rec),flush=True)
+        print(json.dumps({'second_sweep':second,'orders_done':len(records),'elapsed_seconds':round(time.monotonic()-start,2)}),flush=True)
+    report={'scope':'All coupled centralizer splits of the fixed star query frame, three leaves, two sweeps with four fixed connectors in between','options_per_stage':len(good[0]),'orders':len(records),'assignments_per_order':len(good[0])**3,'survivors':sum(r['chronology_survivors'] for r in records),'records':records}
+    Path(__file__).with_name('STAR-SEARCH.json').write_text(json.dumps(report,indent=2)+'\n')
+
+if __name__=='__main__': main()
diff --git a/research/longer-coupled-port-caller/verify.py b/research/longer-coupled-port-caller/verify.py
new file mode 100644
index 0000000000..08217f77da
--- /dev/null
+++ b/research/longer-coupled-port-caller/verify.py
@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""Verify the coupled-star exclusion and its exact controls.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+import sys
+
+PACKAGE=Path(__file__).resolve().parent
+ROOT=PACKAGE.parents[1]
+
+
+def require(test,message):
+    if not test:raise ValueError(message)
+
+
+def local(name):
+    spec=importlib.util.spec_from_file_location(name,PACKAGE/(name+'.py'))
+    module=importlib.util.module_from_spec(spec);spec.loader.exec_module(module)
+    return module
+
+
+def bound_power(rank,bits=48):
+    # Enclose rank^(319/320) by integer powers only.
+    scale=1<<bits;goal=pow(rank,319)<<(320*bits);lo=0;hi=rank*scale+1
+    while hi-lo>1:
+        mid=(lo+hi)//2
+        if pow(mid,320)<=goal:lo=mid
+        else:hi=mid
+    return lo,lo if pow(lo,320)==goal else lo+1
+
+
+def pricing():
+    source=json.loads((ROOT/'research/p104-helper-subspace-splits/RESULT.json').read_text())['local']
+    net={int(r):v for r,v in source['paid'].items()}
+    for r,v in source['helpers'].items():net[int(r)]=net.get(int(r),0)-v
+    require(sum(r*v for r,v in net.items())==1720,'Pinned full rank mass')
+    g=1023;q=104;coeff={r:-2*(g+2)*v for r,v in net.items()}
+    coeff[8*g+1]=coeff.get(8*g+1,0)+2*q;coeff[9]=coeff.get(9,0)+2*q*g
+    lower=upper=0
+    for r,count in coeff.items():
+        lo,hi=bound_power(r)
+        lower+=count*(lo if count>=0 else hi)
+        upper+=count*(hi if count>=0 else lo)
+    require(lower>0,'The excluded relaxed profile must pass its price screen')
+    require(20000000>320*62009,'Screen saving exceeds the refreshed selected saving')
+    h=104*8-720
+    require(8*(h-104)<h,'Eight-call query frame rejection')
+    return {'supplier':'PR5599 09dd0965711ca7eeb169057a420abab1c9052137','net_rank_mass':1720,'excluded_relaxation':{'q':q,'g':g,'full_calls':2*g+4,'main_fields':2*q*(g+1),'main_targets':{str(8*g+1):2*q,'9':2*q*g},'saving':'1/320','moment_interval_numerators':[str(lower),str(upper)],'denominator':str(1<<48),'status':'POSITIVE_PRICE_SCREEN_BUT_NO_CALLER_IN_THE_DECLARED_FRAME'},'rejected_eight_call_frame':{'q':104,'L':8,'N':720,'h':h,'left':8*(h-104),'right':h}}
+
+
+def run():
+    sources=json.loads((PACKAGE/'SOURCES.json').read_text())
+    inputs=[row for row in sources['files'] if row['usage']=='input']
+    for row in inputs:
+        require(hashlib.sha256((ROOT/row['path']).read_bytes()).hexdigest()==row['sha256'],'Source digest: '+row['path'])
+    checker=local('check_certificates')
+    result={'status':'PASS_ALL_ORDER_COUPLED_STAR_EXCLUSION','scope':'All odd g>=3, all positive channel dimensions, all characteristic-two fields, all call orders; fixed star queries and four complementary connectors','authenticated_inputs':len(inputs),'certificate_check':checker.verify(),'matrix_controls':local('model_checks').run(checker),'pricing':pricing(),'limits':['No native or characteristic-zero reduction','No new kappa','Other query frames and connector contracts are not excluded','No proof-assistant or independent human acceptance']}
+    encoded=json.dumps(result,indent=2,sort_keys=True)+'\n'
+    if '--write-result' in sys.argv:(PACKAGE/'RESULT.json').write_text(encoded)
+    else:require((PACKAGE/'RESULT.json').read_text()==encoded,'Committed result differs from replay')
+    print(encoded,end='')
+
+if __name__=='__main__':run()