diff --git a/research/single-connector-cap-obstruction-seed653bd5/CLAIM.md b/research/single-connector-cap-obstruction-seed653bd5/CLAIM.md
new file mode 100644
index 0000000000..f13d5f5f98
--- /dev/null
+++ b/research/single-connector-cap-obstruction-seed653bd5/CLAIM.md
@@ -0,0 +1,19 @@
+# Claim and coordination
+
+**CLAIM — recursive interfaces, refined to one framed accumulator.**
+
+- Seed: `653bd5f4eaffb9d44cab3bdd1378ae10`; catalogue task: `connector-alphabet-change`; scope key: `ff4f5113ed2256ab19ed`; priority revision: 3.
+- Base: `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; selected-record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`.
+- Object: the eight independent external inputs and four late additive ports of each fixed block in `research/complex-block-rank-optimum/CERTIFICATE.json`.
+- Question: can one extra dirty array, with a monotone frame, receive all eight external inputs and supply the two required output incidences of each input while all four target arrays retain their distinct rank-eight terminal caps?
+- Changed premise: add one physical accumulator and route the external-source `Qz` terms through that single array. Existing helpers may retain the `Ry` and dirty-endpoint work but may not carry `Qz`; there is no direct source-to-target route or second `Qz` accumulator. Sources stay read-only, targets stay additive, and frames do not descend.
+- Method and domain: exact F2-subspace joins from the 12 selected source blocks, with the two 12-block PR1319 words as pinned comparison controls; four output caps per block. Use an exact obstruction before considering scalar schedules or recursive prices.
+- Nearby work: PR #1522 / Discussion #1493 share centered dyadic BIT outputs in a different source-tour alphabet; PR #1717 shares a paired rank-eight output delta; PR #1739 changes a connector source/map transition. Generic source tours and alphabet searches are not claimed here. The refreshed overlap scan at 2026-10-14 09:28:19 UTC covered 442 open PRs and 407 Discussion/comment/reply records, complete pagination and no warnings; no direct prior frame-join/cap match appeared.
+- Additional close predecessor: PR #781 / PR #855 and local `research/complex-packet-borrowing23` use one coded helper for a distinct six-source all-K packet cell and account its native provider bill. Here the proposed single accumulator must receive all eight independent external inputs in each selected late block; the new question is whether that full span can ever reach the four retained caps.
+- Expected result: a source-pinned proof and exact checker for feasibility or a scoped interface obstruction, including a feasible-frame positive control and cap-mutation negative control. No new kappa is expected.
+- Optimistic cost screen: if a required final source-to-port update is frame-incompatible, the one-connector route has no feasible finite bill even before charging its extra child, so a large search is unwarranted.
+- Expiry: `2026-10-14 11:20 UTC`.
+
+Discussion claim URL: https://github.com/CrocSwap/integer-mult-bounds/discussions/1771
+
+This is not an independent audit of the selected construction. It tests a new one-accumulator route against the selected block's exact frames and retained target contract.
diff --git a/research/single-connector-cap-obstruction-seed653bd5/PR-BODY.md b/research/single-connector-cap-obstruction-seed653bd5/PR-BODY.md
new file mode 100644
index 0000000000..f736f08a07
--- /dev/null
+++ b/research/single-connector-cap-obstruction-seed653bd5/PR-BODY.md
@@ -0,0 +1,37 @@
+## Result
+
+Scoped negative result for one added dirty accumulator in the selected late complex block. If the single added array reads all eight independent external inputs and is the sole carrier of their `Qz` terms to the four retained additive ports, monotone frame growth makes the route infeasible: the joined input frame is not contained in any rank-eight target cap. Existing helpers may still carry the retained `Ry` and dirty-endpoint work, but cannot store external `Qz` terms. The last external input contributes to two distinct ports, so after the connector has read all eight inputs at least one required output update would force its target to rank nine.
+
+The exact checker covers the 12 blocks in the selected word and 24 blocks from two pinned PR1319 comparison words: 36 block instances and 144 target-cap pairs. Every pair has `dim(span(F_1,...,F_8) + H_j) = 9`; the six rank-eight joins across the three words also differ from every cap. No scalar schedule, gate count or connector tour can evade this frame obstruction inside the stated class.
+
+This is not a general connector lower bound, a result about multiple `Qz` accumulators or direct source-to-target routes, a selected-supplier replacement, or a new `kappa`.
+
+## Provenance and scope
+
+The exact base is `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; the selected-record SHA-256 is `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. `SOURCES.json` pins the selected review, source manifest, assembly certificate, task catalogue, block certificate and compressed block sources.
+
+The closest neighboring constructions are PR #1522's centered BIT source tour, PR #1717's paired dirty-output delta, PR #1739's source/map transition, and PR #781/#855's separate six-source coded-helper packet cell and provider-cost analysis. Those results and their authors remain credited; this result is only the all-eight-input frame-join obstruction for the selected four-port block interface.
+
+## Reproduction
+
+From the repository root:
+
+```sh
+python3 -I -B research/single-connector-cap-obstruction-seed653bd5/verify.py
+python3 -I -B research/complex-block-rank-optimum/verify.py
+python3 scripts/research_package.py --package research/single-connector-cap-obstruction-seed653bd5 --check-only
+make selected-record-check
+```
+
+The local replay passed on Python 3.14.7:
+
+```text
+PASS_SINGLE_CONNECTOR_CAP_OBSTRUCTION selected_blocks=12 selected_pairs=48 all_blocks=36 all_pairs=144 rank8_joins=6 rank9_joins=30 positive_control=1 cap_mutation_rejected=1
+PASS_FIXED_BLOCK_MOMENT_PREMISES blocks=36 subsets=9180 minors=36 controls=12
+PASS_PACKAGE_METADATA_AND_PINS (not a mathematical acceptance check)
+PASS selected record, exact kappa, original source inventory and proof supplement: 836330098538459/500000000000000000
+```
+
+The full research-package wrapper is configured for Python 3.12; the generic metadata check and direct verifiers were run locally. No full selected-construction cold replay is claimed.
+
+Authored by Cinna Davis with substantial OpenAI Codex assistance in scoping, proof development, exact verification, source handling and writing.
diff --git a/research/single-connector-cap-obstruction-seed653bd5/PROOF.md b/research/single-connector-cap-obstruction-seed653bd5/PROOF.md
new file mode 100644
index 0000000000..eabfb990f1
--- /dev/null
+++ b/research/single-connector-cap-obstruction-seed653bd5/PROOF.md
@@ -0,0 +1,91 @@
+# A single framed accumulator cannot serve all four late ports
+
+## Statement
+
+Fix one block interface in `research/complex-block-rank-optimum/CERTIFICATE.json`.
+Let its eight independent read-only external inputs have frames
+`F_1,...,F_8`, and let its four additive targets end at the distinct
+rank-eight caps `H_1,...,H_4`. The required external-input contribution is the
+four-by-eight rational matrix `Q` in the certificate. Every column of `Q` has
+nonzero entries at exactly two distinct output ports.
+
+Consider the following added resource and no other routing change: one extra
+array `c` receives all eight external inputs and is the sole carrier of their
+`Qz` contributions to the four targets. Its frame grows only by inclusion.
+The existing helper values and `Ry` contributions may follow their retained
+route, but no existing helper can become an alternate carrier of `Qz`. Inputs
+are read-only; targets are additive and retain their certified final caps;
+there is no direct input-to-target operation, second `Qz` accumulator, target
+scratch, or frame descent.
+
+For every one of the 12 selected-word blocks, and also for each of the 24
+blocks in the two pinned PR1319 comparison words, this route is infeasible.
+This is a fixed-interface obstruction. It does not rule out multiple
+accumulators, direct source-to-target routes, earlier target access, or changed
+caps.
+
+## Proof
+
+Put `S = F_1 + ... + F_8`. When `c` is updated from an input at frame `F_i`,
+the common operation frame must contain both the current frame of `c` and
+`F_i`. Monotonicity therefore leaves the connector frame containing every
+input frame after all eight independent values have been read. In particular,
+its frame `C` then contains `S`.
+
+Choose the last external input whose value is first incorporated into `c`.
+Its column of `Q` is nonzero at two distinct targets. Since that input is
+independent and the one connector is the sole carrier, both target increments
+still require a later operation that transfers information from `c`. For any
+such operation on target `j`, the common frame contains `C`, and hence `S`.
+The target frame also grows to that common frame. Because target frames only
+grow and the final frame is `H_j`, a legal update must keep its common frame
+inside `H_j`. Thus a necessary condition is `S ⊆ H_j`.
+
+The certificate's exact binary spans give, for every block and every output
+cap,
+
+```text
+dim(S + H_j) = 9,       dim(H_j) = 8.
+```
+
+So `S` is not contained in any `H_j`; every required connector-to-target
+update would force the target to rank nine and violate its endpoint. This
+contradicts the required nonzero two-port contribution of the last input.
+The contradiction is independent of scalar coefficients and gate count.
+
+The conclusion also holds if the connector reads inputs more than once or
+changes its scalar value between reads: its frame cannot forget a frame it
+has already visited. Reading the final independent input and writing through
+the connector are distinct two-array operations, so the required target
+update occurs after the connector contains `S`.
+
+## Exact certificate check
+
+`verify.py` recomputes ranks over the nine-dimensional binary frame space from
+the pinned certificate. It checks all eight input frames contain the common
+frame, all eight columns of `Q` have weight two, all four caps have rank eight,
+and all 144 input-join/cap pairs force a rank-nine common frame. There are 12
+selected blocks and 24 comparison blocks. In the selected blocks, the source
+join has rank eight in bases 592 and 696 and rank nine in the other ten blocks;
+the rank-eight joins still differ from every target cap.
+
+The verifier also checks that its containment predicate accepts a synthetic
+cap containing the source join and that it rejects a rank-mutated target cap.
+The source certificate is pinned by SHA-256 and its predecessor's exact
+source-bound verifier is run separately.
+
+## Complete-cost screen and limits
+
+There is no feasible completed cost for this one-connector route under the
+stated endpoint contract. Charging source reads, the extra connector's
+hosting/restoration children, output updates, precision or tape cannot repair
+the frame contradiction; charging the necessary rank-nine target climb
+violates the cap. The screen therefore stops before any scalar schedule or
+recursive-moment search. No improvement to the selected paid moment or `kappa`
+is claimed.
+
+This does not bound a design with two or more accumulators, does not establish
+a global lower bound for the complex supplier, and does not modify the
+selected construction. It is a scoped negative result for one additional
+monotone accumulator routing all eight external source columns through the
+four retained late target caps.
diff --git a/research/single-connector-cap-obstruction-seed653bd5/README.md b/research/single-connector-cap-obstruction-seed653bd5/README.md
new file mode 100644
index 0000000000..4525e26ae9
--- /dev/null
+++ b/research/single-connector-cap-obstruction-seed653bd5/README.md
@@ -0,0 +1,86 @@
+# One framed connector cannot reach the selected block's late ports
+
+**Scoped recursive-interface obstruction; no new `kappa`.** In each of the 12
+selected late blocks, the join of the eight read-only input frames is not
+contained in any of the four retained rank-eight target caps. A single
+monotone accumulator that reads all eight inputs must therefore force a
+rank-nine target climb before it can deliver the last source contribution.
+The target endpoint forbids that climb.
+
+The obstruction is checked over the 12 selected-word blocks and 24 pinned
+blocks from the PR1319 base/extra words: **36 blocks, 144 target-cap pairs**.
+Every pair has `dim(span(F_1,...,F_8) + H_j) = 9`. The selected input join has
+rank eight in blocks 592 and 696 and rank nine in the other ten blocks; none
+of the four target caps contains it in either case.
+
+This tests one added physical accumulator as the sole carrier for the eight
+external `Qz` terms of the four-output correction. The retained helper route
+may still carry `Ry` and dirty endpoint information, but cannot act as another
+`Qz` carrier. It does not cover
+multiple accumulators, direct input-to-target operations, target retiming, or
+different endpoint caps. It is not a general connector lower bound, selected
+supplier replacement, or exponent improvement.
+
+The accepted selected record remains
+`836330098538459/500000000000000000` (`0.001672660197076918`). The source record
+is pinned by SHA-256
+`10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32` at base
+`0b1cccf86e2f5132ed286a26ef0a681a495740ea`. Its review, source manifest,
+assembly certificate and reproduction command are separately pinned in
+`SOURCES.json`.
+
+## Reproduce
+
+From the repository root with Python 3.12 or later and no third-party
+dependencies:
+
+```sh
+python3 -I -B research/single-connector-cap-obstruction-seed653bd5/verify.py
+python3 -I -B research/complex-block-rank-optimum/verify.py
+python3 scripts/research_package.py --package research/single-connector-cap-obstruction-seed653bd5 --check-only
+make selected-record-check
+```
+
+The first command prints:
+
+```text
+PASS_SINGLE_CONNECTOR_CAP_OBSTRUCTION selected_blocks=12 selected_pairs=48 all_blocks=36 all_pairs=144 rank8_joins=6 rank9_joins=30 positive_control=1 cap_mutation_rejected=1
+```
+
+The predecessor checker prints `PASS_FIXED_BLOCK_MOMENT_PREMISES` and checks
+the stored source-bound certificate. The package metadata command checks
+source pins; it is not a mathematical acceptance check. No full selected
+construction replay is part of this contribution.
+
+## Coordination and nearby results
+
+The focused claim is [Discussion #1771](https://github.com/CrocSwap/integer-mult-bounds/discussions/1771).
+The 2026-10-14 09:28 UTC overlap refresh covered 442 open PRs and 407
+Discussion/comment/reply records with complete pagination and no warnings.
+The refreshed records showed related but different work: [PR #1522's centered
+BIT source tour](https://github.com/CrocSwap/integer-mult-bounds/discussions/1493),
+[PR #1717's paired dirty-output delta](https://github.com/CrocSwap/integer-mult-bounds/pull/1717),
+and [PR #1739's source/map transition](https://github.com/CrocSwap/integer-mult-bounds/pull/1739).
+The close geometric predecessor is [PR #781's six-source coded helper](https://github.com/CrocSwap/integer-mult-bounds/pull/781)
+and its provider-cost follow-up [PR #855](https://github.com/CrocSwap/integer-mult-bounds/pull/855),
+documented in `research/complex-packet-borrowing23`. That construction serves
+a separate all-K packet cell with one coded helper and multiple target pairs;
+this result tests the full join of all eight independent inputs in a selected
+four-port late block. No priority claim is made for source tours, coded helpers
+or connector extensions generally.
+
+The frame data and source-specific interface come from
+`research/complex-block-rank-optimum`, whose proof credits Thomas DiFiore's
+helper-basis screen and Douglas Colkitt's fixed-word packing work. The generic
+dirty-connector interface descends from Ross Richardson's PR #934. This result
+adds only the frame-join/cap incompatibility lemma and its exact replay.
+
+## Open next questions
+
+- Can two or more accumulators partition the external inputs so each partial
+  source join lies in the caps of the targets it must still serve? A first
+  step is to specify the partition, each frame itinerary, and all transfers,
+  then compute a complete hosting/restoration bill.
+
+Authored by Cinna Davis with substantial OpenAI Codex assistance in scoping,
+proof development, exact verification and exposition.
diff --git a/research/single-connector-cap-obstruction-seed653bd5/SOURCES.json b/research/single-connector-cap-obstruction-seed653bd5/SOURCES.json
new file mode 100644
index 0000000000..ccc2192add
--- /dev/null
+++ b/research/single-connector-cap-obstruction-seed653bd5/SOURCES.json
@@ -0,0 +1,90 @@
+{
+  "schema_version": 1,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1",
+      "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075"
+    },
+    {
+      "path": "docs/research/community-batch1099-review.md",
+      "usage": "provenance",
+      "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099",
+      "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb"
+    },
+    {
+      "path": "research/community-frontier1094-audit/ASSEMBLY.json",
+      "usage": "provenance",
+      "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0",
+      "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045"
+    },
+    {
+      "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json",
+      "usage": "provenance",
+      "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8",
+      "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/CERTIFICATE.json",
+      "usage": "input",
+      "git_blob": "59a9863fa8d823524cd42b6845c548089b6ef694",
+      "sha256": "d3ada9ac84a74f72ce9364dd47ee2ab9f02d1a6513df135e81dad11d0e6c6958"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/INPUTS.json",
+      "usage": "input",
+      "git_blob": "1fc0a9fb55e0bdb841ba457c9b92c6bdf496971d",
+      "sha256": "fef08f8a18429f1b68c5eb8657c7fbfc84492752e9639ae97e570a16f87490fe"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/README.md",
+      "usage": "input",
+      "git_blob": "77bd353fdadbfe7fea2fbca725e4ad04e9091d88",
+      "sha256": "f14fe8cee84ff43c8656e553885fc9cf2570e91fb794523343a3c2528905f835"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/inputs/pr1319-base.json.gz",
+      "usage": "input",
+      "git_blob": "eacf8c773cb50637f93a762342b3b5f0853fe29a",
+      "sha256": "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/inputs/pr1319-extra.json.gz",
+      "usage": "input",
+      "git_blob": "4d464f55a2955e5c832b5ce789d5d0e0a39fb4e1",
+      "sha256": "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/inputs/selected-programs.json.gz",
+      "usage": "input",
+      "git_blob": "4eed995798f4aaa8efdd6f788dd07b3723940a81",
+      "sha256": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/inputs/selected.json.gz",
+      "usage": "input",
+      "git_blob": "5f9ef680983b0b63a4c82a4ed909837b78e690cd",
+      "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/verify.py",
+      "usage": "input",
+      "git_blob": "5b08fcad862e6bd35d491bf49894e475396320b3",
+      "sha256": "3741b64dc76f771b74f06c80d4dfcbb6263bf34a790478640d813b59f8b38a3d"
+    },
+    {
+      "path": "research/universal-connector-boundary/README.md",
+      "usage": "provenance",
+      "git_blob": "d277f7c5830b1f2bc42e1ff41ab86e7d7564929f",
+      "sha256": "23415f7829ab8d80a783142f10f7d31abbce84579362769984680af3df954476"
+    }
+  ]
+}
diff --git a/research/single-connector-cap-obstruction-seed653bd5/TASK.json b/research/single-connector-cap-obstruction-seed653bd5/TASK.json
new file mode 100644
index 0000000000..87ab346cf0
--- /dev/null
+++ b/research/single-connector-cap-obstruction-seed653bd5/TASK.json
@@ -0,0 +1,72 @@
+{
+  "schema_version": 1,
+  "task_id": "connector-alphabet-change",
+  "priority_revision": 3,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "original_card": {
+    "id": "connector-alphabet-change",
+    "question": "Does one explicit extension of the connector alphabet offer a favorable completed budget?",
+    "starting_points": [
+      "research/universal-connector-boundary/README.md",
+      "certificates/selected-result.json"
+    ],
+    "methods": [
+      "Construct and charge a legal extra operation on a minimal instance.",
+      "Prove a target-specific bound after adding one specified operation family."
+    ],
+    "acceptance_gate": "State which fixed-alphabet premise changes and charge its implementation; do not declare it free.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/universal-connector-boundary/verify.py"
+      ],
+      "expected": "PASS_UNIVERSAL_CONNECTOR_BOUNDARY",
+      "inspect": "Reproduce the 945-pairing control, then read Exact interface to list the allowed calls.",
+      "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Add exactly one legally priced operation and test a tiny dirty-input instance before enumerating larger cases.",
+    "bottleneck_link": "A new legal connector operation could change recursive interface cost; a larger census in the same alphabet is a separate side result.",
+    "allowed_variations": [
+      "Choose one additional operation and a small source count for its first counterexample."
+    ],
+    "scope_change_triggers": [
+      "Keeping the alphabet and only increasing the source count; record this as a changed assignment."
+    ],
+    "overlap_terms": [
+      "universal connector",
+      "source-toggle",
+      "connector alphabet"
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Test whether one additional monotone dirty connector array can receive all eight independent external source columns in a fixed four-output late complex block and act as the sole carrier of their Qz terms to the two required ports per input, while the four targets retain their distinct rank-eight terminal caps. Existing helper values and R y terms may follow their retained route, but cannot become alternate carriers of Qz. The question is frame feasibility for the exact selected block interface, not a universal Boolean source-tour census.",
+  "scope_change_reason": "The added resource is an extra physical accumulator with a monotone frame, rather than only a new abstract scalar-call symbol. This tests whether the fixed rational source-to-output incidence can be hosted under the selected block's input and target frames; it is geometrically distinct from universal connector-mask or source-tour enumeration.",
+  "overlap": {
+    "checked_at": "2026-10-14T09:28:19Z",
+    "coverage": "442 open PRs and 407 Discussion/comment/reply records, complete pagination, no warnings; exact frame-cap and selected-block terms had no direct prior remote match",
+    "nearest_work": [
+      "Discussion #1493 / PR #1522: centered dyadic BIT outputs share a restored source tour; its domain and frames differ.",
+      "PR #1717: paired dirty scalar outputs share one rank-eight child delta; it does not collect eight framed inputs into one connector.",
+      "PR #1739: a connector transition changes the source/map contract across calls; it does not use selected-block input joins or terminal caps.",
+      "PR #781 / PR #855 and research/complex-packet-borrowing23: one coded helper serves a separate six-source all-K packet cell and its complete provider bill; this scope forces one array to receive all eight independent selected-block inputs and tests the four late caps before scalar scheduling.",
+      "Discussion #1587: target-cap terminology appears in a plane-port unpaid-coordinate question, with a different template and object."
+    ],
+    "distinction": "No direct selected-block frame-join claim appeared in the refreshed records. The generic source-tour family and the separate coded-helper construction are credited; this contribution only tests the single-array all-input route against the selected block's 36 exact source/cap interfaces."
+  },
+  "bottleneck_link": "A feasible one-row accumulator might reuse source-to-output information, but its full source join must still admit the late target writes and one extra recursively hosted array. If the retained caps make even the one-row route infeasible, there is no finite completed bill in this restricted class.",
+  "budget_minutes": 60,
+  "stop_rule": "Check the exact span join and cap compatibility on all 12 selected blocks (and the 24 pinned predecessor controls); stop immediately if the final required source contribution cannot reach its output without a rank-nine target climb. No gate search or kappa claim follows an interface obstruction.",
+  "outcome": "negative-result",
+  "evidence": "PROOF.md and verify.py: exact rank and cap-containment checks over 36 pinned block certificates, plus feasible-frame and cap-mutation controls.",
+  "author": "Cinna Davis with substantial OpenAI Codex assistance",
+  "ai_assistance": "Substantial OpenAI Codex assistance in scoping, exact frame analysis, checker implementation, verification and exposition.",
+  "open_questions": [
+    {
+      "question": "Can two or more accumulators partition the external sources so each accumulated frame remains in the caps of its remaining output ports?",
+      "why_it_matters": "A partitioned design could avoid the single-array join obstruction, but adds connector hosting, transfers, restoration and possibly target retiming.",
+      "first_step": "State the exact source partition, per-connector frame itinerary, and which target ports each connector serves before pricing it.",
+      "blocked_by": "The one-connector negative result supplies no lower bound for multiple connectors or direct source-to-target routes."
+    }
+  ]
+}
diff --git a/research/single-connector-cap-obstruction-seed653bd5/VERIFY.json b/research/single-connector-cap-obstruction-seed653bd5/VERIFY.json
new file mode 100644
index 0000000000..4eabe0ad2e
--- /dev/null
+++ b/research/single-connector-cap-obstruction-seed653bd5/VERIFY.json
@@ -0,0 +1,38 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/complex-block-rank-optimum/CERTIFICATE.json",
+    "research/complex-block-rank-optimum/README.md",
+    "research/complex-block-rank-optimum/INPUTS.json",
+    "research/complex-block-rank-optimum/verify.py",
+    "research/complex-block-rank-optimum/inputs/selected.json.gz",
+    "research/complex-block-rank-optimum/inputs/pr1319-base.json.gz",
+    "research/complex-block-rank-optimum/inputs/pr1319-extra.json.gz",
+    "research/complex-block-rank-optimum/inputs/selected-programs.json.gz"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Exact 36-block frame join/cap obstruction, two-port incidence, synthetic positive containment control and target-cap rank mutation rejection"
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "research/complex-block-rank-optimum/verify.py"
+      ],
+      "timeout_seconds": 240,
+      "checks": "Pinned predecessor source-bound block premises and certificate controls"
+    }
+  ]
+}
diff --git a/research/single-connector-cap-obstruction-seed653bd5/verify.py b/research/single-connector-cap-obstruction-seed653bd5/verify.py
new file mode 100644
index 0000000000..0a62f975e2
--- /dev/null
+++ b/research/single-connector-cap-obstruction-seed653bd5/verify.py
@@ -0,0 +1,125 @@
+"""Recheck the one-connector frame obstruction from pinned block certificates."""
+
+import hashlib
+import json
+from pathlib import Path
+
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+CERT_PATH = ROOT / "research/complex-block-rank-optimum/CERTIFICATE.json"
+CERT_SHA256 = "d3ada9ac84a74f72ce9364dd47ee2ab9f02d1a6513df135e81dad11d0e6c6958"
+
+
+def basis(values):
+    pivots = {}
+    for value in values:
+        value = int(value)
+        if value < 0 or value >= 512:
+            raise ValueError("frame vector is outside F2^9")
+        while value:
+            pivot = value.bit_length()
+            if pivot in pivots:
+                value ^= pivots[pivot]
+            else:
+                pivots[pivot] = value
+                break
+    return tuple(pivots[p] for p in sorted(pivots, reverse=True))
+
+
+def rank(values):
+    return len(basis(values))
+
+
+def contained(subspace, cap):
+    return rank(tuple(subspace) + tuple(cap)) == rank(cap)
+
+
+def valid_cap(cap):
+    return rank(cap) == 8
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def check_block(block):
+    inputs = block["input_frames"]
+    caps = block["target_caps"]
+    common = block["common_frame"]
+    R, Q = block["R"], block["Q"]
+    require(len(inputs) == 8 and len(caps) == 4, "unexpected block dimensions")
+    require(len(R) == 4 and all(len(row) == 4 for row in R), "bad helper matrix")
+    require(len(Q) == 4 and all(len(row) == 8 for row in Q), "bad external matrix")
+    require(all(contained(common, frame) for frame in inputs), "input misses common frame")
+
+    for column in range(8):
+        support = [row for row in range(4) if Q[row][column] != "0"]
+        require(len(support) == 2 and support[0] != support[1],
+                "external input does not have two distinct output incidences")
+
+    source_join = basis(vector for frame in inputs for vector in frame)
+    source_rank = len(source_join)
+    require(8 <= source_rank <= 9, "unexpected external-input join rank")
+    for cap in caps:
+        require(valid_cap(cap), "target cap does not have rank eight")
+        require(rank(source_join + tuple(cap)) == 9,
+                "source join is compatible with a retained target cap")
+    return source_rank
+
+
+def main():
+    raw = CERT_PATH.read_bytes()
+    require(hashlib.sha256(raw).hexdigest() == CERT_SHA256,
+            "pinned block certificate hash mismatch")
+    cert = json.loads(raw)
+    sources = cert["sources"]
+    require(len(sources) == 3, "expected selected and two comparison source sets")
+    require(sources[0]["file"] == "inputs/selected.json.gz",
+            "selected-word source is not first in certificate")
+
+    counts = {8: 0, 9: 0}
+    selected_pairs = all_pairs = 0
+    blocks_seen = 0
+    for source_index, source in enumerate(sources):
+        blocks = source["blocks"]
+        require(len(blocks) == 12, "expected twelve blocks per pinned source word")
+        for block in blocks:
+            source_rank = check_block(block)
+            counts[source_rank] += 1
+            blocks_seen += 1
+            all_pairs += 4
+            if source_index == 0:
+                selected_pairs += 4
+    require(blocks_seen == 36 and selected_pairs == 48 and all_pairs == 144,
+            "coverage count mismatch")
+
+    # Positive control: a cap that contains the same source join is accepted.
+    control_join = basis((1, 2, 4))
+    require(contained(control_join, control_join),
+            "positive containment control was rejected")
+
+    # Negative control: deleting one independent vector from a real cap must
+    # fail the retained rank-eight endpoint check.
+    selected_cap = sources[0]["blocks"][0]["target_caps"][0]
+    reduced_cap = basis(selected_cap)[:-1]
+    require(rank(reduced_cap) == 7, "cap mutation did not reduce the rank")
+    try:
+        require(valid_cap(reduced_cap), "mutated cap should be rejected")
+    except ValueError:
+        cap_mutation_rejected = True
+    else:
+        raise ValueError("rank-seven target-cap mutation was accepted")
+
+    print(
+        "PASS_SINGLE_CONNECTOR_CAP_OBSTRUCTION "
+        f"selected_blocks=12 selected_pairs={selected_pairs} "
+        f"all_blocks={blocks_seen} all_pairs={all_pairs} "
+        f"rank8_joins={counts[8]} rank9_joins={counts[9]} "
+        "positive_control=1 cap_mutation_rejected=" + str(int(cap_mutation_rejected))
+    )
+
+
+if __name__ == "__main__":
+    main()