diff --git a/research/bit-s3-two-target-census-seed36501/CERTIFICATE.json b/research/bit-s3-two-target-census-seed36501/CERTIFICATE.json
new file mode 100644
index 0000000000..8af0ae2a63
--- /dev/null
+++ b/research/bit-s3-two-target-census-seed36501/CERTIFICATE.json
@@ -0,0 +1,605 @@
+{
+  "all_two_target_minima_equal_separate_geodesic_bills": true,
+  "direct_call_histogram": {
+    "0": 1,
+    "1": 4,
+    "2": 8,
+    "3": 10,
+    "4": 8,
+    "5": 4,
+    "6": 1
+  },
+  "direct_omission_controls": 108,
+  "free_scalar_mixing": "captured by all rank-one idempotents after augmentation normalization",
+  "generators": [
+    [
+      2,
+      1,
+      1
+    ],
+    [
+      2,
+      1,
+      3
+    ],
+    [
+      2,
+      2,
+      2
+    ],
+    [
+      2,
+      2,
+      3
+    ],
+    [
+      2,
+      3,
+      1
+    ],
+    [
+      2,
+      3,
+      2
+    ],
+    [
+      1,
+      1,
+      1
+    ],
+    [
+      1,
+      1,
+      3
+    ],
+    [
+      1,
+      2,
+      2
+    ],
+    [
+      1,
+      2,
+      3
+    ],
+    [
+      1,
+      3,
+      1
+    ],
+    [
+      1,
+      3,
+      2
+    ]
+  ],
+  "group": "S3",
+  "group_elements": [
+    [
+      0,
+      1,
+      2
+    ],
+    [
+      0,
+      2,
+      1
+    ],
+    [
+      1,
+      0,
+      2
+    ],
+    [
+      1,
+      2,
+      0
+    ],
+    [
+      2,
+      0,
+      1
+    ],
+    [
+      2,
+      1,
+      0
+    ]
+  ],
+  "identity_radius_five_layers": [
+    1,
+    12,
+    80,
+    466,
+    2345,
+    10760
+  ],
+  "identity_radius_five_state_count": 13664,
+  "identity_radius_five_state_sha256": "3e3c2c1ff2cd94336eaeb6ab45fcb102637bb73afa0e2d739eda32315eb8c9f9",
+  "inverse_three_cycle_pair_minimum": 4,
+  "longest_element_pair_minimum": 6,
+  "minimum_call_histogram": {
+    "0": 1,
+    "1": 4,
+    "2": 8,
+    "3": 10,
+    "4": 8,
+    "5": 4,
+    "6": 1
+  },
+  "new_kappa_claimed": false,
+  "ordered_words_independently_checked_through_length_three": 1885,
+  "packed_transition_independently_replayed": true,
+  "radius_five_canonical_paths_formally_replayed": 13664,
+  "rank_one_idempotents": [
+    [
+      1,
+      1
+    ],
+    [
+      1,
+      3
+    ],
+    [
+      2,
+      2
+    ],
+    [
+      2,
+      3
+    ],
+    [
+      3,
+      1
+    ],
+    [
+      3,
+      2
+    ]
+  ],
+  "registers": 2,
+  "status": "PASS_S3_TWO_TARGET_NO_SHARING",
+  "target_group_elements": {
+    "xy": 3,
+    "xyx_yxy": 5,
+    "yx": 4
+  },
+  "target_pair_count": 36,
+  "target_pairs": [
+    {
+      "direct_calls": 0,
+      "direct_generator_indices": [],
+      "left_group_element": 0,
+      "minimum_calls": 0,
+      "right_group_element": 0,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 1,
+      "direct_generator_indices": [
+        8
+      ],
+      "left_group_element": 0,
+      "minimum_calls": 1,
+      "right_group_element": 1,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 1,
+      "direct_generator_indices": [
+        2
+      ],
+      "left_group_element": 0,
+      "minimum_calls": 1,
+      "right_group_element": 2,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 2,
+      "direct_generator_indices": [
+        2,
+        8
+      ],
+      "left_group_element": 0,
+      "minimum_calls": 2,
+      "right_group_element": 3,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 2,
+      "direct_generator_indices": [
+        8,
+        2
+      ],
+      "left_group_element": 0,
+      "minimum_calls": 2,
+      "right_group_element": 4,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 3,
+      "direct_generator_indices": [
+        2,
+        8,
+        2
+      ],
+      "left_group_element": 0,
+      "minimum_calls": 3,
+      "right_group_element": 5,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 1,
+      "direct_generator_indices": [
+        6
+      ],
+      "left_group_element": 1,
+      "minimum_calls": 1,
+      "right_group_element": 0,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 2,
+      "direct_generator_indices": [
+        6,
+        8
+      ],
+      "left_group_element": 1,
+      "minimum_calls": 2,
+      "right_group_element": 1,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 2,
+      "direct_generator_indices": [
+        6,
+        2
+      ],
+      "left_group_element": 1,
+      "minimum_calls": 2,
+      "right_group_element": 2,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 3,
+      "direct_generator_indices": [
+        6,
+        2,
+        8
+      ],
+      "left_group_element": 1,
+      "minimum_calls": 3,
+      "right_group_element": 3,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 3,
+      "direct_generator_indices": [
+        6,
+        8,
+        2
+      ],
+      "left_group_element": 1,
+      "minimum_calls": 3,
+      "right_group_element": 4,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 4,
+      "direct_generator_indices": [
+        6,
+        2,
+        8,
+        2
+      ],
+      "left_group_element": 1,
+      "minimum_calls": 4,
+      "right_group_element": 5,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 1,
+      "direct_generator_indices": [
+        0
+      ],
+      "left_group_element": 2,
+      "minimum_calls": 1,
+      "right_group_element": 0,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 2,
+      "direct_generator_indices": [
+        0,
+        8
+      ],
+      "left_group_element": 2,
+      "minimum_calls": 2,
+      "right_group_element": 1,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 2,
+      "direct_generator_indices": [
+        0,
+        2
+      ],
+      "left_group_element": 2,
+      "minimum_calls": 2,
+      "right_group_element": 2,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 3,
+      "direct_generator_indices": [
+        0,
+        2,
+        8
+      ],
+      "left_group_element": 2,
+      "minimum_calls": 3,
+      "right_group_element": 3,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 3,
+      "direct_generator_indices": [
+        0,
+        8,
+        2
+      ],
+      "left_group_element": 2,
+      "minimum_calls": 3,
+      "right_group_element": 4,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 4,
+      "direct_generator_indices": [
+        0,
+        2,
+        8,
+        2
+      ],
+      "left_group_element": 2,
+      "minimum_calls": 4,
+      "right_group_element": 5,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 2,
+      "direct_generator_indices": [
+        0,
+        6
+      ],
+      "left_group_element": 3,
+      "minimum_calls": 2,
+      "right_group_element": 0,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 3,
+      "direct_generator_indices": [
+        0,
+        6,
+        8
+      ],
+      "left_group_element": 3,
+      "minimum_calls": 3,
+      "right_group_element": 1,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 3,
+      "direct_generator_indices": [
+        0,
+        6,
+        2
+      ],
+      "left_group_element": 3,
+      "minimum_calls": 3,
+      "right_group_element": 2,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 4,
+      "direct_generator_indices": [
+        0,
+        6,
+        2,
+        8
+      ],
+      "left_group_element": 3,
+      "minimum_calls": 4,
+      "right_group_element": 3,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 4,
+      "direct_generator_indices": [
+        0,
+        6,
+        8,
+        2
+      ],
+      "left_group_element": 3,
+      "minimum_calls": 4,
+      "right_group_element": 4,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 5,
+      "direct_generator_indices": [
+        0,
+        6,
+        2,
+        8,
+        2
+      ],
+      "left_group_element": 3,
+      "minimum_calls": 5,
+      "right_group_element": 5,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 2,
+      "direct_generator_indices": [
+        6,
+        0
+      ],
+      "left_group_element": 4,
+      "minimum_calls": 2,
+      "right_group_element": 0,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 3,
+      "direct_generator_indices": [
+        6,
+        0,
+        8
+      ],
+      "left_group_element": 4,
+      "minimum_calls": 3,
+      "right_group_element": 1,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 3,
+      "direct_generator_indices": [
+        6,
+        0,
+        2
+      ],
+      "left_group_element": 4,
+      "minimum_calls": 3,
+      "right_group_element": 2,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 4,
+      "direct_generator_indices": [
+        6,
+        0,
+        2,
+        8
+      ],
+      "left_group_element": 4,
+      "minimum_calls": 4,
+      "right_group_element": 3,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 4,
+      "direct_generator_indices": [
+        6,
+        0,
+        8,
+        2
+      ],
+      "left_group_element": 4,
+      "minimum_calls": 4,
+      "right_group_element": 4,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 5,
+      "direct_generator_indices": [
+        6,
+        0,
+        2,
+        8,
+        2
+      ],
+      "left_group_element": 4,
+      "minimum_calls": 5,
+      "right_group_element": 5,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 3,
+      "direct_generator_indices": [
+        0,
+        6,
+        0
+      ],
+      "left_group_element": 5,
+      "minimum_calls": 3,
+      "right_group_element": 0,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 4,
+      "direct_generator_indices": [
+        0,
+        6,
+        0,
+        8
+      ],
+      "left_group_element": 5,
+      "minimum_calls": 4,
+      "right_group_element": 1,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 4,
+      "direct_generator_indices": [
+        0,
+        6,
+        0,
+        2
+      ],
+      "left_group_element": 5,
+      "minimum_calls": 4,
+      "right_group_element": 2,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 5,
+      "direct_generator_indices": [
+        0,
+        6,
+        0,
+        2,
+        8
+      ],
+      "left_group_element": 5,
+      "minimum_calls": 5,
+      "right_group_element": 3,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 5,
+      "direct_generator_indices": [
+        0,
+        6,
+        0,
+        8,
+        2
+      ],
+      "left_group_element": 5,
+      "minimum_calls": 5,
+      "right_group_element": 4,
+      "target_in_radius_five": true
+    },
+    {
+      "direct_calls": 6,
+      "direct_generator_indices": [
+        0,
+        6,
+        0,
+        2,
+        8,
+        2
+      ],
+      "left_group_element": 5,
+      "minimum_calls": 6,
+      "right_group_element": 5,
+      "target_in_radius_five": false
+    }
+  ],
+  "transpositions": {
+    "x": 2,
+    "y": 1
+  }
+}
diff --git a/research/bit-s3-two-target-census-seed36501/README.md b/research/bit-s3-two-target-census-seed36501/README.md
new file mode 100644
index 0000000000..78b1e66c1c
--- /dev/null
+++ b/research/bit-s3-two-target-census-seed36501/README.md
@@ -0,0 +1,97 @@
+# No two S3 target maps share a paid call in the transposition model
+
+**Exact two-register bound in one finite nonabelian relaxation; no new κ.**
+For every ordered pair `g,h ∈ S₃`, the exact dirty-register target
+`diag([g],[h])` in `F₂[S₃]` requires exactly
+`|g|_{x,y} + |h|_{x,y}` paid calls when the only address labels are
+`x=(12)` and `y=(23)`. Here `|·|_{x,y}` is shortest word length in those two
+transpositions. Rank-one scalar mixing cannot share a paid call between the
+two targets in this model. This does not establish a bound for the retained
+rational-frame supplier and does not change the selected κ. The source-bound
+baseline replayed for this cycle reports the complex primitive as binding.
+
+The exact census covers all 36 ordered target pairs. Their minimum-call
+histogram is `{0:1, 1:4, 2:8, 3:10, 4:8, 5:4, 6:1}`, equal to the histogram of
+the separate direct bills. In particular, the inverse 3-cycle pair
+`diag([xy],[yx])` costs four calls, and the pair of longest Coxeter elements
+`diag([xyx],[xyx])` costs six.
+
+## Model and complete cost
+
+The group elements are all six permutations of three points, with products
+composed right-to-left. Paid labels are only `x=(12)` and `y=(23)`. A paid
+factor is `I + ([s]+[1])N`, where `N=u vᵀ` is a rank-one idempotent in
+`M₂(F₂)`. There are exactly six such idempotents (`u,v` nonzero and
+`vᵀu=1`), giving twelve paid generators. Each call costs one.
+
+Both endpoint registers contain arbitrary dirty data. The target is exactly
+diagonal, so both off-diagonal group-algebra entries must vanish. There is no
+extra register, COPY, erasure, clean state or free address map. Free scalar
+`GL₂(F₂)` mixing is included: push each free map through a paid factor by
+conjugating `N`; augmentation sends every paid factor to the identity, forcing
+the residual scalar map to be the identity. The twelve-generator alphabet
+therefore covers all normalized words.
+
+For each pair `(g,h)`, separate shortest transposition words give an exact
+upper bound of at most six calls. Any strict saving must lie in the radius-five
+ball. The exact search enumerates that complete ball, and its minimum for every
+pair equals the direct bill. The radius-five ball has layer sizes
+`1, 12, 80, 466, 2,345, 10,760`, for 13,664 distinct formal products. The
+unique maximum-cost pair `(xyx,xyx)` is absent through length five and has its
+six-call direct word, so the same search certifies its exact lower bound.
+
+## Exact evidence and reproduction
+
+`verify.py` enumerates the complete radius-five ball in six-coefficient
+`F₂[S₃]` matrix form. It checks the group table, all twelve paid generators,
+and exact direct words for all 36 targets. A separate literal matrix-product
+implementation checks all 1,885 ordered words of lengths zero through three
+and replays every one of the 13,664 canonical search paths. Each of 108
+single-factor omissions from the direct words fails its target equality. These
+formal coefficient equalities cover arbitrary dirty inputs; this is not a
+finite-address representation test.
+
+Reproduce from the repository root:
+
+```sh
+python3 -I -B research/bit-s3-two-target-census-seed36501/verify.py
+python3 scripts/research_package.py --package research/bit-s3-two-target-census-seed36501 --check-only
+```
+
+Expected first line:
+
+```text
+PASS_S3_TWO_TARGET_NO_SHARING layers=[1, 12, 80, 466, 2345, 10760] pairs=36 minima={'0': 1, '1': 4, '2': 8, '3': 10, '4': 8, '5': 4, '6': 1} sha256=7923043c2764ca3ea6675d0f2ea01866f8a25401e11f10c6a928004b685a62d6
+```
+
+Local direct and optimized verifier replays pass under Python 3.14.7. Python
+3.12 is not installed here, so the registered generic package replay could not
+run locally; metadata and source-pin validation passed. `SOURCES.json` records
+the exact base commit, selected record, task catalogue, review, selected source
+manifest, assembly certificate and D8 predecessor README pins.
+
+## Limits
+
+This result is exact only for two registers, all 36 diagonal target pairs in
+`S₃`, the two specified transposition labels, and the stated rank-one
+idempotent factors. It does not cover more registers, another group or label
+set, arbitrary rational address frames, physical hosting or precision, or the
+recursive paid profile. No selected supplier adoption or new κ is claimed.
+
+## Open next questions
+
+Does a third arbitrary dirty register permit a shared-call saving for a fixed
+S3 target triple, such as `diag([xyx],[xyx],1)` in the same transposition
+alphabet? This would test whether the two-register no-sharing result depends on
+role count. First enumerate the 56 rank-one-idempotent generators for three
+registers and measure exact radius-four state growth for that target before
+searching deeper. The 56-generator ball may grow quickly; the current
+two-register census gives no bound for the expanded role model.
+
+## Credit
+
+This is an independent exact group-algebra search. The nearby D8
+central-commutator result in `research/bit-dihedral-commutator/README.md`
+motivated testing a different finite group and target family; no predecessor
+code is imported. Prepared by Cinna Davis with substantial OpenAI Codex
+assistance. Apache-2.0.
diff --git a/research/bit-s3-two-target-census-seed36501/SOURCES.json b/research/bit-s3-two-target-census-seed36501/SOURCES.json
new file mode 100644
index 0000000000..c3a6be5e2f
--- /dev/null
+++ b/research/bit-s3-two-target-census-seed36501/SOURCES.json
@@ -0,0 +1,48 @@
+{
+  "schema_version": 1,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "files": [
+    {
+      "path": "autoresearch.md",
+      "usage": "provenance",
+      "git_blob": "8d5403e0f10f68a61d0cb9294fa2e83e872d1d82",
+      "sha256": "215b3222f6a943edc69422a28ac21ea1f397ddf54770f1d87ac4195385d73699"
+    },
+    {
+      "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/bit-dihedral-commutator/README.md",
+      "usage": "input",
+      "git_blob": "b7619a5d56f32daf7f48d6cc3a0e260c5a333510",
+      "sha256": "4f3f9df6d6d96a26ccb0fcd2ef947cce5d53b0d992da22e866f1e025be4c0492"
+    },
+    {
+      "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"
+    }
+  ]
+}
diff --git a/research/bit-s3-two-target-census-seed36501/TASK.json b/research/bit-s3-two-target-census-seed36501/TASK.json
new file mode 100644
index 0000000000..807b3b6187
--- /dev/null
+++ b/research/bit-s3-two-target-census-seed36501/TASK.json
@@ -0,0 +1,83 @@
+{
+  "schema_version": 1,
+  "task_id": "bit-new-register-model",
+  "priority_revision": 3,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "original_card": {
+    "id": "bit-new-register-model",
+    "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?",
+    "starting_points": [
+      "research/bit-three-register-lower-bound/README.md",
+      "certificates/selected-result.json"
+    ],
+    "methods": [
+      "Construct the smallest exact identity in a newly specified legal operation alphabet.",
+      "Derive a target-specific relaxation bound for that same explicit alphabet."
+    ],
+    "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read Model section 1 of the three-register bound and identify the exact excluded free operations.",
+      "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Write a complete operation alphabet outside one named premise and price a baseline before searching identities.",
+    "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.",
+    "allowed_variations": [
+      "Choose a fixed larger register count or a specified nonabelian operation family."
+    ],
+    "scope_change_triggers": [
+      "Remaining inside the already-excluded three-register abelian model."
+    ],
+    "overlap_terms": [
+      "three-register",
+      "nonabelian",
+      "group algebra"
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "Exact minimum paid-call cost for every diagonal target diag([g],[h]) with (g,h) in S3 squared, using two arbitrary dirty scalar registers, the transposition labels x=(12), y=(23), and rank-one idempotent factors I+([s]+[1])N.",
+  "scope_change_reason": "The catalogue permits a specified nonabelian family. The first bounded inverse-3-cycle pair had no saving; one evidence-driven pivot expanded the same S3/two-register model to all 36 target pairs, to determine whether no-sharing was target-specific. No further expansion was made.",
+  "bottleneck_link": "This screens whether a changed finite nonabelian bit alphabet permits paid-call sharing across two targets. The group has no physical map to the selected rational-frame supplier, so the result is a scoped alternative-model bound and cannot change the selected recursive profile.",
+  "budget_minutes": 60,
+  "stop_rule": "Exhaust the complete radius-five ball over the twelve paid generators. For each of the 36 target pairs, compare its shortest transposition-word direct construction with the exact ball distance. Since every separate bill is at most six, radius five covers every possible strict saving. Stop at two registers, S3, the two labels, and all diagonal target pairs.",
+  "outcome": "negative-result",
+  "evidence": "CERTIFICATE.json records the complete radius-five layers [1,12,80,466,2345,10760] (13,664 distinct products), exact minima for all 36 pairs, the equal direct-call histogram, 1,885 raw-word literal replays, 13,664 canonical-path formal replays, and 108 omitted-factor controls.",
+  "author": "Cinna Davis",
+  "ai_assistance": "Substantial OpenAI Codex assistance. No predecessor code was imported.",
+  "open_questions": [
+    {
+      "question": "Does a third arbitrary dirty register permit any shared-call saving for an S3 target triple, for example diag([xyx],[xyx],1) with the same paid transpositions?",
+      "why_it_matters": "This would test whether the exact two-register no-sharing result depends on role count and could expose a new multi-target mechanism.",
+      "first_step": "Enumerate the 56 rank-one-idempotent generators for three registers and measure exact radius-four state growth for the fixed target before searching deeper.",
+      "blocked_by": "The generator count and state ball grow quickly; the two-register result supplies no lower bound for the expanded role model."
+    }
+  ],
+  "track": "bit-mechanisms",
+  "accepted_seed": "36501a8544a63b2f0ecd2e6452836c79",
+  "catalogue_priority_revision": 3,
+  "catalogue_sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075",
+  "catalogue_scope_key": "7084092dd726e7ba1f2f",
+  "refined_scope_key": "7084092dd726e7ba1f2f/S3-transposition-two-target-census/r2/all-36/radius-five",
+  "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32",
+  "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18923720",
+  "finding_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18923874",
+  "source_baseline": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY; complex primitive binds; selected kappa unchanged.",
+  "submission_overlap_refresh": {
+    "checked_at_utc": "2026-10-14T12:33:47Z",
+    "open_prs": {
+      "records": 527,
+      "complete_pagination": true
+    },
+    "discussions": {
+      "records": 506,
+      "complete_pagination": true
+    },
+    "exact_s3_pair_census_matches": 0,
+    "warnings": []
+  }
+}
diff --git a/research/bit-s3-two-target-census-seed36501/TASK.md b/research/bit-s3-two-target-census-seed36501/TASK.md
new file mode 100644
index 0000000000..395be366c9
--- /dev/null
+++ b/research/bit-s3-two-target-census-seed36501/TASK.md
@@ -0,0 +1,76 @@
+# Cycle J task card: all two-target maps in the S3 transposition model
+
+- Track: `bit-mechanisms`.
+- Accepted OS seed: `36501a8544a63b2f0ecd2e6452836c79`.
+- Catalogue card: `bit-new-register-model`, scope key `7084092dd726e7ba1f2f`; priority revision 3, catalogue SHA-256 `6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075`.
+- Exact base commit: `0b1cccf86e2f5132ed286a26ef0a681a495740ea`.
+- Selected-record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`.
+- Refined scope key: `7084092dd726e7ba1f2f/S3-transposition-two-target-census/r2/all-36/radius-five`.
+- Claim: https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18923720.
+
+## Question and changed premise
+
+For every ordered pair `g,h` in `S3`, what is the minimum number of paid calls
+to realize the exact dirty-register map `diag([g],[h])` in `F2[S3]`, using only
+the transposition labels `x=(12)` and `y=(23)`? Each call is
+`I + ([s]+[1])N`, with `N` a rank-one idempotent over `F2`. The direct bill is
+the sum of the two shortest `x,y` word lengths.
+
+Scope status: refined from the catalogue's permitted nonabelian-family
+variation. The first bounded target, `diag([xy],[yx])`, had no saving. One
+evidence-driven pivot widened that same finite object to its 36 ordered target
+pairs, to determine whether the obstruction was target-specific. No further
+parameter expansion is in scope.
+
+## Method, full cost and domain
+
+There are six rank-one idempotents in `M2(F2)`, hence twelve paid generators.
+The largest separate direct bill is six calls (`xyx` on each register). An
+exact breadth-first search enumerates the entire radius-five ball. That is
+enough to certify every possible strict saving: all target-pair direct bills
+are at most six, so any cheaper word would have length at most five. Direct
+words give the exact upper bounds; the search gives each matching lower bound.
+
+Count every paid factor. Free scalar `GL2(F2)` basis changes are included by
+normalizing them into arbitrary rank-one idempotents and using augmentation to
+force the residual scalar map to identity. Both endpoint registers are
+arbitrary dirty data. No extra register, COPY, erasure, clean state, or free
+address operation is in the alphabet.
+
+This changes the retained additive rational-frame address group to finite
+nonabelian `S3`. There is no established physical supplier implementation, so
+the result is a scoped alternative-model bound, not a selected-profile or
+`kappa` change.
+
+## Overlap, predecessors and stopping rule
+
+Final pre-submission overlap refresh at 2026-10-14 12:33:47 UTC found no exact
+S3 two-target transposition census among 527 completely paginated open PRs and
+506 Discussion records, and no matching local task/readme/ledger entry. Nearby distinct work:
+PR #1822 uses `Q8` central-commutator pairs; PR #1716 uses a restricted `AGL2`
+triple; Discussions #1759 and #1818 use `UT4` and `D16`; PRs #1478/#1573/#1742
+and overlap handoff #1792 already address the D8 third-register question.
+These differ in group, paid alphabet or target family. Discussion #1167's
+recent claims were in other tracks or different objects.
+
+Predecessor: `research/bit-dihedral-commutator/README.md` is pinned as a
+provenance input in `SOURCES.json`; it studies a D8 central target, while this
+result changes both the group and the target family. No predecessor code is
+imported.
+
+Stop after all 36 minima equal their separate direct bills. Do not expand to
+more registers, other groups or other paid labels in this cycle.
+
+## Evidence and deliverable
+
+The exact radius-five ball has layers `[1,12,80,466,2345,10760]` and 13,664
+distinct products. The 36 pair minima have histogram `{0:1,1:4,2:8,3:10,4:8,5:4,6:1}`,
+identical to the separate direct bills. All 36 direct words replay exactly;
+the maximum-cost pair `(xyx,xyx)` is absent through length five and has its
+six-call direct word. The verifier also checks all 1,885 ordered words through
+length three against an independent formal-product implementation, replays all
+13,664 canonical paths formally, and rejects each of 108 single-factor
+omissions from the direct words.
+
+Deliverable: source-pinned local package and exact certificate. No `kappa` or
+supplier adoption is claimed. Prepared with substantial OpenAI Codex assistance.
diff --git a/research/bit-s3-two-target-census-seed36501/VERIFY.json b/research/bit-s3-two-target-census-seed36501/VERIFY.json
new file mode 100644
index 0000000000..8fcf715e82
--- /dev/null
+++ b/research/bit-s3-two-target-census-seed36501/VERIFY.json
@@ -0,0 +1,21 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/bit-dihedral-commutator/README.md"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Exact S3 group table and rank-one idempotents; complete radius-three paid-word search; direct four-call positive control; literal formal-product replay for every searched word; four omitted-factor negative controls."
+    }
+  ]
+}
diff --git a/research/bit-s3-two-target-census-seed36501/verify.py b/research/bit-s3-two-target-census-seed36501/verify.py
new file mode 100644
index 0000000000..b2259e68cb
--- /dev/null
+++ b/research/bit-s3-two-target-census-seed36501/verify.py
@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+"""Exact radius-three search for the inverse 3-cycle pair in F2[S3]."""
+
+import hashlib
+import itertools
+import json
+import sys
+from pathlib import Path
+
+
+HERE = Path(__file__).resolve().parent
+
+
+def need(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def compose(p, q):
+    """Permutation product p*q, applying q first."""
+    return tuple(p[q[i]] for i in range(3))
+
+
+GROUP = tuple(itertools.permutations(range(3)))
+GID = {g: i for i, g in enumerate(GROUP)}
+TABLE = tuple(tuple(GID[compose(a, b)] for b in GROUP) for a in GROUP)
+E = GID[(0, 1, 2)]
+X = GID[(1, 0, 2)]  # (12)
+Y = GID[(0, 2, 1)]  # (23)
+XY = TABLE[X][Y]
+YX = TABLE[Y][X]
+
+
+def rank_one_idempotents():
+    # N = u v^T; over F2 this parameterization is unique for rank one.
+    return tuple(
+        (u, v)
+        for u in range(1, 4)
+        for v in range(1, 4)
+        if ((u & v).bit_count() & 1)
+    )
+
+
+IDEMPOTENTS = rank_one_idempotents()
+GENERATORS = tuple((g, u, v) for g in (X, Y) for u, v in IDEMPOTENTS)
+
+
+def permute_mask(g, mask):
+    out = 0
+    for a in range(len(GROUP)):
+        if (mask >> a) & 1:
+            out ^= 1 << TABLE[g][a]
+    return out
+
+
+def right_permute_mask(mask, g):
+    out = 0
+    for a in range(len(GROUP)):
+        if (mask >> a) & 1:
+            out ^= 1 << TABLE[a][g]
+    return out
+
+
+PERMUTED_RIGHT = tuple(
+    tuple(right_permute_mask(mask, g) for mask in range(1 << len(GROUP)))
+    for g in (X, Y)
+)
+LABEL_INDEX = {X: 0, Y: 1}
+
+
+def unpack(state):
+    return tuple((state >> (6 * i)) & 63 for i in range(4))
+
+
+def pack(cells):
+    return sum(cell << (6 * i) for i, cell in enumerate(cells))
+
+
+def step(state, generator):
+    """Right-multiply a 2x2 F2[S3] matrix by one paid factor."""
+    g, u, v = generator
+    cells = list(unpack(state))
+    p = PERMUTED_RIGHT[LABEL_INDEX[g]]
+    for row in range(2):
+        value = 0
+        for middle in range(2):
+            if (u >> middle) & 1:
+                value ^= cells[2 * row + middle]
+        delta = value ^ p[value]  # right-multiply by ([g]+[1])
+        for col in range(2):
+            if (v >> col) & 1:
+                cells[2 * row + col] ^= delta
+    return pack(cells)
+
+
+def convolve(left, right):
+    out = 0
+    for a in range(6):
+        if (left >> a) & 1:
+            for b in range(6):
+                if (right >> b) & 1:
+                    out ^= 1 << TABLE[a][b]
+    return out
+
+
+def formal_product(word):
+    """Independent literal 2x2 matrix product with six-bit group coefficients."""
+    out = [1 << E, 0, 0, 1 << E]
+    for index in word:
+        g, u, v = GENERATORS[index]
+        factor = [0, 0, 0, 0]
+        for row in range(2):
+            for col in range(2):
+                cell = (1 << E) if row == col else 0
+                if ((u >> row) & 1) and ((v >> col) & 1):
+                    cell ^= (1 << E) ^ (1 << g)
+                factor[2 * row + col] = cell
+        next_out = [0, 0, 0, 0]
+        for row in range(2):
+            for col in range(2):
+                value = 0
+                for middle in range(2):
+                    value ^= convolve(out[2 * row + middle], factor[2 * middle + col])
+                next_out[2 * row + col] = value
+        out = next_out
+    return tuple(out)
+
+
+IDENTITY = pack((1 << E, 0, 0, 1 << E))
+TARGET_CELLS = (1 << XY, 0, 0, 1 << YX)
+TARGET = pack(TARGET_CELLS)
+
+
+def ball(start, depth):
+    found = {start: ()}
+    frontier = [start]
+    layers = [1]
+    for _ in range(depth):
+        next_frontier = []
+        for state in frontier:
+            prefix = found[state]
+            for i, generator in enumerate(GENERATORS):
+                value = step(state, generator)
+                if value not in found:
+                    found[value] = prefix + (i,)
+                    next_frontier.append(value)
+        frontier = next_frontier
+        layers.append(len(frontier))
+    return found, layers
+
+
+def group_geodesics():
+    words = {E: ()}
+    frontier = [E]
+    while frontier:
+        nxt = []
+        for value in frontier:
+            for label in (X, Y):
+                image = TABLE[value][label]
+                if image not in words:
+                    words[image] = words[value] + (label,)
+                    nxt.append(image)
+        frontier = nxt
+    return words
+
+
+def direct_word(left, right, geodesics):
+    first = tuple(GENERATORS.index((g, 1, 1)) for g in geodesics[left])
+    second = tuple(GENERATORS.index((g, 2, 2)) for g in geodesics[right])
+    return first + second
+
+
+def run():
+    need(len(GROUP) == 6 and len(set(GROUP)) == 6, "S3 group inventory")
+    need(all(TABLE[TABLE[a][b]][c] == TABLE[a][TABLE[b][c]]
+             for a, b, c in itertools.product(range(6), repeat=3)), "associativity")
+    need(TABLE[X][X] == E and TABLE[Y][Y] == E, "transposition involutions")
+    need(XY != YX and TABLE[XY][XY] == YX and TABLE[XY][YX] == E,
+         "inverse 3-cycle target")
+    need(len(IDEMPOTENTS) == 6 and len(set(IDEMPOTENTS)) == 6,
+         "complete rank-one idempotents")
+    need(len(GENERATORS) == 12 and len(set(GENERATORS)) == 12,
+         "complete paid alphabet")
+
+    found, layers = ball(IDENTITY, 5)
+    geodesics = group_geodesics()
+    need(set(geodesics) == set(range(6)), "transposition alphabet does not generate S3")
+
+    # Compare the packed transition with literal products for every ordered
+    # word through length three, and replay every canonical path in the full
+    # radius-five ball using literal group-algebra matrix multiplication.
+    checked = 0
+    for length in range(4):
+        for word in itertools.product(range(len(GENERATORS)), repeat=length):
+            packed_state = IDENTITY
+            for index in word:
+                packed_state = step(packed_state, GENERATORS[index])
+            literal = formal_product(word)
+            need(unpack(packed_state) == literal, "packed/literal product disagreement")
+            checked += 1
+
+    path_replays = 0
+    for state, word in found.items():
+        need(pack(formal_product(word)) == state, "radius-five path formal replay")
+        path_replays += 1
+
+    pair_rows = []
+    omission_controls = 0
+    direct_histogram = {}
+    exact_histogram = {}
+    for left, right in itertools.product(range(6), repeat=2):
+        cells = (1 << left, 0, 0, 1 << right)
+        target = pack(cells)
+        direct = direct_word(left, right, geodesics)
+        direct_cost = len(direct)
+        # The direct construction costs at most six. If a target is absent
+        # from the complete radius-five ball, its exact minimum is therefore 6.
+        exact_cost = len(found[target]) if target in found else 6
+        need(exact_cost == direct_cost, "two targets share a paid call")
+        need(formal_product(direct) == cells, "direct target-pair construction")
+        if target in found:
+            need(pack(formal_product(found[target])) == target,
+                 "shortest target-pair witness replay")
+            need(len(found[target]) == direct_cost,
+                 "shortest paid word does not match direct bill")
+        else:
+            need(direct_cost == 6, "radius-five absence with a shorter direct bill")
+        for i in range(direct_cost):
+            need(formal_product(direct[:i] + direct[i + 1:]) != cells,
+                 "omitted direct factor still reaches target")
+            omission_controls += 1
+        direct_histogram[str(direct_cost)] = direct_histogram.get(str(direct_cost), 0) + 1
+        exact_histogram[str(exact_cost)] = exact_histogram.get(str(exact_cost), 0) + 1
+        pair_rows.append({
+            "left_group_element": left,
+            "right_group_element": right,
+            "direct_calls": direct_cost,
+            "minimum_calls": exact_cost,
+            "target_in_radius_five": target in found,
+            "direct_generator_indices": list(direct),
+        })
+
+    state_digest = hashlib.sha256(
+        b"".join(state.to_bytes(4, "little") for state in sorted(found))
+    ).hexdigest()
+    xyx = TABLE[TABLE[X][Y]][X]
+    inverse_pair = next(p for p in pair_rows
+                        if p["left_group_element"] == XY and p["right_group_element"] == YX)
+
+    certificate = {
+        "status": "PASS_S3_TWO_TARGET_NO_SHARING",
+        "group": "S3",
+        "group_elements": [list(p) for p in GROUP],
+        "transpositions": {"x": X, "y": Y},
+        "target_group_elements": {"xy": XY, "yx": YX, "xyx_yxy": xyx},
+        "registers": 2,
+        "generators": [[g, u, v] for g, u, v in GENERATORS],
+        "rank_one_idempotents": [[u, v] for u, v in IDEMPOTENTS],
+        "identity_radius_five_layers": layers,
+        "identity_radius_five_state_count": len(found),
+        "identity_radius_five_state_sha256": state_digest,
+        "ordered_words_independently_checked_through_length_three": checked,
+        "radius_five_canonical_paths_formally_replayed": path_replays,
+        "target_pair_count": len(pair_rows),
+        "direct_call_histogram": dict(sorted(direct_histogram.items())),
+        "minimum_call_histogram": dict(sorted(exact_histogram.items())),
+        "all_two_target_minima_equal_separate_geodesic_bills": True,
+        "target_pairs": pair_rows,
+        "inverse_three_cycle_pair_minimum": inverse_pair["minimum_calls"],
+        "longest_element_pair_minimum": next(
+            p["minimum_calls"] for p in pair_rows
+            if p["left_group_element"] == xyx and p["right_group_element"] == xyx
+        ),
+        "direct_omission_controls": omission_controls,
+        "packed_transition_independently_replayed": True,
+        "free_scalar_mixing": "captured by all rank-one idempotents after augmentation normalization",
+        "new_kappa_claimed": False,
+    }
+    return certificate
+
+
+def main():
+    result = run()
+    path = HERE / "CERTIFICATE.json"
+    if "--write" in sys.argv:
+        path.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n")
+    else:
+        need(path.is_file(), "missing CERTIFICATE.json")
+        expected = json.loads(path.read_text())
+        need(result == expected, "certificate mismatch")
+    digest = hashlib.sha256(json.dumps(result, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+    print(result["status"], "layers=" + str(result["identity_radius_five_layers"]),
+          "pairs=" + str(result["target_pair_count"]), "minima=" + str(result["minimum_call_histogram"]),
+          "sha256=" + digest)
+
+
+if __name__ == "__main__":
+    main()