From 05670a6f57c975cbb4a89506c545837b30cccb56 Mon Sep 17 00:00:00 2001
From: Cinna Davis <1337isnot1337@users.noreply.github.com>
Date: Wed, 14 Oct 2026 22:57:43 -0500
Subject: [PATCH 1/4] Add nine-source Johnson-chain connector construction

---
 .../CLAIM.md                                  |  65 ++++++
 .../README.md                                 | 197 ++++++++++++++++++
 .../SOURCES.json                              | 132 ++++++++++++
 .../TASK.json                                 | 177 ++++++++++++++++
 .../VERIFY.json                               |  20 ++
 .../verify.py                                 | 182 ++++++++++++++++
 6 files changed, 773 insertions(+)
 create mode 100644 research/nine-source-johnson-chain-seed923edf/CLAIM.md
 create mode 100644 research/nine-source-johnson-chain-seed923edf/README.md
 create mode 100644 research/nine-source-johnson-chain-seed923edf/SOURCES.json
 create mode 100644 research/nine-source-johnson-chain-seed923edf/TASK.json
 create mode 100644 research/nine-source-johnson-chain-seed923edf/VERIFY.json
 create mode 100644 research/nine-source-johnson-chain-seed923edf/verify.py

diff --git a/research/nine-source-johnson-chain-seed923edf/CLAIM.md b/research/nine-source-johnson-chain-seed923edf/CLAIM.md
new file mode 100644
index 0000000000..71d70cb2f7
--- /dev/null
+++ b/research/nine-source-johnson-chain-seed923edf/CLAIM.md
@@ -0,0 +1,65 @@
+# Cycle 32 local research claim
+
+**Status:** LOCAL-ONLY; the authenticated GraphQL overlap refresh hung and was
+stopped after about two minutes, and the final pre-submission retry produced
+no output before timing out after 50 seconds at 03:56 UTC on 2026-10-15. A prior
+direct REST Discussions comment attempt returned 404. No public claim was
+posted.
+
+- **Track / task / seed:** `recursive-interfaces` / `connector-alphabet-change` /
+  `923edf31ad6e8cfdc58bb11a6c6d6b3d`.
+- **Exact base:** `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`.
+- **Catalogue / selected record:** revision 4; catalogue SHA256
+  `d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7`; selected
+  record SHA256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`.
+- **Question:** In the established singleton F2 dirty-connector alphabet, can
+  five separate dirty outputs with supports
+  `{01234, 01235, 01256, 01567, 05678}` be computed with nine read-only
+  sources at the complete-call floor? These five 5-subsets form a path in
+  `J(9,5)`, each step replacing one source, and their union is all nine
+  sources.
+- **Changed scope:** The selector card asks to add one connector operation.
+  This investigation adds no operation; it studies one explicit sparse
+  output-support family under the existing alphabet. It is a construction,
+  not a repeat of Cycle 31's eight-source full weight-four two-sweep census.
+- **Candidate screen:** The two-unpaid-coordinate coverage-law question is
+  already claimed in Discussion #1587. Centre-path hosting is claimed in
+  #1516 through 05:00 UTC, with older related nonadjacent-path records #1963
+  and #2058. The joint-query
+  lane has open PRs #2153 and #2268, including the immediately preceding
+  Cycle 30 contribution. The general connector lane has active GF(4) and
+  seven-source claims plus open alphabet/path PRs; this claim narrows it to a
+  different positive n=9, weight-five support chain with no new operation.
+- **Method / domain:** Use the source walk `0 → S1 → S2 → S3 → S4 → S5 → 0`,
+  toggle each symmetric difference, and read each `A_i` once at `q=0` and once
+  at `q=S_i`. Charge all B and A calls. Exhaust all `2^9` source assignments,
+  dirty connector bits and `2^5` dirty-output vectors. Stop after exact replay,
+  the lower-bound proof and the listed failure controls; no search over
+  unrelated support families.
+- **Favorable screen:** Optimistic floor and proposed schedule are both
+  `2*9 + 2*5 = 28` complete calls. Five independent restored row stars cost
+  `5*(2*5+2)=60`. The intended saving is 32 calls in this abstract interface;
+  under stable per-call source prices `c_j`, the weighted saving is exactly
+  `2*sum_j (d_j-1)c_j`, where `d=(5,4,3,2,1,4,3,2,1)`; A-call prices cancel.
+  Position-dependent transitions and concrete supplier placement remain
+  unpriced, so no recursive supplier or kappa is claimed.
+- **Expected evidence:** A standalone verifier, exact source/readout word,
+  arbitrary dirty-state replay, lower-bound argument, negative controls,
+  complete provenance pins, and a focused package PR if overlap remains clear.
+- **Relevant work and distinction:** PR #2271 (head
+  `95fd439596f72575d3869277c2d01aca1ca6ab6a`) is a 12-row bit-register Gray
+  tour through three masks, not this nine-source recursive B/A interface.
+  PR #2283 (head `21145202e9a27cd9b18ffc7e23383cc83461c4a0`) is Cycle 31's
+  negative result for the full n=8 weight-four shell under two complete
+  sweeps. PR #2229 covers n=7 weights 1--3; PR #2266 changes to GF(4) for two
+  sources. Active neighboring claims #2262 (GF(4)) and #2275 (seven-source
+  paired-call roots) do not use this mask family. Exact overlap terms returned
+  no direct remote match in a complete snapshot of 511 open PRs and 990
+  Discussions (PR data 03:42 UTC; Discussion data 03:26 UTC, 2026-10-15).
+- **Expiry:** 2026-10-15 05:45 UTC.
+
+The selected conditional result is `836330098538459/500000000000000000` at
+this base, reviewed in `docs/research/community-batch1099-review.md`; the
+selected assembly and source manifest are pinned in `SOURCES.json`. The
+selected supplier reproduction is `make frontier1094-verify`; it is not part
+of this connector-level experiment.
diff --git a/research/nine-source-johnson-chain-seed923edf/README.md b/research/nine-source-johnson-chain-seed923edf/README.md
new file mode 100644
index 0000000000..1b6e4d228a
--- /dev/null
+++ b/research/nine-source-johnson-chain-seed923edf/README.md
@@ -0,0 +1,197 @@
+# Nine-source Johnson-path connector construction
+
+**Exact connector-level construction; no selected-kappa change.** Five
+distinct dirty outputs on nine read-only F2 sources have supports
+`01234, 01235, 01256, 01567, 05678`. A single restored source path computes
+all five outputs in **28 complete calls**, meeting the general floor of two
+calls per active source and two per output. Five independent restored row
+stars cost 60 calls. The construction uses only the existing singleton
+connector alphabet and makes no supplier or multiplication-bound claim.
+
+Prepared by Cinna Davis with substantial OpenAI Codex assistance in scope
+selection, derivation, implementation and verification. No other contributor
+work is claimed. Apache-2.0.
+
+## Assignment, scope and coordination
+
+- Accepted seed: `923edf31ad6e8cfdc58bb11a6c6d6b3d`; track
+  `recursive-interfaces`; task `connector-alphabet-change`.
+- Excluded draw: `3c0e460e62633c4b16b5923d0f386d45` selected
+  `adversarial-audit` from the prior submitted branch, so it was discarded.
+- Exact base: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`; catalogue revision 4,
+  catalogue SHA256
+  `d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7`;
+  selected-record SHA256
+  `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`.
+- Scope changed from adding a connector operation to keeping the existing
+  alphabet and constructing one sparse support family. The exact local claim
+  is in [CLAIM.md](CLAIM.md). The generalization is limited to support paths
+  that introduce a fresh source at each one-element exchange.
+- Overlap: the complete cached snapshot held 511 open PRs and 990 Discussions
+  (no warnings); exact searches for the nine-source weight-five path returned
+  no remote matches. PR data was fetched at 03:42 UTC and Discussion data at
+  03:26 UTC on 2026-10-15. A newer GraphQL refresh hung and was stopped after
+  about two minutes. The final pre-submission refresh produced no output and
+  timed out after 50 seconds at 03:56 UTC on 2026-10-15, so the cached snapshot
+  was not refreshed. The nearest source-path result, PR #2271 at
+  `95fd439596f72575d3869277c2d01aca1ca6ab6a`, is a 12-row local bit-register
+  tour through three different masks. Cycle 31 PR #2283 at
+  `21145202e9a27cd9b18ffc7e23383cc83461c4a0` is a negative result for the
+  entire n=8 weight-four shell under two complete sweeps. PR #2229 studies n=7
+  weights 1--3; PR #2266 changes the alphabet to GF(4) for two sources.
+  Active nearby claims #2262 (GF(4)) and #2275 (seven-source paired-call root
+  counts) use different objects and support families.
+- Discussion claim status: local-only because the authenticated GraphQL
+  request hung, the final pre-submission refresh timed out without output, and
+  a prior direct REST Discussions comment attempt returned 404. Claim expiry
+  recorded in [CLAIM.md](CLAIM.md) is 2026-10-15 05:45 UTC.
+
+## Model and fully charged cost screen
+
+Use the pinned singleton F2 interface: `B_j: z += B_j x_j` for read-only
+sources `j=0,...,8`, and `A_i: y_i += A_i z` for five separate outputs. At
+entry, all source rows, targets and connector `z` are arbitrary and dirty.
+Each complete call restores its private scratch and tape heads. The interface
+and predecessor are pinned in [SOURCES.json](SOURCES.json), especially the
+[universal connector statement](../universal-connector-boundary/README.md).
+
+Before implementation, the target was 28 complete calls: every one of the
+nine active source maps must be toggled an even positive number of times to
+restore dirty `z`, so it costs at least 18 B calls. Every nonzero output map
+must be read an even positive number of times to cancel arbitrary dirty `z`,
+so five outputs cost at least ten A calls. The independent restored-row
+baseline is 60 calls: for each weight-five row, read its `A_i` at `q=0`,
+toggle five sources into `z`, read `A_i` at `q=S_i`, and toggle those five
+sources back, for `5+2+5=12` calls per row. The path below reaches 28 exactly,
+saving 32 complete calls (53 1/3%) in the unit-call model.
+
+For the lower bound, specialize every operator to scalar identity maps and
+vary one source and the dirty connector independently. Restoring `z` forces
+each active `B_j` count even, while producing every nonzero output and
+cancelling arbitrary `z` forces each `A_i` count even and positive. This
+gives `2*9 + 2*5` for any correct schedule in the stated alphabet.
+
+The same comparison holds with unequal **per-call** prices. Let `c_j > 0` be
+the complete price of `B_j`, `a_i > 0` the complete price of `A_i`, and
+`d_j` the number of outputs containing source `j`. Here
+`d=(5,4,3,2,1,4,3,2,1)`. The shared path costs
+`2 sum_j c_j + 2 sum_i a_i`; independent row stars cost
+`2 sum_j d_j c_j + 2 sum_i a_i`. Thus the exact saving is
+`2 sum_j (d_j-1)c_j > 0`. Readout prices cancel; the saving comes from
+source maps that occur in multiple rows. This weighted invoice charges each
+complete B/A call, including its recursive child bill when such a bill is
+assigned. It assumes a call's price is stable across positions in the word.
+
+The path adds no clean rows, copies, helper operations or separate frames, and
+returns `z` to its dirty entry value. The abstract connector model has no
+position-dependent frame-transition charge. A concrete supplier would still
+need its actual child prices, any schedule-dependent transition or host cost,
+precision and tape bill, and a placement proof. This local cost reduction is
+not a kappa claim.
+
+## Construction
+
+Let the five supports be
+
+```text
+S1 = {0,1,2,3,4}
+S2 = {0,1,2,3,5}
+S3 = {0,1,2,5,6}
+S4 = {0,1,5,6,7}
+S5 = {0,5,6,7,8}.
+```
+
+They form a path in `J(9,5)`: each next support removes one current source
+and introduces a source not used before. Their union is all nine sources, and
+only source 0 is common to all five outputs; the route does not rely on a
+large shared core.
+The source word follows the parity states
+
+```text
+0 -> S1 -> S2 -> S3 -> S4 -> S5 -> 0
+```
+
+by toggling each symmetric difference:
+
+```text
+B0 B1 B2 B3 B4 | B4 B5 | B3 B6 | B2 B7 | B1 B8 | B0 B5 B6 B7 B8
+```
+
+At the initial `q=0` prefix, call each `A_i` once. At the later prefix
+`q=S_i`, call that same `A_i` once more. The resulting full schedule uses 18
+source calls and ten output readouts. Each `B_j` appears exactly twice, so
+arbitrary connector contents are restored.
+
+For each output, the two `A_i` calls contribute
+
+```text
+A_i z_initial + A_i(z_initial + sum_{j in S_i} B_j x_j)
+= sum_{j in S_i} A_i B_j x_j,
+```
+
+because the interface is over F2 and `A_i` is linear. Thus arbitrary initial
+target and connector contents cancel in the update, while every source input
+remains unchanged. The scalar verifier exhausts all source values and dirty
+bits; this algebraic identity establishes the same schedule for arbitrary
+compatible linear maps.
+
+More generally, take `p` distinct supports `S_1,...,S_p` of size `r`, where
+each transition replaces one current source by a fresh source and
+`n=r+p-1`. The same closed path `0,S_1,...,S_p,0` uses
+`r+2(p-1)+r=2n` source calls; each source appears twice. Two A readouts per
+output give `2n+2p`, the complete-call lower floor. Separate row stars cost
+`p(2r+2)`. In the recorded instance `n=9`, `r=p=5`, these are 28 and 60.
+
+## Verification
+
+Run from repository root with Python 3.10 or later and the standard library:
+
+```sh
+python3 -B research/nine-source-johnson-chain-seed923edf/verify.py
+python3 scripts/research_package.py --package research/nine-source-johnson-chain-seed923edf --check-only
+```
+
+The exact verifier checks the five supports, all nine source labels, every
+Johnson-path transition, the 18-toggle word, the ten readouts and the 28-call
+floor. For each of 512 source assignments, both dirty connector bits and all
+32 dirty-output vectors (32,768 cases), it replays both the shared path and an
+independent 60-call row-star schedule. Negative controls expose single-readout
+connector leakage, a wrong output boundary, and a missing restoration call.
+The verifier also checks the weighted formula at the nonuniform prices
+`c_B=(1,...,9)` and `a=(1,...,5)`, where the saving is 120 price units.
+
+Expected output starts with:
+
+```text
+PASS_NINE_SOURCE_WEIGHT_FIVE_JOHNSON_CHAIN
+supports=01f,02f,067,0e3,1e1
+common_sources=0
+source_calls=18
+readout_calls=10
+total_complete_calls=28
+independent_row_stars=60
+saved_calls=32
+weighted_price_control_saving=120
+dirty_state_cases=32768
+```
+
+The registered package replay uses Python 3.12. This host has Python 3.14.7
+and no `python3.12`; the direct verifier and package metadata/pin check were
+run locally. Hosted replay remains an obligation.
+
+## Selected context
+
+The selected conditional result remains
+`836330098538459/500000000000000000`, reviewed in
+`docs/research/community-batch1099-review.md`. Its source manifest,
+`ASSEMBLY.json`, reproduction `make frontier1094-verify`, Makefile rule and
+actual verifier are pinned in [SOURCES.json](SOURCES.json). That reproduction
+was resolved but not rerun: this contribution changes no selected source,
+certificate, supplier or frontier record.
+
+## Open next questions
+
+The next useful question is whether nonuniform B/A call prices preserve a net
+saving over separate row stars for this fresh-source Johnson-path family. That
+requires assigning actual recursive child prices before claiming any effect
+on the selected bound.
diff --git a/research/nine-source-johnson-chain-seed923edf/SOURCES.json b/research/nine-source-johnson-chain-seed923edf/SOURCES.json
new file mode 100644
index 0000000000..2b553d1ee3
--- /dev/null
+++ b/research/nine-source-johnson-chain-seed923edf/SOURCES.json
@@ -0,0 +1,132 @@
+{
+  "schema_version": 1,
+  "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
+  "files": [
+    {
+      "path": "AGENTS.md",
+      "usage": "provenance",
+      "git_blob": "1dce1b16a687a5d1a507ef64b9d4da19dd9e43f9",
+      "sha256": "5378ffbf3a119fcd0c23bcce20f34e5dd2fa792a00a0033e47667aeba72bbc37"
+    },
+    {
+      "path": "CONTRIBUTING.md",
+      "usage": "provenance",
+      "git_blob": "e51435543687f1bd88ab22248082dc689ce8b853",
+      "sha256": "df5b5646602f42cb5da5844f04ac925182ddcd0f627b9de1c96a5095bb7a277a"
+    },
+    {
+      "path": "Makefile",
+      "usage": "provenance",
+      "git_blob": "448f13b58fbe3492e2ea6b2005c8822aefe2765c",
+      "sha256": "029076ba6558f4c97d59d508baeb47847e0fad3545ed1fd22943ab9d6c84c2b9"
+    },
+    {
+      "path": "autoresearch.md",
+      "usage": "provenance",
+      "git_blob": "9b6cbfef0fb725f28c177038d32f482706e12c94",
+      "sha256": "79d0c8be61d90dd6c46b6e7250e0c88713d29854128d8d1361b6343682dad1d8"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "e8870e5917057d59b730eb14721a778639eca050",
+      "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7"
+    },
+    {
+      "path": "docs/research/community-batch1099-review.md",
+      "usage": "provenance",
+      "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099",
+      "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb"
+    },
+    {
+      "path": "docs/research/research-priority-log.md",
+      "usage": "provenance",
+      "git_blob": "457b6c703cbc2436c224945f4d9c4cf97911261e",
+      "sha256": "6e861e9198370aac3f8fabf8d68d95d605dcfaf9e6bf5f05e58378b0f2bedf5d"
+    },
+    {
+      "path": "research/community-frontier1094-audit/ASSEMBLY.json",
+      "usage": "provenance",
+      "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0",
+      "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045"
+    },
+    {
+      "path": "research/community-frontier1094-audit/INDEPENDENT1094.json",
+      "usage": "provenance",
+      "git_blob": "009a385e26858058a18188364078d162aa6f9519",
+      "sha256": "301fb8a0e4ab7e3c383ff974c54c08178283b2a3453c5282757f692a3c7a4bfd"
+    },
+    {
+      "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json",
+      "usage": "provenance",
+      "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8",
+      "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b"
+    },
+    {
+      "path": "research/universal-connector-boundary/CERTIFICATE.json",
+      "usage": "provenance",
+      "git_blob": "079e3e1441dc07c2f0536e9527acf290e51ea9c0",
+      "sha256": "e733746ba3e5151c829b4e8728bfff5ae3ed24d8d203eb77c735d20758e8266a"
+    },
+    {
+      "path": "research/universal-connector-boundary/EXPECTED.json",
+      "usage": "provenance",
+      "git_blob": "c0f2eef36c9543745bb9d00f66913b0abf5cc904",
+      "sha256": "658924c2940cbe193378d5ef09f4d62500fc7b385c16c0ea33846be836c429d2"
+    },
+    {
+      "path": "research/universal-connector-boundary/README.md",
+      "usage": "provenance",
+      "git_blob": "d277f7c5830b1f2bc42e1ff41ab86e7d7564929f",
+      "sha256": "23415f7829ab8d80a783142f10f7d31abbce84579362769984680af3df954476"
+    },
+    {
+      "path": "research/universal-connector-boundary/SOURCES.json",
+      "usage": "provenance",
+      "git_blob": "885157ac149d8c8b8daad7e2b324e6d0ee454a51",
+      "sha256": "6c51dd06c73a4e94f28b636b9d07a22b8917baebdbf4a3b85b0f8541ea7dcbfe"
+    },
+    {
+      "path": "research/universal-connector-boundary/dense_checks.py",
+      "usage": "provenance",
+      "git_blob": "62f15821973de3d517396917f1992f2bd6ddb84d",
+      "sha256": "7a568bca612fede226fc5326492953392d895d04e88fad417119d40d148a9fc6"
+    },
+    {
+      "path": "research/universal-connector-boundary/independent.py",
+      "usage": "provenance",
+      "git_blob": "af9a81a137991431c4d243475b2d6dac9c3d8790",
+      "sha256": "fb765d0d26e0cdf1d266663fe7068957fcfba77b9bd89396af29966f89f1b6cf"
+    },
+    {
+      "path": "research/universal-connector-boundary/references/PR934-NOTICE.md",
+      "usage": "provenance",
+      "git_blob": "22bc8648ac14639249923aa328603877aaceaf1a",
+      "sha256": "2b085e535c310847dd489ca60e5d12277bdb601aa1af3c731f36eb0275184528"
+    },
+    {
+      "path": "research/universal-connector-boundary/references/PR934-README.md",
+      "usage": "provenance",
+      "git_blob": "7158c8c1f9d64506cb2a52ca047f947e544e0ae6",
+      "sha256": "d187dc94bf631bd5b6da2cc1019a2d1ba687b624fdaf32aae05dffc67872509d"
+    },
+    {
+      "path": "research/universal-connector-boundary/verify.py",
+      "usage": "provenance",
+      "git_blob": "de6483bb7ff51940dbbb76c18f91af4c907e07da",
+      "sha256": "e4fa4700f9e1ae6ca09c3c76ebc569e8361b89b699425a67839d999d8812e42d"
+    },
+    {
+      "path": "scripts/verify_frontier1094.py",
+      "usage": "provenance",
+      "git_blob": "96e6c1386bd052b9bcaf136d934406f3f0c3f777",
+      "sha256": "c7e20f59968ed5736fb859735de4de207de3418083e37012310ebcded946b949"
+    }
+  ]
+}
diff --git a/research/nine-source-johnson-chain-seed923edf/TASK.json b/research/nine-source-johnson-chain-seed923edf/TASK.json
new file mode 100644
index 0000000000..1ae84ddda9
--- /dev/null
+++ b/research/nine-source-johnson-chain-seed923edf/TASK.json
@@ -0,0 +1,177 @@
+{
+  "schema_version": 1,
+  "task_id": "connector-alphabet-change",
+  "priority_revision": 4,
+  "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
+  "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": "In the established singleton F2 dirty-connector alphabet, construct an exact complete-call-floor schedule for nine read-only source maps B0..B8 and five distinct dirty output maps Ai with supports S1=01234, S2=01235, S3=01256, S4=01567, S5=05678. These five weight-five masks form a path in J(9,5), each step replacing one source, and use all nine sources.",
+  "scope_change_reason": "The selected card asks to extend the connector alphabet, but the live connector and output-path lanes are crowded. This scope adds no operation: it tests an explicit sparse support family whose consecutive masks form a Johnson path. It is distinct from Cycle 31 PR #2283, which searched a two-sweep path for all 70 weight-four masks at n=8 and found a scoped obstruction, and from PR #2271, a 12-row local bit-register tour through three different masks.",
+  "bottleneck_link": "A path through sparse output supports can share repeated B-source transitions and remove work from a recursive connector interface; reaching the 2n+2p call floor is a precise local target, while supplier placement and weighted child prices remain open.",
+  "budget_minutes": 60,
+  "stop_rule": "Screen the fully charged per-complete-call floor against separate row stars. If favorable, construct the explicit n=9, r=5, p=5 Johnson path; replay all 32768 dirty scalar cases and run one-readout, wrong-boundary and missing-restoration controls. Stop after the exact replay and lower-bound proof; do not search unrelated support families or infer supplier placement/kappa.",
+  "outcome": "completed",
+  "evidence": "PASS_NINE_SOURCE_WEIGHT_FIVE_JOHNSON_CHAIN: 18 source calls plus ten readouts = exact 28-call floor; five independent row stars cost 60. Both schedules were replayed for all 32768 arbitrary dirty scalar states. Single-readout leakage, wrong-boundary and missing-restoration controls pass. Source incidence vector is (5,4,3,2,1,4,3,2,1); for stable positive per-call prices the exact saving over row stars is 2*sum_j(d_j-1)c_j, while A-call prices cancel. No supplier placement or kappa claim.",
+  "author": "Cinna Davis",
+  "ai_assistance": "Substantial OpenAI Codex assistance in scope selection, derivation, implementation and verification.",
+  "open_questions": [
+    {
+      "question": "Can a source-pinned selected supplier realize the fresh-source Johnson-path schedule with stable per-call B/A prices and no offsetting frame or host charges?",
+      "why_it_matters": "The abstract weighted saving is strict for positive source prices, but only actual source-role placement and transition billing can connect it to the selected recursive moment.",
+      "first_step": "Identify a selected source word with nine roles matching the supports and price each B/A invocation, frame transition, host, precision and tape effect against separate stars.",
+      "blocked_by": "No matching selected supplier or source-role map is identified in this finite connector package."
+    }
+  ],
+  "track": "recursive-interfaces",
+  "assignment_seed": "923edf31ad6e8cfdc58bb11a6c6d6b3d",
+  "discarded_excluded_draws": [
+    {
+      "seed": "3c0e460e62633c4b16b5923d0f386d45",
+      "track": "adversarial-audit",
+      "reason": "Excluded track; draw was also made from the prior submitted branch rather than current main and was not accepted."
+    }
+  ],
+  "selector_scope_key": "ff4f5113ed2256ab19ed",
+  "catalog_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7",
+  "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32",
+  "selector_suggestions": [
+    {
+      "task_id": "coverage-law-change",
+      "scope_key": "f383d8fc405ee6982cdd"
+    },
+    {
+      "task_id": "connector-alphabet-change",
+      "scope_key": "ff4f5113ed2256ab19ed"
+    },
+    {
+      "task_id": "joint-query-controller",
+      "scope_key": "0e34adbc1dd119161c3a"
+    }
+  ],
+  "claim_status": "local-only-unposted-graphql-refresh-hung",
+  "claim_expiry_utc": "2026-10-15T05:45:00Z",
+  "claim_text_path": "CLAIM.md",
+  "overlap_snapshot": {
+    "checked_at_utc": "2026-10-15T03:44:32Z",
+    "open_prs": 511,
+    "discussion_records": 990,
+    "open_prs_fetched_at_utc": "2026-10-15T03:42:09Z",
+    "discussions_fetched_at_utc": "2026-10-15T03:26:59Z",
+    "complete_pagination": true,
+    "warnings": [],
+    "exact_terms": [
+      "nine-source weight-five connector",
+      "J(9,5) path",
+      "n=9 weight-five mask chain",
+      "complete-call floor 28",
+      "01234 01235 01256 01567 05678"
+    ],
+    "direct_remote_matches": 0,
+    "live_refresh": "The earlier GraphQL request hung and was stopped after about two minutes; the final pre-submission refresh produced no output and timed out after 50 seconds at 2026-10-15T03:56:30Z. The cached snapshots were not refreshed.",
+    "pre_submission_refresh_at_utc": "2026-10-15T03:56:30Z",
+    "pre_submission_refresh_result": "timeout after 50 seconds; no output; no new overlap data",
+    "related_open_pr_heads": {
+      "PR2128": "697369a971eed02c0fbcd75ebefec9f59945f08e",
+      "PR2229": "b4eab83755969d406edba9f25b7890e4db4c4931",
+      "PR2266": "9382f0d9796cd58831f876943162c536fa14cfd5",
+      "PR2271": "95fd439596f72575d3869277c2d01aca1ca6ab6a",
+      "PR2283": "21145202e9a27cd9b18ffc7e23383cc83461c4a0"
+    },
+    "related_discussions": [
+      "Discussion #1516: active centre-path hosting claim; different object",
+      "Discussion #1587: active two-unpaid-coordinate claim; different object",
+      "Discussion #2221: completed n=7 low-weight mask result",
+      "Discussion #2262: active GF(4) scalar-source claim",
+      "Discussion #2275: active n=7 paired-call root-count claim"
+    ]
+  },
+  "selected_context": {
+    "kappa": "836330098538459/500000000000000000",
+    "review": "docs/research/community-batch1099-review.md",
+    "source_manifest": "research/community-frontier1094-audit/SELECTED-SOURCE.json",
+    "certificate": "research/community-frontier1094-audit/ASSEMBLY.json",
+    "reproduce": "make frontier1094-verify",
+    "certificate_sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045",
+    "source_manifest_sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b",
+    "review_sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb",
+    "reproduction_run_this_cycle": false
+  },
+  "candidate_screen": [
+    {
+      "scope": "coverage-law-change: two unpaid coordinates per family",
+      "status": "rejected-overlap",
+      "evidence": "Active Discussion #1587, expires 2026-10-15T07:30Z; this is the current selector card question."
+    },
+    {
+      "scope": "centre-path-sharing: host or share the selected centre path",
+      "status": "rejected-overlap",
+      "evidence": "Active Discussion #1516 claim through 2026-10-15T05:00Z; related older records #1963 and #2058."
+    },
+    {
+      "scope": "joint-query-controller: QQ16 changed interface",
+      "status": "rejected-overlap-and-repeat",
+      "evidence": "Open PR #2153 and prior Cycle 30 PR #2268; not repeated."
+    },
+    {
+      "scope": "connector-alphabet-change: explicit new operation",
+      "status": "scope-changed",
+      "evidence": "Open connector work includes PRs #2128, #2229, #2266, #2271 and Cycle 31 PR #2283 plus active Discussions #2262 and #2275. Exact n=9, weight-five Johnson path searches returned no direct remote match; use existing alphabet."
+    }
+  ],
+  "cost_screen": {
+    "source_call_floor": 18,
+    "output_readout_floor": 10,
+    "optimistic_and_constructed_total": 28,
+    "row_star_comparator": 60,
+    "unit_call_saving": 32,
+    "source_incidence_counts": [
+      5,
+      4,
+      3,
+      2,
+      1,
+      4,
+      3,
+      2,
+      1
+    ],
+    "weighted_saving": "2*sum_j(d_j-1)c_Bj; target A prices cancel",
+    "per_call_scope": "Each B_j and A_i price is a complete invocation price, including its recursive child bill if assigned; prices are assumed stable across positions.",
+    "not_invoiced": "No position-dependent transition or concrete supplier placement price is known; no selected kappa is inferred."
+  }
+}
diff --git a/research/nine-source-johnson-chain-seed923edf/VERIFY.json b/research/nine-source-johnson-chain-seed923edf/VERIFY.json
new file mode 100644
index 0000000000..e81f6a6b00
--- /dev/null
+++ b/research/nine-source-johnson-chain-seed923edf/VERIFY.json
@@ -0,0 +1,20 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Verify the five supports and Johnson path; exhaust all 32768 dirty scalar states for both shared and independent row-star schedules; require the exact 28-call floor, weighted price identity and three failure controls."
+    }
+  ]
+}
diff --git a/research/nine-source-johnson-chain-seed923edf/verify.py b/research/nine-source-johnson-chain-seed923edf/verify.py
new file mode 100644
index 0000000000..e176afa747
--- /dev/null
+++ b/research/nine-source-johnson-chain-seed923edf/verify.py
@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""Exact dirty-state replay for a nine-source Johnson-path connector batch."""
+
+from __future__ import annotations
+
+from collections import Counter
+
+N = 9
+MASKS = (0x01F, 0x02F, 0x067, 0x0E3, 0x1E1)
+SOURCE_WORD = (0, 1, 2, 3, 4, 4, 5, 3, 6, 2, 7, 1, 8, 0, 5, 6, 7, 8)
+READOUT_BOUNDARIES = (5, 7, 9, 11, 13)
+DIRTY_OUTPUTS = len(MASKS)
+
+
+def require(condition: bool, message: str) -> None:
+    if not condition:
+        raise ValueError(message)
+
+
+def parity_dot(source_values: int, support: int) -> int:
+    return (source_values & support).bit_count() & 1
+
+
+def prefix_masks() -> tuple[int, ...]:
+    q = 0
+    states = [q]
+    for source in SOURCE_WORD:
+        q ^= 1 << source
+        states.append(q)
+    return tuple(states)
+
+
+def replay(source_values: int, dirty_connector: int, dirty_outputs: int) -> tuple[int, int]:
+    """Execute the scheduled scalar F2 calls; return final z and output bits."""
+    q = 0
+    z = dirty_connector
+    outputs = dirty_outputs
+
+    # Each A_i is read once at the common zero prefix.
+    for i in range(DIRTY_OUTPUTS):
+        outputs ^= dirty_connector << i
+
+    readout_at = {boundary: i for i, boundary in enumerate(READOUT_BOUNDARIES)}
+    for boundary, source in enumerate(SOURCE_WORD, start=1):
+        value = (source_values >> source) & 1
+        z ^= value
+        q ^= 1 << source
+        if boundary in readout_at:
+            output = readout_at[boundary]
+            outputs ^= z << output
+
+    require(q == 0, "source connector did not return to its entry parity")
+    expected_z = dirty_connector
+    require(z == expected_z, "dirty connector value was not restored")
+    return z, outputs
+
+
+def replay_row_stars(source_values: int, dirty_connector: int,
+                     dirty_outputs: int) -> tuple[int, int]:
+    """Independent per-output schedule used for the 60-call comparator."""
+    z = dirty_connector
+    outputs = dirty_outputs
+    for i, support in enumerate(MASKS):
+        outputs ^= z << i
+        for source in range(N):
+            if (support >> source) & 1:
+                z ^= (source_values >> source) & 1
+        outputs ^= z << i
+        for source in range(N):
+            if (support >> source) & 1:
+                z ^= (source_values >> source) & 1
+    return z, outputs
+
+
+def verify_instance() -> tuple[int, int, tuple[int, ...]]:
+    universe = (1 << N) - 1
+    require(len(set(MASKS)) == DIRTY_OUTPUTS, "output supports must be distinct")
+    require(all(mask.bit_count() == 5 for mask in MASKS), "each output must have weight five")
+    require(set().union(*(set(j for j in range(N) if (mask >> j) & 1) for mask in MASKS)) == set(range(N)),
+            "the output family must use all nine sources")
+    common = universe
+    for mask in MASKS:
+        common &= mask
+    require(common == 1, "only source 0 should be common to all five outputs")
+    require(all((left ^ right).bit_count() == 2 for left, right in zip(MASKS, MASKS[1:])),
+            "successive supports must differ by one exchange in J(9,5)")
+
+    counts = Counter(SOURCE_WORD)
+    require(counts == Counter({j: 2 for j in range(N)}), "every source must be toggled exactly twice")
+    states = prefix_masks()
+    require(tuple(states[b] for b in READOUT_BOUNDARIES) == MASKS,
+            "the source word must visit all five requested supports")
+    require(states[-1] == 0, "source path must end at zero")
+
+    cases = 0
+    for source_values in range(1 << N):
+        for dirty_connector in (0, 1):
+            for dirty_outputs in range(1 << DIRTY_OUTPUTS):
+                final_z, actual_outputs = replay(source_values, dirty_connector, dirty_outputs)
+                expected_outputs = dirty_outputs
+                for i, support in enumerate(MASKS):
+                    expected_outputs ^= parity_dot(source_values, support) << i
+                require(final_z == dirty_connector, "connector restoration failed")
+                require(actual_outputs == expected_outputs, "dirty-state output map mismatch")
+                stars_z, stars_outputs = replay_row_stars(
+                    source_values, dirty_connector, dirty_outputs)
+                require(stars_z == dirty_connector and stars_outputs == expected_outputs,
+                        "independent row-star control disagrees with the target map")
+                cases += 1
+
+    require(cases == (1 << N) * 2 * (1 << DIRTY_OUTPUTS), "dirty-state domain is incomplete")
+
+    # Failure control 1: a lone A readout leaks arbitrary entry dirt.
+    dirty_y, dirty_z, zero_sources = 0, 1, 0
+    lone_read = dirty_y ^ dirty_z ^ parity_dot(zero_sources, 0)
+    require(lone_read != dirty_y, "single-readout dirty-z control failed to expose leakage")
+
+    # Failure control 2: reading output 0 at the S2 boundary instead of S1
+    # returns source 4 even though source 4 is absent from its requested row.
+    wrong_source_values = 1 << 4
+    wrong_boundary_term = parity_dot(wrong_source_values, states[READOUT_BOUNDARIES[1]])
+    correct_row_term = parity_dot(wrong_source_values, MASKS[0])
+    require(wrong_boundary_term != correct_row_term, "wrong-boundary control failed")
+
+    # Failure control 3: omit the final B8 call and set x8=1; the connector
+    # then retains the source-8 coefficient instead of restoring to entry.
+    without_last = SOURCE_WORD[:-1]
+    q = 0
+    for source in without_last:
+        q ^= 1 << source
+    omitted_restore_residual = parity_dot(1 << 8, q)
+    require(omitted_restore_residual == 1, "missing-restoration control failed")
+
+    # The exact call floor and the row-by-row comparator use the same complete
+    # unit-call alphabet: 2 per active source, 2 per output; 2r+2 per row star.
+    source_calls = len(SOURCE_WORD)
+    readout_calls = 2 * DIRTY_OUTPUTS
+    lower_floor = 2 * N + 2 * DIRTY_OUTPUTS
+    row_stars = DIRTY_OUTPUTS * (2 * 5 + 2)
+    require(source_calls == 2 * N and readout_calls == 2 * DIRTY_OUTPUTS,
+            "schedule call counts do not meet the source/readout lower floor")
+    require(source_calls + readout_calls == lower_floor == 28,
+            "schedule did not attain the exact complete-call floor")
+    require(row_stars == 60, "row-star baseline arithmetic changed")
+
+    # Heterogeneous complete-call prices are charged by operator type. The
+    # output-readout bill is identical in both schedules; B_j is used 2*d_j
+    # times in separate stars and exactly twice in the shared path.
+    degrees = tuple(sum((mask >> j) & 1 for mask in MASKS) for j in range(N))
+    require(degrees == (5, 4, 3, 2, 1, 4, 3, 2, 1), "source incidence vector changed")
+    source_prices = tuple(range(1, N + 1))
+    target_prices = tuple(range(1, DIRTY_OUTPUTS + 1))
+    shared_weighted = 2 * sum(source_prices) + 2 * sum(target_prices)
+    stars_weighted = (2 * sum(degrees[j] * source_prices[j] for j in range(N))
+                      + 2 * sum(target_prices))
+    weighted_saving = 2 * sum((degrees[j] - 1) * source_prices[j] for j in range(N))
+    require(stars_weighted - shared_weighted == weighted_saving == 120,
+            "heterogeneous complete-call price accounting failed")
+    require(weighted_saving > 0, "positive source call prices should yield a strict saving")
+    return cases, weighted_saving, degrees
+
+
+def main() -> None:
+    cases, weighted_saving, degrees = verify_instance()
+    print("PASS_NINE_SOURCE_WEIGHT_FIVE_JOHNSON_CHAIN")
+    print(f"supports={','.join(f'{m:03x}' for m in MASKS)}")
+    print("common_sources=0")
+    print(f"source_word={','.join(str(j) for j in SOURCE_WORD)}")
+    print("source_calls=18")
+    print("readout_calls=10")
+    print("total_complete_calls=28")
+    print("independent_row_stars=60")
+    print("saved_calls=32")
+    print(f"source_incidence_counts={','.join(str(x) for x in degrees)}")
+    print(f"weighted_price_control_saving={weighted_saving}")
+    print(f"dirty_state_cases={cases}")
+    print("controls=single-readout,wrong-boundary,missing-restoration")
+    print("scope=singleton F2 connector; weighted formula assumes stable per-call prices; no supplier or kappa claim")
+
+
+if __name__ == "__main__":
+    main()

From b4af93f238e69ccf000eb9e90030be4c01cda391 Mon Sep 17 00:00:00 2001
From: Cinna Davis <1337isnot1337@users.noreply.github.com>
Date: Wed, 14 Oct 2026 23:02:30 -0500
Subject: [PATCH 2/4] Record connector overlap with broader walk compiler

---
 .../CLAIM.md                                  | 14 +++++++----
 .../README.md                                 | 24 +++++++++++++------
 .../TASK.json                                 | 17 ++++++++++++-
 3 files changed, 43 insertions(+), 12 deletions(-)

diff --git a/research/nine-source-johnson-chain-seed923edf/CLAIM.md b/research/nine-source-johnson-chain-seed923edf/CLAIM.md
index 71d70cb2f7..a7ce8cc63b 100644
--- a/research/nine-source-johnson-chain-seed923edf/CLAIM.md
+++ b/research/nine-source-johnson-chain-seed923edf/CLAIM.md
@@ -46,16 +46,22 @@ posted.
 - **Expected evidence:** A standalone verifier, exact source/readout word,
   arbitrary dirty-state replay, lower-bound argument, negative controls,
   complete provenance pins, and a focused package PR if overlap remains clear.
-- **Relevant work and distinction:** PR #2271 (head
+- **Relevant work and distinction:** Open PR #2208 (head
+  `28480ef4fdb4caeab89765ea56595bf1f6f37688`) develops all-word two-root
+  dirty-connector bounds and an exact minimum-read compiler for supplied source
+  walks over as many as 511 outputs. It is adjacent source-walk work, but uses
+  a two-root framed interface and does not present this one-connector, five-
+  mask Johnson chain or its 28-call floor. PR #2271 (head
   `95fd439596f72575d3869277c2d01aca1ca6ab6a`) is a 12-row bit-register Gray
   tour through three masks, not this nine-source recursive B/A interface.
   PR #2283 (head `21145202e9a27cd9b18ffc7e23383cc83461c4a0`) is Cycle 31's
   negative result for the full n=8 weight-four shell under two complete
   sweeps. PR #2229 covers n=7 weights 1--3; PR #2266 changes to GF(4) for two
   sources. Active neighboring claims #2262 (GF(4)) and #2275 (seven-source
-  paired-call roots) do not use this mask family. Exact overlap terms returned
-  no direct remote match in a complete snapshot of 511 open PRs and 990
-  Discussions (PR data 03:42 UTC; Discussion data 03:26 UTC, 2026-10-15).
+  paired-call roots) do not use this mask family. Targeted live PR searches at
+  04:00 UTC found no `J(9,5)`, exact five-mask or "nine-source Johnson-chain"
+  match. The complete cached snapshot covered 511 open PRs and 990 Discussions
+  (PR data 03:42 UTC; Discussion data 03:26 UTC, 2026-10-15).
 - **Expiry:** 2026-10-15 05:45 UTC.
 
 The selected conditional result is `836330098538459/500000000000000000` at
diff --git a/research/nine-source-johnson-chain-seed923edf/README.md b/research/nine-source-johnson-chain-seed923edf/README.md
index 1b6e4d228a..dfd80d7394 100644
--- a/research/nine-source-johnson-chain-seed923edf/README.md
+++ b/research/nine-source-johnson-chain-seed923edf/README.md
@@ -28,19 +28,29 @@ work is claimed. Apache-2.0.
   is in [CLAIM.md](CLAIM.md). The generalization is limited to support paths
   that introduce a fresh source at each one-element exchange.
 - Overlap: the complete cached snapshot held 511 open PRs and 990 Discussions
-  (no warnings); exact searches for the nine-source weight-five path returned
-  no remote matches. PR data was fetched at 03:42 UTC and Discussion data at
-  03:26 UTC on 2026-10-15. A newer GraphQL refresh hung and was stopped after
-  about two minutes. The final pre-submission refresh produced no output and
-  timed out after 50 seconds at 03:56 UTC on 2026-10-15, so the cached snapshot
-  was not refreshed. The nearest source-path result, PR #2271 at
+  (no warnings). The exact local overlap-helper searches for the nine-source
+  weight-five path returned no direct matches. PR data was fetched at 03:42 UTC
+  and Discussion data at 03:26 UTC on 2026-10-15. A newer authenticated
+  GraphQL refresh hung and was stopped after about two minutes. The final
+  pre-submission refresh produced no output and
+  timed out after 50 seconds at 03:56 UTC, so the full cached snapshot was not
+  refreshed. Targeted live PR searches at 04:00 UTC found no `J(9,5)`, exact
+  five-mask, or "nine-source Johnson-chain" match. A broader search surfaced
+  open PR #2208 at head
+  `28480ef4fdb4caeab89765ea56595bf1f6f37688`, which studies all-word two-root
+  dirty-connector bounds and a minimum-read source-walk compiler for up to 511
+  outputs. That work is adjacent, but does not give this single-connector
+  five-mask path or its 28-call floor. The nearest small source-path result,
+  PR #2271 at
   `95fd439596f72575d3869277c2d01aca1ca6ab6a`, is a 12-row local bit-register
   tour through three different masks. Cycle 31 PR #2283 at
   `21145202e9a27cd9b18ffc7e23383cc83461c4a0` is a negative result for the
   entire n=8 weight-four shell under two complete sweeps. PR #2229 studies n=7
   weights 1--3; PR #2266 changes the alphabet to GF(4) for two sources.
   Active nearby claims #2262 (GF(4)) and #2275 (seven-source paired-call root
-  counts) use different objects and support families.
+  counts) use different objects and support families. PR #2208 changes the
+  interface to two roots and studies many outputs/readout tariffs; this result
+  uses one F2 connector and five specified outputs, with no frame transitions.
 - Discussion claim status: local-only because the authenticated GraphQL
   request hung, the final pre-submission refresh timed out without output, and
   a prior direct REST Discussions comment attempt returned 404. Claim expiry
diff --git a/research/nine-source-johnson-chain-seed923edf/TASK.json b/research/nine-source-johnson-chain-seed923edf/TASK.json
index 1ae84ddda9..70b108cfb0 100644
--- a/research/nine-source-johnson-chain-seed923edf/TASK.json
+++ b/research/nine-source-johnson-chain-seed923edf/TASK.json
@@ -107,11 +107,26 @@
     "pre_submission_refresh_result": "timeout after 50 seconds; no output; no new overlap data",
     "related_open_pr_heads": {
       "PR2128": "697369a971eed02c0fbcd75ebefec9f59945f08e",
+      "PR2208": "28480ef4fdb4caeab89765ea56595bf1f6f37688",
       "PR2229": "b4eab83755969d406edba9f25b7890e4db4c4931",
       "PR2266": "9382f0d9796cd58831f876943162c536fa14cfd5",
       "PR2271": "95fd439596f72575d3869277c2d01aca1ca6ab6a",
       "PR2283": "21145202e9a27cd9b18ffc7e23383cc83461c4a0"
     },
+    "targeted_live_pr_search": {
+      "searched_at_utc": "2026-10-15T04:00:24Z",
+      "queries": [
+        "J(9,5)",
+        "01234 01235 01256 01567 05678",
+        "nine-source Johnson-chain"
+      ],
+      "exact_query_matches": 0,
+      "adjacent_open_pr": {
+        "number": 2208,
+        "head": "28480ef4fdb4caeab89765ea56595bf1f6f37688",
+        "scope": "all-word two-root dirty-connector bounds and minimum-read walk compilation for many outputs"
+      }
+    },
     "related_discussions": [
       "Discussion #1516: active centre-path hosting claim; different object",
       "Discussion #1587: active two-unpaid-coordinate claim; different object",
@@ -150,7 +165,7 @@
     {
       "scope": "connector-alphabet-change: explicit new operation",
       "status": "scope-changed",
-      "evidence": "Open connector work includes PRs #2128, #2229, #2266, #2271 and Cycle 31 PR #2283 plus active Discussions #2262 and #2275. Exact n=9, weight-five Johnson path searches returned no direct remote match; use existing alphabet."
+      "evidence": "Open connector work includes PRs #2128, #2208, #2229, #2266, #2271 and Cycle 31 PR #2283 plus active Discussions #2262 and #2275. Live searches for J(9,5) and the exact five-mask vector returned no PR match. Adjacent PR #2208 develops all-word two-root dirty-connector bounds and a minimum-read compiler for supplied walks over many outputs; it does not provide this one-connector five-mask chain or 28-call floor. Use the existing alphabet."
     }
   ],
   "cost_screen": {

From 96a16c119d29a231ea6921e7b78edec4e9b8570a Mon Sep 17 00:00:00 2001
From: Cinna Davis <1337isnot1337@users.noreply.github.com>
Date: Wed, 14 Oct 2026 23:03:47 -0500
Subject: [PATCH 3/4] Record cycle 32 PR handoff status

---
 .../CLAIM.md                                  | 19 ++++++++++++-------
 .../README.md                                 |  7 +++++++
 .../TASK.json                                 | 11 ++++++++++-
 3 files changed, 29 insertions(+), 8 deletions(-)

diff --git a/research/nine-source-johnson-chain-seed923edf/CLAIM.md b/research/nine-source-johnson-chain-seed923edf/CLAIM.md
index a7ce8cc63b..19dacc32e9 100644
--- a/research/nine-source-johnson-chain-seed923edf/CLAIM.md
+++ b/research/nine-source-johnson-chain-seed923edf/CLAIM.md
@@ -1,10 +1,13 @@
 # Cycle 32 local research claim
 
-**Status:** LOCAL-ONLY; the authenticated GraphQL overlap refresh hung and was
-stopped after about two minutes, and the final pre-submission retry produced
-no output before timing out after 50 seconds at 03:56 UTC on 2026-10-15. A prior
-direct REST Discussions comment attempt returned 404. No public claim was
-posted.
+**Status:** RESULT SUBMITTED as [PR #2296](https://github.com/CrocSwap/integer-mult-bounds/pull/2296).
+The PR was open and mergeable at head `b4af93f238e69ccf000eb9e90030be4c01cda391`
+against base `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`; hosted checks were
+queued when checked. The public Discussion claim remains local-only: the
+authenticated GraphQL overlap refresh hung and was stopped after about two
+minutes, the final pre-submission retry produced no output before timing out
+after 50 seconds at 03:56 UTC on 2026-10-15, and a prior direct REST Discussions
+comment attempt returned 404. No public claim was posted.
 
 - **Track / task / seed:** `recursive-interfaces` / `connector-alphabet-change` /
   `923edf31ad6e8cfdc58bb11a6c6d6b3d`.
@@ -45,7 +48,8 @@ posted.
   unpriced, so no recursive supplier or kappa is claimed.
 - **Expected evidence:** A standalone verifier, exact source/readout word,
   arbitrary dirty-state replay, lower-bound argument, negative controls,
-  complete provenance pins, and a focused package PR if overlap remains clear.
+  complete provenance pins, and a focused package PR. Submitted as PR #2296;
+  hosted checks were queued when checked.
 - **Relevant work and distinction:** Open PR #2208 (head
   `28480ef4fdb4caeab89765ea56595bf1f6f37688`) develops all-word two-root
   dirty-connector bounds and an exact minimum-read compiler for supplied source
@@ -62,7 +66,8 @@ posted.
   04:00 UTC found no `J(9,5)`, exact five-mask or "nine-source Johnson-chain"
   match. The complete cached snapshot covered 511 open PRs and 990 Discussions
   (PR data 03:42 UTC; Discussion data 03:26 UTC, 2026-10-15).
-- **Expiry:** 2026-10-15 05:45 UTC.
+- **Expiry:** The local claim is released on completion; the recorded planning
+  expiry was 2026-10-15 05:45 UTC.
 
 The selected conditional result is `836330098538459/500000000000000000` at
 this base, reviewed in `docs/research/community-batch1099-review.md`; the
diff --git a/research/nine-source-johnson-chain-seed923edf/README.md b/research/nine-source-johnson-chain-seed923edf/README.md
index dfd80d7394..ca3ce95baf 100644
--- a/research/nine-source-johnson-chain-seed923edf/README.md
+++ b/research/nine-source-johnson-chain-seed923edf/README.md
@@ -8,6 +8,13 @@ calls per active source and two per output. Five independent restored row
 stars cost 60 calls. The construction uses only the existing singleton
 connector alphabet and makes no supplier or multiplication-bound claim.
 
+**Handoff:** [PR #2296](https://github.com/CrocSwap/integer-mult-bounds/pull/2296)
+is open at head `b4af93f238e69ccf000eb9e90030be4c01cda391` against the exact
+base `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. It was mergeable when checked;
+hosted checks were queued. The public Discussion claim remains unposted because
+the authenticated GraphQL route did not complete and the prior REST comment
+route returned 404; the local claim and PR preserve the coordination record.
+
 Prepared by Cinna Davis with substantial OpenAI Codex assistance in scope
 selection, derivation, implementation and verification. No other contributor
 work is claimed. Apache-2.0.
diff --git a/research/nine-source-johnson-chain-seed923edf/TASK.json b/research/nine-source-johnson-chain-seed923edf/TASK.json
index 70b108cfb0..f8192373b4 100644
--- a/research/nine-source-johnson-chain-seed923edf/TASK.json
+++ b/research/nine-source-johnson-chain-seed923edf/TASK.json
@@ -83,9 +83,18 @@
       "scope_key": "0e34adbc1dd119161c3a"
     }
   ],
-  "claim_status": "local-only-unposted-graphql-refresh-hung",
+  "claim_status": "local-only-unposted; result submitted as PR #2296",
   "claim_expiry_utc": "2026-10-15T05:45:00Z",
   "claim_text_path": "CLAIM.md",
+  "submission": {
+    "pull_request": 2296,
+    "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2296",
+    "state": "OPEN",
+    "head": "b4af93f238e69ccf000eb9e90030be4c01cda391",
+    "base": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
+    "mergeable": true,
+    "hosted_checks": "queued at initial submission check"
+  },
   "overlap_snapshot": {
     "checked_at_utc": "2026-10-15T03:44:32Z",
     "open_prs": 511,

From b2c9ead9ee4a9468deed3d4c96efff8b7d0bb306 Mon Sep 17 00:00:00 2001
From: Cinna Davis <1337isnot1337@users.noreply.github.com>
Date: Wed, 14 Oct 2026 23:04:19 -0500
Subject: [PATCH 4/4] Clarify cycle 32 initial PR status

---
 research/nine-source-johnson-chain-seed923edf/CLAIM.md  | 6 ++++--
 research/nine-source-johnson-chain-seed923edf/README.md | 8 +++++---
 research/nine-source-johnson-chain-seed923edf/TASK.json | 2 +-
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/research/nine-source-johnson-chain-seed923edf/CLAIM.md b/research/nine-source-johnson-chain-seed923edf/CLAIM.md
index 19dacc32e9..e5f59d7cea 100644
--- a/research/nine-source-johnson-chain-seed923edf/CLAIM.md
+++ b/research/nine-source-johnson-chain-seed923edf/CLAIM.md
@@ -2,8 +2,10 @@
 
 **Status:** RESULT SUBMITTED as [PR #2296](https://github.com/CrocSwap/integer-mult-bounds/pull/2296).
 The PR was open and mergeable at head `b4af93f238e69ccf000eb9e90030be4c01cda391`
-against base `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`; hosted checks were
-queued when checked. The public Discussion claim remains local-only: the
+against base `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2` at the initial
+submission check; hosted checks were queued. The subsequent handoff metadata
+update advanced the branch; consult the PR for its current head and checks. The
+public Discussion claim remains local-only: the
 authenticated GraphQL overlap refresh hung and was stopped after about two
 minutes, the final pre-submission retry produced no output before timing out
 after 50 seconds at 03:56 UTC on 2026-10-15, and a prior direct REST Discussions
diff --git a/research/nine-source-johnson-chain-seed923edf/README.md b/research/nine-source-johnson-chain-seed923edf/README.md
index ca3ce95baf..3f3a9e67c7 100644
--- a/research/nine-source-johnson-chain-seed923edf/README.md
+++ b/research/nine-source-johnson-chain-seed923edf/README.md
@@ -9,9 +9,11 @@ stars cost 60 calls. The construction uses only the existing singleton
 connector alphabet and makes no supplier or multiplication-bound claim.
 
 **Handoff:** [PR #2296](https://github.com/CrocSwap/integer-mult-bounds/pull/2296)
-is open at head `b4af93f238e69ccf000eb9e90030be4c01cda391` against the exact
-base `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. It was mergeable when checked;
-hosted checks were queued. The public Discussion claim remains unposted because
+is open against the exact base `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`.
+At the initial submission check, head `b4af93f238e69ccf000eb9e90030be4c01cda391`
+was mergeable and hosted checks were queued. The subsequent handoff metadata
+update advanced the branch; consult the PR for its current head and checks.
+The public Discussion claim remains unposted because
 the authenticated GraphQL route did not complete and the prior REST comment
 route returned 404; the local claim and PR preserve the coordination record.
 
diff --git a/research/nine-source-johnson-chain-seed923edf/TASK.json b/research/nine-source-johnson-chain-seed923edf/TASK.json
index f8192373b4..a8aa0f17c7 100644
--- a/research/nine-source-johnson-chain-seed923edf/TASK.json
+++ b/research/nine-source-johnson-chain-seed923edf/TASK.json
@@ -90,7 +90,7 @@
     "pull_request": 2296,
     "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2296",
     "state": "OPEN",
-    "head": "b4af93f238e69ccf000eb9e90030be4c01cda391",
+    "initial_head": "b4af93f238e69ccf000eb9e90030be4c01cda391",
     "base": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2",
     "mergeable": true,
     "hosted_checks": "queued at initial submission check"