diff --git a/research/d10-reflection-sharing-seeda3def8/CERTIFICATE.json b/research/d10-reflection-sharing-seeda3def8/CERTIFICATE.json
new file mode 100644
index 0000000000..368af3bcab
--- /dev/null
+++ b/research/d10-reflection-sharing-seeda3def8/CERTIFICATE.json
@@ -0,0 +1,40 @@
+{
+  "schema_version": 1,
+  "model": {
+    "group": "D10 of order 10",
+    "presentation": "<s,t | s^2=t^2=e,(st)^5=e>",
+    "encoding_primary": "r^k s^epsilon as index 2*k+epsilon, r=st",
+    "encoding_independent": "permutations of the five polygon vertices",
+    "coefficient_field": "F2",
+    "registers": 3,
+    "paid_labels": ["s", "t"],
+    "scalar_factors": "D_N(g)=I+([g]+[e])N; N=xy^T, y^T x=1"
+  },
+  "target": "diag([st],[ts],[e])",
+  "rank_one_idempotents": 28,
+  "search": {
+    "lengths": [0, 1, 2, 3],
+    "candidate_counts": {"0": 1, "1": 56, "2": 3136, "3": 175616},
+    "exact_endpoint_hits": {"0": 0, "1": 0, "2": 0, "3": 0},
+    "total_candidates": 178809,
+    "primary_state_sha256": {
+      "0": "992d20f65528722d3c9f89c6ecd3876deae0d0084d271d8dffa254f1e21dfeae",
+      "1": "75d31c5b61a5e4704d487416541aae736b9a7d35a809c094a12b80a465a57194",
+      "2": "3a734c7f69b67583fd847a2df0919430092d755c757eb9fa2d2aa8dffb71669c",
+      "3": "32cdd595df3a5b2f39853beceb0f4e395f9e1277b1059204f3aeddd2cbee6258"
+    },
+    "independent_state_sha256": {
+      "0": "626523c7a23825bc1c716fb9540513bfa1ae0543b5a35e31993a89236e5e4d5e",
+      "1": "53740396a3f0f73e8392fbb7dae15ec29853e43d507ca3b48051b05fa97e7cb3",
+      "2": "385b9687ea222aa258066118a956483af8faade44fbf6a88bbfd3403018a5854",
+      "3": "078453f4249334b2553bb29e8bc7c8041a6f6910dfa112d9b9f4e571e7699c29"
+    }
+  },
+  "attaining_word": {
+    "labels": ["s", "t", "t", "s"],
+    "projectors": ["E00", "E00", "E11", "E11"],
+    "paid_calls": 4,
+    "exact_endpoint": true
+  },
+  "conclusion": "Exact minimum 4 for this target, register count, and paid alphabet only."
+}
diff --git a/research/d10-reflection-sharing-seeda3def8/README.md b/research/d10-reflection-sharing-seeda3def8/README.md
new file mode 100644
index 0000000000..658429a788
--- /dev/null
+++ b/research/d10-reflection-sharing-seeda3def8/README.md
@@ -0,0 +1,74 @@
+# Finite D10 torsion does not give a three-call inverse-rotation share
+
+**Scoped exact negative result; no new `kappa`.** In the formal group algebra of the dihedral group of order 10, the target
+
+`diag([st],[ts],[e])`
+
+on three arbitrary binary scalar registers has minimum paid-call cost **four** when the only paid address labels are the two reflections `s,t`. The natural three-call overlap word `s,t,s` does not work, and exhaustive exact search rules out every word of at most three calls, with every rank-one idempotent scalar projector allowed. Four calls attain the endpoint directly.
+
+This is a first finite odd-rotation quotient check beside the all-register `D_infinity` reflection tariff in PR #1911. It does not extend that theorem to other finite dihedral groups or register counts. It provides no native supplier mapping, compiler, hosting/precision invoice, conditional bound or selected-frontier change.
+
+## Exact model and result
+
+Let
+
+`G = <s,t | s^2=t^2=e, (st)^5=e>`
+
+be the dihedral group of order 10. Set `r=st`; then `ts=r^-1`. Work in the full formal group algebra `F2[G]`, whose basis is the ten group elements. Matrix products use the group multiplication in their coefficient convolution. No natural or permutation representation is used as a substitute for formal equality.
+
+A paid factor is
+
+`D_N(g) = I + ([g]+[e]) N`,
+
+where `g` is either `s` or `t`, and `N=xy^T` is a rank-one idempotent in `M3(F2)`, with `y^T x=1`. Each factor costs one paid reflection call. There are exactly 28 such projectors. The endpoint identity is coefficientwise equality in `M3(F2[G])`; its third diagonal entry is `[e]`, so the dirty helper is restored exactly.
+
+**Theorem for this finite domain.** The minimum is four. The direct word
+
+`D_E00(s) D_E00(t) D_E11(t) D_E11(s)`
+
+is `diag([st],[ts],[e])`. For the lower bound, the verifier checks every ordered paid-label word over `{s,t}` of lengths 0 through 3 and every choice of the 28 projectors at each position. There are respectively 1, 56, 3,136 and 175,616 candidates, with zero exact endpoints. Thus no three-call mechanism exists in this declared model; the calculation says nothing about longer alphabets, different groups or more registers.
+
+The proposed `s,t,s` word has a tempting path interpretation: its first two labels spell `st` and its last two spell `ts`. The complete search shows that no choice of rank-one idempotents can simultaneously route those overlapping subsequences while cancelling all other group-algebra coefficients.
+
+## Cost accounting and frontier scope
+
+The baseline direct bill is 2 calls for `st` plus 2 for `ts`, total 4; the identity helper needs no call. Every paid factor, including any call used for cleanup, is included in the formal endpoint. The searched alternative allows arbitrary rank-one idempotents on all three roles, so it grants the full scalar projector alphabet at no additional scalar-operation charge. No other operation is allowed for free.
+
+This one-unit candidate saving would be a 25% reduction of this tiny reflection bill if it existed. It does not. Even a positive local word would require a separate justified mapping to the selected bit supplier, full interface and hosting costs, precision, and recursive moment before it could affect `kappa`. The selected conditional construction remains `kappa = 836330098538459/500000000000000000`.
+
+## Evidence and reproduction
+
+Two separate standard-library engines evaluate the full formal endpoint. `verify.py` stores 3x3 binary matrices as nine-bit integers and multiplies against the precomputed finite matrix table. `independent.py` builds `D10` from its action on the five polygon vertices and stores each coefficient matrix as three row masks; its multiplication by a rank-one projector uses the outer-product identity `(A x)y^T`. Their encodings and per-level state digests differ. Both cover the full 178,809 words through length 3 and agree on zero hits. The exact counters and digests are pinned in `CERTIFICATE.json`.
+
+Run:
+
+```sh
+python3 -I -B research/d10-reflection-sharing-seeda3def8/verify.py
+python3 -I -B research/d10-reflection-sharing-seeda3def8/independent.py
+python3 -I -B research/d10-reflection-sharing-seeda3def8/test_package.py
+python3 scripts/research_package.py --package research/d10-reflection-sharing-seeda3def8 --check-only
+python3 -B scripts/research_baseline.py
+make selected-record-check
+```
+
+Expected markers include `PASS_D10_INVERSE_ROTATION_MINIMUM` and `PASS_D10_INDEPENDENT_PERMUTATION_REPLAY`. `--check-only` validates package metadata and source pins; it does not itself prove the minimum. The two verifiers perform that finite calculation. Registered CI requests Python 3.12; this host's available interpreter at packaging time is CPython 3.14.7.
+
+## Task, selected record and overlap
+
+- Accepted cycle seed: `a3def8e7b944810f5d933bfa65cba990`; track `bit-mechanisms`; task `bit-new-register-model`; priority revision 3.
+- Exact base commit: `0b1cccf86e2f5132ed286a26ef0a681a495740ea`.
+- Focused contribution PR: [#1953](https://github.com/CrocSwap/integer-mult-bounds/pull/1953), open at handoff from head `4f3bdf7c` (the package and overlap record are the entire change).
+- Selected record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`.
+- Selected `kappa`: `836330098538459/500000000000000000`; the baseline checker prints `PASS_RESEARCH_BASELINE_BINDINGS_ONLY`, not a cold selected-construction replay.
+- The selected record points to review `docs/research/community-batch1099-review.md`, source manifest `research/community-frontier1094-audit/SELECTED-SOURCE.json`, certificate `research/community-frontier1094-audit/ASSEMBLY.json` (SHA-256 `1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045`), and reproduction target `make frontier1094-verify`; these are pinned in `SOURCES.json`.
+- Coordination claim: [Discussion #1167 comment 18926353](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18926353); handoff goes there.
+- Nearby work: PR #1911 at head `712593f82739203639d0a169b88c6bcac6f0590c` proves reflection tariffs for `D_infinity`, but explicitly does not descend to finite quotients. New open PR #1941 at head `5938ce3e91bbb8b5c2227af7976d444b2fbac7d4` proves tariffs for every **even** rotation order and explicitly leaves odd periods out. PR #1821 at head `a986127fa82b680a5bbb29f49fec4c8c3a944bde` is a D16 central involution; PR #1573 at head `0b8c5a69297c794f2de22c04494c83e41300ae36` is a D8 central-target theorem. PR #1870 at head `538d194e69420a6a773612e0b5ad0c94575f8aaa` exhausts S3 target pairs. Discussion #1929 comment 18925900 is the claim for PR #1941. The current result fixes odd rotation order `n=5` and the noncentral inverse pair, outside #1941's theorem.
+- Overlap limits: the complete refreshed snapshot at 2026-10-14 14:56:57 UTC covered 601 open PRs and 575 Discussion records with no warnings; no D10/order-five target claim appeared. The latest mechanism-thread comments were separately re-read at 14:51:17 UTC, including the even-order claim and #1941's result. Code diffs and closed PRs beyond the local ledger were not globally searched.
+
+Prepared with substantial OpenAI Codex assistance in scope selection, exact enumeration, independent implementation and writing. No independent human review is claimed.
+
+## Open next questions
+
+- Does the same inverse-rotation pair still have the direct four-call minimum in `D_{2p}` for odd primes `p >= 7`, or does another finite torsion order admit a share?
+- Can a torsion-aware invariant explain the D10 minimum uniformly for all finite dihedral quotients without reproducing a separate finite census for each order?
+- Is there a justified compiler/supplier operation that pays only the two chosen reflections and preserves this exact group-algebra endpoint? Without that link, no exponent change follows.
diff --git a/research/d10-reflection-sharing-seeda3def8/SOURCES.json b/research/d10-reflection-sharing-seeda3def8/SOURCES.json
new file mode 100644
index 0000000000..153a274dd5
--- /dev/null
+++ b/research/d10-reflection-sharing-seeda3def8/SOURCES.json
@@ -0,0 +1,100 @@
+{
+  "schema_version": 1,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1",
+      "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075"
+    },
+    {
+      "path": "autoresearch.md",
+      "usage": "provenance",
+      "git_blob": "8d5403e0f10f68a61d0cb9294fa2e83e872d1d82",
+      "sha256": "215b3222f6a943edc69422a28ac21ea1f397ddf54770f1d87ac4195385d73699"
+    },
+    {
+      "path": "CONTRIBUTING.md",
+      "usage": "provenance",
+      "git_blob": "e51435543687f1bd88ab22248082dc689ce8b853",
+      "sha256": "df5b5646602f42cb5da5844f04ac925182ddcd0f627b9de1c96a5095bb7a277a"
+    },
+    {
+      "path": "Makefile",
+      "usage": "provenance",
+      "git_blob": "448f13b58fbe3492e2ea6b2005c8822aefe2765c",
+      "sha256": "029076ba6558f4c97d59d508baeb47847e0fad3545ed1fd22943ab9d6c84c2b9"
+    },
+    {
+      "path": "docs/research/community-batch1099-review.md",
+      "usage": "input",
+      "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099",
+      "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb"
+    },
+    {
+      "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json",
+      "usage": "input",
+      "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8",
+      "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b"
+    },
+    {
+      "path": "research/community-frontier1094-audit/ASSEMBLY.json",
+      "usage": "input",
+      "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0",
+      "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045"
+    },
+    {
+      "path": "research/bit-three-register-lower-bound/README.md",
+      "usage": "input",
+      "git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79",
+      "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd"
+    }
+  ],
+  "external_predecessors": [
+    {
+      "pr": 1911,
+      "head": "712593f82739203639d0a169b88c6bcac6f0590c",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1911",
+      "use": "Infinite-dihedral reflection tariff; explicitly not descended to finite quotients."
+    },
+    {
+      "pr": 1821,
+      "head": "a986127fa82b680a5bbb29f49fec4c8c3a944bde",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1821",
+      "use": "D16 central involution endpoint; not D10 inverse rotations."
+    },
+    {
+      "pr": 1573,
+      "head": "0b8c5a69297c794f2de22c04494c83e41300ae36",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1573",
+      "use": "D8 central target tariff; different group and endpoint."
+    },
+    {
+      "pr": 1870,
+      "head": "538d194e69420a6a773612e0b5ad0c94575f8aaa",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1870",
+      "use": "Exact S3 target-pair census; group and target are different."
+    },
+    {
+      "pr": 1941,
+      "head": "5938ce3e91bbb8b5c2227af7976d444b2fbac7d4",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1941",
+      "use": "Sharp finite-dihedral tariff for all even rotation orders; explicitly leaves odd periods out, so it does not cover D10 with rotation order five."
+    }
+  ],
+  "external_discussions": [
+    {
+      "discussion": 1929,
+      "comment": 18925900,
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1929#discussioncomment-18925900",
+      "use": "Original claim for PR #1941 covers finite dihedral groups with even rotation order; this package fixes odd rotation order five and the noncentral inverse-rotation endpoint."
+    }
+  ]
+}
diff --git a/research/d10-reflection-sharing-seeda3def8/TASK.json b/research/d10-reflection-sharing-seeda3def8/TASK.json
new file mode 100644
index 0000000000..d6b2a8f0f9
--- /dev/null
+++ b/research/d10-reflection-sharing-seeda3def8/TASK.json
@@ -0,0 +1,151 @@
+{
+  "schema_version": 1,
+  "task_id": "bit-new-register-model",
+  "priority_revision": 3,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32",
+  "catalogue_sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075",
+  "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 paid-call minimum for diag([st],[ts],[e]) in M3(F2[D10]), D10=<s,t|s^2=t^2=e,(st)^5=e> of order ten, with paid labels {s,t} and all rank-one idempotents in M3(F2).",
+  "scope_change_reason": "The first candidate was a W=4 rational two-relation endpoint, close to open PR #1733 and Discussion #1700. The selected refinement changes the address group to a finite nonabelian quotient whose torsion is explicitly outside PR #1911, and asks a single exact three-call sharing question for a noncentral inverse-rotation pair.",
+  "bottleneck_link": "Tests whether finite torsion enables shared paid reflection calls across dirty register outputs. A positive local word would still need a separate supplier/compiler and full interface-cost mapping before any conditional-bound consequence.",
+  "budget_minutes": 60,
+  "stop_rule": "Exhaust all rank-one idempotent choices and all paid-label words of lengths zero through three in the exact ten-element group algebra; check the four-call direct endpoint and mutation controls. Stop this construction after the complete finite cover and do not infer results for other groups or widths.",
+  "outcome": "negative-result",
+  "evidence": "Two independently represented standard-library engines exhaust 178,809 words (1, 56, 3,136, 175,616 by length) with zero target hits through three calls. The direct four-call word is exact. Per-level state digests and the attaining word are recorded in CERTIFICATE.json.",
+  "author": "OpenAI Codex research agent",
+  "ai_assistance": "Substantial OpenAI Codex assistance in scope selection, exact enumeration, independent implementation and writing. No independent human review is claimed.",
+  "accepted_seed": "a3def8e7b944810f5d933bfa65cba990",
+  "assigned_track": "bit-mechanisms",
+  "assigned_scope_key": "7f5f4426ef796683c485",
+  "discussion_claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18926353",
+  "claim_expiry_utc": "2026-10-14T16:45:00Z",
+  "predecessors": [
+    {
+      "pr": 1911,
+      "head": "712593f82739203639d0a169b88c6bcac6f0590c",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1911",
+      "use": "Infinite-dihedral reflection tariff; explicitly not descended to finite quotients."
+    },
+    {
+      "pr": 1821,
+      "head": "a986127fa82b680a5bbb29f49fec4c8c3a944bde",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1821",
+      "use": "D16 central involution endpoint; not D10 inverse rotations."
+    },
+    {
+      "pr": 1573,
+      "head": "0b8c5a69297c794f2de22c04494c83e41300ae36",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1573",
+      "use": "D8 central target tariff; different group and endpoint."
+    },
+    {
+      "pr": 1870,
+      "head": "538d194e69420a6a773612e0b5ad0c94575f8aaa",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1870",
+      "use": "Exact S3 target-pair census; group and target are different."
+    },
+    {
+      "pr": 1941,
+      "head": "5938ce3e91bbb8b5c2227af7976d444b2fbac7d4",
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1941",
+      "use": "Sharp finite-dihedral tariff for all even rotation orders; explicitly leaves odd periods out, so it does not cover D10 with rotation order five."
+    }
+  ],
+  "open_questions": [
+    {
+      "question": "Does the inverse-rotation pair keep its direct four-call tariff in D_{2p} for odd primes p>=7?",
+      "why_it_matters": "A different finite torsion order may enable a sharing mechanism absent in D10.",
+      "first_step": "Choose p=7, pin a finite dihedral group table, and test the same target with exact rank-one idempotents at three registers.",
+      "blocked_by": "No uniform torsion-aware invariant is established by this one finite census."
+    },
+    {
+      "question": "Can a torsion-aware invariant explain the D10 minimum for all finite dihedral quotients?",
+      "why_it_matters": "It would replace separate finite censuses with a mechanism-level bound.",
+      "first_step": "Identify a coefficient-ring invariant that detects finite rotation order and bounds simultaneous endpoint routing.",
+      "blocked_by": "The D_infinity Laurent proof does not descend through finite rotation relations."
+    },
+    {
+      "question": "Is there a justified native supplier/compiler for a paid two-reflection alphabet?",
+      "why_it_matters": "Without it the finite group-algebra cost is not a bit-supplier cost.",
+      "first_step": "State an admitted bit primitive realizing exactly s and t and invoice its full interface and restoration.",
+      "blocked_by": "No physical supplier mapping is included here."
+    }
+  ],
+  "selected_result": {
+    "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",
+    "certificate_sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045",
+    "reproduce": "make frontier1094-verify"
+  },
+  "pull_request": {
+    "number": 1953,
+    "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1953",
+    "status": "open",
+    "head": "4f3bdf7c"
+  },
+  "external_discussions": [
+    {
+      "discussion": 1929,
+      "comment": 18925900,
+      "url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1929#discussioncomment-18925900",
+      "use": "Original claim for PR #1941 covers finite dihedral groups with even rotation order; this package fixes odd rotation order five and the noncentral inverse-rotation endpoint."
+    }
+  ],
+  "final_overlap_snapshot": {
+    "searched_at": "2026-10-14T14:56:57.247444Z",
+    "open_prs": 601,
+    "discussions": 575,
+    "complete_pagination": true,
+    "warnings": [],
+    "nearest_new_result": "https://github.com/CrocSwap/integer-mult-bounds/pull/1941",
+    "distinction": "PR #1941 proves all even rotation orders and explicitly excludes odd periods; this package treats the order-five rotation pair in D10."
+  },
+  "handoff": {
+    "result": "Exact minimum four for the D10 order-five inverse-rotation pair with two paid reflections on three registers.",
+    "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/1953",
+    "remaining_obligations": [
+      "Registered Python 3.12 replay and hosted CI",
+      "No native supplier/compiler or physical interface mapping",
+      "No conditional-moment or kappa consequence"
+    ]
+  }
+}
diff --git a/research/d10-reflection-sharing-seeda3def8/TASK.md b/research/d10-reflection-sharing-seeda3def8/TASK.md
new file mode 100644
index 0000000000..190727b5ad
--- /dev/null
+++ b/research/d10-reflection-sharing-seeda3def8/TASK.md
@@ -0,0 +1,20 @@
+# Cycle 14 task card
+
+- Task ID / proposed scope key: `bit-new-register-model`; `bit-new-register-model/D10-r3-inverse-rotation-pair/sts-three-call-supersequence`
+- Accepted OS seed: `a3def8e7b944810f5d933bfa65cba990`; track `bit-mechanisms`; priority revision 3; catalogue SHA-256 `6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075`; base `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; selected-record SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`.
+- Scope status: refined, with one evidence-driven change from the first candidate. The first candidate was a W=4 rational two-relation target. PR #1733 and Discussion #1700 already cover a nearby two-relation W=4 family. This card instead tests finite torsion in a nonabelian group model, a stated open direction in PR #1911.
+- Concrete object and question: in the formal group algebra `F2[D10]`, with `D10=<s,t | s^2=t^2=e, (st)^5=e>`, can three paid factors realize `diag([st],[ts],[e])` on three arbitrary dirty scalar registers? The complete paid alphabet for this experiment is `{s,t}`; each factor is `D_N(g)=I+([g]+[e])N` for a rank-one idempotent `N` in `M3(F2)`. The proposed shared schedule is label word `s,t,s`: the first two labels spell `st`, the last two spell `ts`.
+- Nearest predecessor/overlap: PR #1911 proves an all-register sharp bill in `D_infinity` and expressly notes its Laurent proof does not descend to finite dihedral quotients; its open next question asks for a torsion-aware finite-quotient invariant. New PR #1941 (head `5938ce3e91bbb8b5c2227af7976d444b2fbac7d4`) resolves every even rotation order and explicitly leaves odd periods out. Discussion #1929 comment 18925900 is its original claim. PR #1821 covers a D16 central involution; PR #1573 covers D8 central targets. This task fixes odd rotation order `n=5` and the noncentral inverse pair. The complete final overlap snapshot at 2026-10-14 14:56:57 UTC covers 601 open PRs / 575 Discussions with no warnings and no D10 target claim. The broad #1884 thread includes the D-infinity task; this task was claimed in #1167 with the finite-quotient distinction explicit.
+- Baseline/full cost: two calls for `st` and two for `ts`, total 4; target helpers are identity and restoration is part of formal equality. Candidate target is 3 calls, so one paid-call saving in this abstract model. No supplier, compiler, hosting, precision or recursive interface mapping is assumed; no kappa claim is available from this experiment alone.
+- Method/domain: enumerate all 28 rank-one idempotents in `M3(F2)` for every position and every ordered label word of length at most 3 over `{s,t}`. Exact product in the 10-element formal group algebra, no finite representation substitution. Search candidate `s,t,s` first; then complete the full length-0..3 cover.
+- Optimistic cost and gate: direct 4 vs candidate 3, with each factor priced as one paid reflection. If the exact three-factor endpoint fails in the full cover, stop this construction and report the exact finite obstruction only for this group, target, register count and alphabet.
+- Success/falsification: full coefficient equality to `diag([st],[ts],[e])`; exact direct four-call positive control; one-call omission, label mutation and role-swap negative controls. Seed-specific domain is finite and fully enumerable. Stop after the complete <=3 search plus controls; no broader quotient claim.
+- Intended artifact: self-contained `research/d10-reflection-sharing-seeda3def8/` package with exact replay and scope. Reproduction command planned: `python3 -I -B research/d10-reflection-sharing-seeda3def8/verify.py`.
+- Predecessor attribution: PR #1911 (D-infinity reflection tariffs), PR #1821 (D16 central pair), PR #1573 (D8 central pair), and the base three-register rank-one-idempotent model in `research/bit-three-register-lower-bound/README.md`. Prepared with substantial OpenAI Codex assistance; no independent review claimed.
+
+
+## Handoff
+
+- Result: exact minimum four; all 178,809 words through three calls excluded by both engines, with the direct four-call endpoint verified.
+- PR: [#1953](https://github.com/CrocSwap/integer-mult-bounds/pull/1953), open at handoff from head `4f3bdf7c`.
+- Remaining: registered Python 3.12 replay / hosted CI; no native supplier or compiler mapping; no conditional-moment or `kappa` consequence.
diff --git a/research/d10-reflection-sharing-seeda3def8/VERIFY.json b/research/d10-reflection-sharing-seeda3def8/VERIFY.json
new file mode 100644
index 0000000000..f35c17e88a
--- /dev/null
+++ b/research/d10-reflection-sharing-seeda3def8/VERIFY.json
@@ -0,0 +1,46 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "docs/research/community-batch1099-review.md",
+    "research/community-frontier1094-audit/SELECTED-SOURCE.json",
+    "research/community-frontier1094-audit/ASSEMBLY.json",
+    "research/bit-three-register-lower-bound/README.md",
+    "docs/research/agent-task-catalog.json"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Full exact coefficient search over all label words and all 28 rank-one idempotents through length three; verifies zero hits, deterministic state hashes and four-call endpoint."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/independent.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Independent permutation-built D10 and row-mask engine exhausts the same full domain with separate per-level digests."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/test_package.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Optimized-Python positive and negative controls for group relations, direct endpoint, call deletion, label mutation and role swap."
+    }
+  ]
+}
diff --git a/research/d10-reflection-sharing-seeda3def8/independent.py b/research/d10-reflection-sharing-seeda3def8/independent.py
new file mode 100644
index 0000000000..4b7398c575
--- /dev/null
+++ b/research/d10-reflection-sharing-seeda3def8/independent.py
@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""Independent exact replay using permutation-built D10 and row-vector matrices."""
+from __future__ import annotations
+
+import hashlib
+import json
+from itertools import product
+from pathlib import Path
+
+RREG = 3
+BITS = 7
+ZERO_M = (0, 0, 0)
+ID_M = (1, 2, 4)
+
+
+def as_perm(k: int, e: int) -> tuple[int, ...]:
+    return tuple((k + (-j if e else j)) % 5 for j in range(5))
+
+
+PERMS = [as_perm(k, e) for k in range(5) for e in range(2)]
+PERM_INDEX = {p: i for i, p in enumerate(PERMS)}
+
+
+def compose(a: tuple[int, ...], b: tuple[int, ...]) -> tuple[int, ...]:
+    """Permutation product a*b means apply b, then a."""
+    return tuple(a[b[i]] for i in range(5))
+
+
+TABLE = [[PERM_INDEX[compose(a, b)] for b in PERMS] for a in PERMS]
+E = PERM_INDEX[(0, 1, 2, 3, 4)]
+S = PERM_INDEX[(0, 4, 3, 2, 1)]
+T = PERM_INDEX[(4, 3, 2, 1, 0)]
+R = PERM_INDEX[(1, 2, 3, 4, 0)]
+R_INV = PERM_INDEX[(4, 0, 1, 2, 3)]
+assert len(PERMS) == 10 and len(PERM_INDEX) == 10
+assert TABLE[S][T] == R and TABLE[T][S] == R_INV
+assert TABLE[S][S] == E and TABLE[T][T] == E
+assert TABLE[R][R] == 4
+rot = E
+for _ in range(5):
+    rot = TABLE[rot][R]
+assert rot == E
+assert all(TABLE[TABLE[a][b]][c] == TABLE[a][TABLE[b][c]]
+           for a in range(10) for b in range(10) for c in range(10))
+
+PROJECTORS = [(x, y) for x in range(1, 8) for y in range(1, 8)
+              if (x & y).bit_count() & 1]
+assert len(PROJECTORS) == 28
+EXPECTED_DIGESTS = {
+    0: "626523c7a23825bc1c716fb9540513bfa1ae0543b5a35e31993a89236e5e4d5e",
+    1: "53740396a3f0f73e8392fbb7dae15ec29853e43d507ca3b48051b05fa97e7cb3",
+    2: "385b9687ea222aa258066118a956483af8faade44fbf6a88bbfd3403018a5854",
+    3: "078453f4249334b2553bb29e8bc7c8041a6f6910dfa112d9b9f4e571e7699c29",
+}
+CERTIFICATE = json.loads(Path(__file__).with_name("CERTIFICATE.json").read_text(encoding="utf-8"))
+if CERTIFICATE["search"]["independent_state_sha256"] != {
+        str(k): v for k, v in EXPECTED_DIGESTS.items()}:
+    raise RuntimeError("D10 certificate mismatch: independent state digests")
+if CERTIFICATE["search"]["total_candidates"] != 178809:
+    raise RuntimeError("D10 certificate mismatch: total candidates")
+
+# Algebra matrix state: a ten-tuple of three row bitmasks per group element.
+UNIT = tuple(ID_M if g == E else ZERO_M for g in range(10))
+TARGET = tuple((1, 0, 0) if g == R else
+               (0, 2, 0) if g == R_INV else
+               (0, 0, 4) if g == E else ZERO_M for g in range(10))
+
+
+def add_rows(a: tuple[int, ...], b: tuple[int, ...]) -> tuple[int, ...]:
+    return (a[0] ^ b[0], a[1] ^ b[1], a[2] ^ b[2])
+
+
+def right_call(state: tuple[tuple[int, ...], ...], label: int,
+               projector: tuple[int, int]) -> tuple[tuple[int, ...], ...]:
+    x, y = projector
+    out = [ZERO_M for _ in range(10)]
+    for g, rows in enumerate(state):
+        if rows == ZERO_M:
+            continue
+        image = tuple(y if (row & x).bit_count() & 1 else 0 for row in rows)
+        unchanged = add_rows(rows, image)  # multiply by I+N
+        h = TABLE[g][label]
+        out[g] = add_rows(out[g], unchanged)
+        out[h] = add_rows(out[h], image)
+    return tuple(out)
+
+
+def word_state(labels: tuple[int, ...], projectors: tuple[tuple[int, int], ...]):
+    state = UNIT
+    for label, projector in zip(labels, projectors):
+        state = right_call(state, label, projector)
+    return state
+
+
+def main() -> None:
+    expected_counts = {0: 1, 1: 56, 2: 3136, 3: 175616}
+    counts = {}
+    hits = {}
+    digests = {}
+    for k in range(4):
+        digest = hashlib.sha256()
+        count = hit = 0
+        for labels in product((S, T), repeat=k):
+            for projectors in product(PROJECTORS, repeat=k):
+                state = word_state(labels, projectors)
+                record = bytes(labels)
+                record += b"".join(bytes(p) for p in projectors)
+                record += bytes(row for coeff in state for row in coeff)
+                digest.update(record)
+                count += 1
+                hit += state == TARGET
+        counts[k] = count
+        hits[k] = hit
+        digests[k] = digest.hexdigest()
+    assert counts == expected_counts
+    assert hits == {0: 0, 1: 0, 2: 0, 3: 0}
+    assert digests == EXPECTED_DIGESTS
+
+    e00 = (1, 1)
+    e11 = (2, 2)
+    direct = word_state((S, T, T, S), (e00, e00, e11, e11))
+    assert direct == TARGET
+    assert word_state((T, S, S, T), (e00, e00, e11, e11)) != TARGET
+    print("INDEPENDENT_SEARCH_COUNTS", counts)
+    print("INDEPENDENT_SEARCH_HITS", hits)
+    print("INDEPENDENT_STATE_SHA256", digests)
+    print("PASS_D10_INDEPENDENT_PERMUTATION_REPLAY min_calls=4 tested_words_le3=178809")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/d10-reflection-sharing-seeda3def8/test_package.py b/research/d10-reflection-sharing-seeda3def8/test_package.py
new file mode 100644
index 0000000000..cf52a7123d
--- /dev/null
+++ b/research/d10-reflection-sharing-seeda3def8/test_package.py
@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""Small behavioral controls for the D10 package."""
+from __future__ import annotations
+
+from importlib.util import module_from_spec, spec_from_file_location
+from pathlib import Path
+
+_SPEC = spec_from_file_location("d10_verify", Path(__file__).with_name("verify.py"))
+verify = module_from_spec(_SPEC)
+_SPEC.loader.exec_module(verify)
+
+
+def require(condition: bool, message: str) -> None:
+    if not condition:
+        raise SystemExit("FAIL_D10_PACKAGE_TEST: " + message)
+
+
+def main() -> None:
+    require(len(verify.PROJECTORS) == 28, "rank-one idempotent census")
+    require(verify.GROUP_TABLE[verify.S][verify.T] == verify.R, "st=r relation")
+    require(verify.GROUP_TABLE[verify.T][verify.S] == verify.R_INV, "ts=r^-1 relation")
+    require(verify.group_mul(verify.S, verify.S) == verify.E, "s involution")
+    require(verify.group_mul(verify.T, verify.T) == verify.E, "t involution")
+
+    labels, projectors = verify.direct_four_call()
+    direct = verify.word_state(labels, projectors)
+    require(direct == verify.TARGET, "four-call direct endpoint")
+    for drop in range(4):
+        short_labels = labels[:drop] + labels[drop + 1:]
+        short_projectors = projectors[:drop] + projectors[drop + 1:]
+        require(verify.word_state(short_labels, short_projectors) != verify.TARGET,
+                "one-call omission control " + str(drop))
+
+    wrong_labels = list(labels)
+    wrong_labels[1] = verify.S
+    require(verify.word_state(tuple(wrong_labels), projectors) != verify.TARGET,
+            "wrong-label control")
+    swapped_target = tuple((1 << 0) if g == verify.R_INV else
+                           (1 << 4) if g == verify.R else
+                           (1 << 8) if g == verify.E else 0
+                           for g in range(verify.NGROUP))
+    require(direct != swapped_target, "role-swap corruption control")
+    require(verify.word_state((verify.T, verify.S, verify.S, verify.T),
+                              (1, 1, 16, 16)) == swapped_target,
+            "role-swapped positive control")
+    require(verify.word_state((verify.S, verify.T, verify.S),
+                              (1, 1, 1)) != verify.TARGET,
+            "proposed three-call supersequence control")
+    print("PASS_D10_PACKAGE_CONTROLS projectors=28 direct_calls=4 mutations=6")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/d10-reflection-sharing-seeda3def8/verify.py b/research/d10-reflection-sharing-seeda3def8/verify.py
new file mode 100644
index 0000000000..e813a6e5af
--- /dev/null
+++ b/research/d10-reflection-sharing-seeda3def8/verify.py
@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""Exact rank-one-idempotent word search in F2[D10] on three registers."""
+from __future__ import annotations
+
+import hashlib
+import json
+from itertools import product
+from pathlib import Path
+
+NREG = 3
+NGROUP = 10
+MASK = (1 << NREG) - 1
+IDENTITY_MATRIX = sum(1 << (i * NREG + i) for i in range(NREG))
+
+
+def group_mul(a: int, b: int) -> int:
+    """Encode D10 elements r^k s^e by 2*k+e; r=st, s^2=t^2=1."""
+    ka, ea = divmod(a, 2)
+    kb, eb = divmod(b, 2)
+    k = (ka + (-kb if ea else kb)) % 5
+    return 2 * k + (ea ^ eb)
+
+
+E = 0
+S = 1
+T = 9  # s*r = r^-1*s, since t=s*r and r=st
+R = 2
+R_INV = 8
+
+
+def mat_mul(a: int, b: int) -> int:
+    """Multiply encoded 3x3 matrices over F2."""
+    out = 0
+    for i in range(NREG):
+        row = (a >> (i * NREG)) & MASK
+        for j in range(NREG):
+            col = sum(((b >> (k * NREG + j)) & 1) << k for k in range(NREG))
+            if (row & col).bit_count() & 1:
+                out |= 1 << (i * NREG + j)
+    return out
+
+
+MATMUL = [[mat_mul(a, b) for b in range(1 << 9)] for a in range(1 << 9)]
+
+
+def mat_rank(a: int) -> int:
+    rows = [(a >> (i * NREG)) & MASK for i in range(NREG)]
+    rank = 0
+    for col in range(NREG):
+        pivot = next((i for i in range(rank, NREG) if (rows[i] >> col) & 1), None)
+        if pivot is None:
+            continue
+        rows[rank], rows[pivot] = rows[pivot], rows[rank]
+        for i in range(NREG):
+            if i != rank and ((rows[i] >> col) & 1):
+                rows[i] ^= rows[rank]
+        rank += 1
+    return rank
+
+
+def rank_one_idempotents() -> list[int]:
+    vals = set()
+    for x in range(1, 1 << NREG):
+        for y in range(1, 1 << NREG):
+            if (x & y).bit_count() & 1:
+                n = sum((((x >> i) & 1) * (((y >> j) & 1)) << (i * NREG + j))
+                        for i in range(NREG) for j in range(NREG))
+                vals.add(n)
+    result = sorted(vals)
+    assert len(result) == 28
+    assert all(MATMUL[n][n] == n and mat_rank(n) == 1 for n in result)
+    return result
+
+
+PROJECTORS = rank_one_idempotents()
+EXPECTED_PRIMARY_DIGESTS = {
+    0: "992d20f65528722d3c9f89c6ecd3876deae0d0084d271d8dffa254f1e21dfeae",
+    1: "75d31c5b61a5e4704d487416541aae736b9a7d35a809c094a12b80a465a57194",
+    2: "3a734c7f69b67583fd847a2df0919430092d755c757eb9fa2d2aa8dffb71669c",
+    3: "32cdd595df3a5b2f39853beceb0f4e395f9e1277b1059204f3aeddd2cbee6258",
+}
+
+
+def require(condition: bool, message: str) -> None:
+    if not condition:
+        raise RuntimeError("D10 certificate mismatch: " + message)
+
+
+CERTIFICATE = json.loads(Path(__file__).with_name("CERTIFICATE.json").read_text(encoding="utf-8"))
+require(CERTIFICATE["search"]["primary_state_sha256"] ==
+        {str(k): v for k, v in EXPECTED_PRIMARY_DIGESTS.items()}, "primary state digests")
+require(CERTIFICATE["search"]["candidate_counts"] ==
+        {"0": 1, "1": 56, "2": 3136, "3": 175616}, "candidate counts")
+require(CERTIFICATE["search"]["exact_endpoint_hits"] ==
+        {"0": 0, "1": 0, "2": 0, "3": 0}, "hit counts")
+require(CERTIFICATE["target"] == "diag([st],[ts],[e])", "target statement")
+GROUP_TABLE = [[group_mul(a, b) for b in range(NGROUP)] for a in range(NGROUP)]
+assert all(GROUP_TABLE[E][g] == g and GROUP_TABLE[g][E] == g for g in range(NGROUP))
+assert all(GROUP_TABLE[g][GROUP_TABLE[g][E]] == E for g in (S, T))
+assert GROUP_TABLE[S][T] == R and GROUP_TABLE[T][S] == R_INV
+assert group_mul(R, R) == 4 and group_mul(group_mul(R, R), group_mul(R, R)) == R_INV
+assert group_mul(R, R_INV) == E and group_mul(R_INV, R) == E
+assert group_mul(group_mul(R, R), group_mul(group_mul(R, R), R)) == E
+assert all(group_mul(group_mul(a, b), c) == group_mul(a, group_mul(b, c))
+           for a in range(NGROUP) for b in range(NGROUP) for c in range(NGROUP))
+
+# A state is a tuple of ten coefficient matrices, one per group element.
+ZERO = (0,) * NGROUP
+UNIT = tuple(IDENTITY_MATRIX if g == E else 0 for g in range(NGROUP))
+
+
+def right_multiply_call(state: tuple[int, ...], label: int, n: int) -> tuple[int, ...]:
+    """Right multiply by I + ([label]+[e])N in characteristic two."""
+    id_part = IDENTITY_MATRIX ^ n
+    out = [0] * NGROUP
+    for g, coeff in enumerate(state):
+        if coeff:
+            out[g] ^= MATMUL[coeff][id_part]
+            out[GROUP_TABLE[g][label]] ^= MATMUL[coeff][n]
+    return tuple(out)
+
+
+def word_state(labels: tuple[int, ...], projectors: tuple[int, ...]) -> tuple[int, ...]:
+    state = UNIT
+    for label, n in zip(labels, projectors):
+        state = right_multiply_call(state, label, n)
+    return state
+
+
+def target_state() -> tuple[int, ...]:
+    coeffs = [0] * NGROUP
+    coeffs[R] = 1 << 0
+    coeffs[R_INV] = 1 << (1 * NREG + 1)
+    coeffs[E] = 1 << (2 * NREG + 2)
+    return tuple(coeffs)
+
+TARGET = target_state()
+
+
+def direct_four_call() -> tuple[tuple[int, ...], tuple[int, ...]]:
+    e00 = 1 << 0
+    e11 = 1 << 4
+    labels = (S, T, T, S)
+    projectors = (e00, e00, e11, e11)
+    assert all(n in PROJECTORS for n in projectors)
+    return labels, projectors
+
+
+def exhaustive(max_length: int = 3) -> dict[int, tuple[tuple[int, ...], tuple[int, ...]] | None]:
+    hits = {k: None for k in range(max_length + 1)}
+    counts = {k: 0 for k in range(max_length + 1)}
+    hit_counts = {k: 0 for k in range(max_length + 1)}
+    digests = {k: hashlib.sha256() for k in range(max_length + 1)}
+    for k in range(max_length + 1):
+        for labels in product((S, T), repeat=k):
+            for projectors in product(PROJECTORS, repeat=k):
+                counts[k] += 1
+                state = word_state(labels, projectors)
+                record = bytes(labels)
+                record += b"".join(n.to_bytes(2, "little") for n in projectors)
+                record += b"".join(c.to_bytes(2, "little") for c in state)
+                digests[k].update(record)
+                if state == TARGET:
+                    hit_counts[k] += 1
+                    if hits[k] is None:
+                        hits[k] = (labels, projectors)
+    expected = {0: 1, 1: 56, 2: 3136, 3: 175616}
+    assert counts == expected, (counts, expected)
+    assert hit_counts == {0: 0, 1: 0, 2: 0, 3: 0}, hit_counts
+    assert {k: d.hexdigest() for k, d in digests.items()} == EXPECTED_PRIMARY_DIGESTS
+    print("SEARCH_COUNTS", counts)
+    print("SEARCH_HITS", hit_counts)
+    print("SEARCH_STATE_SHA256", {k: d.hexdigest() for k, d in digests.items()})
+    return hits
+
+
+def main() -> None:
+    hits = exhaustive(3)
+    direct_labels, direct_projectors = direct_four_call()
+    direct = word_state(direct_labels, direct_projectors)
+    assert direct == TARGET
+    assert all(hits[k] is None for k in range(4))
+    # The supplied four-call word is a positive control; every one-factor
+    # deletion and one label mutation fails exact full-group-algebra equality.
+    for drop in range(4):
+        reduced_labels = direct_labels[:drop] + direct_labels[drop + 1:]
+        reduced_ns = direct_projectors[:drop] + direct_projectors[drop + 1:]
+        assert word_state(reduced_labels, reduced_ns) != TARGET
+    mutated_labels = list(direct_labels)
+    mutated_labels[1] = S
+    assert word_state(tuple(mutated_labels), direct_projectors) != TARGET
+    swapped_target = tuple((1 << 0) if g == R_INV else
+                           (1 << 4) if g == R else
+                           (1 << 8) if g == E else 0
+                           for g in range(NGROUP))
+    assert TARGET != swapped_target
+    assert direct != swapped_target
+    swapped_direct = word_state((T, S, S, T), (1, 1, 16, 16))
+    assert swapped_direct == swapped_target
+    print("DIRECT_CONTROL labels=stts calls=4 exact_endpoint=true")
+    print("NEGATIVE_CONTROLS deleted_calls=4 label_mutation=1 role_swap_distinct=true")
+    print("PASS_D10_INVERSE_ROTATION_MINIMUM min_calls=4 tested_words_le3=178809 projectors=28 group_order=10")
+
+
+if __name__ == "__main__":
+    main()