diff --git a/research/eisenstein-eleven-total-seed22/EXPECTED.json b/research/eisenstein-eleven-total-seed22/EXPECTED.json
new file mode 100644
index 0000000000..3339a3c16d
--- /dev/null
+++ b/research/eisenstein-eleven-total-seed22/EXPECTED.json
@@ -0,0 +1,112 @@
+{
+  "frames": [
+    550561120257,
+    274890489858,
+    137439150084,
+    4362108936,
+    2181300240,
+    34376519712,
+    8591507520,
+    17181982848,
+    1207968000,
+    68719480320
+  ],
+  "primary": {
+    "flat_count": 772,
+    "support_count": 164110,
+    "rank_counts": {
+      "1": 40,
+      "2": 1230,
+      "3": 162840
+    },
+    "coset_count": 159270,
+    "deficit_counts": {
+      "1": 153920,
+      "2": 4950,
+      "4": 400
+    },
+    "maximum_coset_deficit": 4,
+    "maximum_coset_members": 4
+  },
+  "coordinate_check": {
+    "multi_member_cosets": 4360,
+    "complements_checked": 9200,
+    "complement_pairs_checked": 5470,
+    "independent_coset_count": 159270
+  },
+  "direct_factorizations": {
+    "ports": 4,
+    "rectangles": 225,
+    "ordered_pairs": 50625,
+    "exact_two_term_decompositions": 6,
+    "exact_three_term_decompositions": 618,
+    "minimum_charge_by_active_terms_1_2_3": [
+      null,
+      4,
+      4
+    ]
+  },
+  "sharp_witness": {
+    "ten_total_charge": 40,
+    "eleven_total_charge": 40,
+    "eleven_terms": [
+      [
+        1,
+        550561120257
+      ],
+      [
+        550561120256,
+        550561120257
+      ],
+      [
+        274890489858,
+        274890489858
+      ],
+      [
+        137439150084,
+        137439150084
+      ],
+      [
+        4362108936,
+        4362108936
+      ],
+      [
+        2181300240,
+        2181300240
+      ],
+      [
+        34376519712,
+        34376519712
+      ],
+      [
+        8591507520,
+        8591507520
+      ],
+      [
+        17181982848,
+        17181982848
+      ],
+      [
+        1207968000,
+        1207968000
+      ],
+      [
+        68719480320,
+        68719480320
+      ]
+    ]
+  },
+  "negative_controls": [
+    "duplicate frame rejected",
+    "repeated support violates distinct-coset deficit",
+    "tampered support rank rejected",
+    "full-span charge checked in direct small model"
+  ],
+  "independent_coverage": {
+    "prime": 65537,
+    "minor_absolute_bound": 4096,
+    "generator_sets": 10700,
+    "proper_nonzero_flats": 770,
+    "proper_nonempty_supports": 164110
+  }
+}
diff --git a/research/eisenstein-eleven-total-seed22/PROOF.md b/research/eisenstein-eleven-total-seed22/PROOF.md
new file mode 100644
index 0000000000..1c335977a7
--- /dev/null
+++ b/research/eisenstein-eleven-total-seed22/PROOF.md
@@ -0,0 +1,180 @@
+# One extra total cannot reduce a frame-partition decoder's copy charge
+
+## Statement
+
+Let q and d be positive integers.
+Let V be a d-dimensional real or complex inner-product space with a positive-definite form.
+Partition qd distinct port indices into q sets F_1,...,F_q of size d.
+The vectors at each F_a form an orthogonal basis of V; their norms may differ.
+Different ports may represent the same geometric line.
+For a support R, let X_R be the span of its port vectors.
+Define c(R,A) as the rank of the inner-product pairing between X_R and X_A.
+Equivalently, choose bases and take the rank of their Gram block.
+
+Let B be the binary qd-by-qd matrix with an all-ones block on each F_a-by-F_a and zero elsewhere.
+All matrix identities in the decoder factorization are over F2, regardless of the geometric field.
+For arbitrary port subsets R_j and A_j, suppose
+
+```
+B = sum_{j=1}^m 1_(R_j) 1_(A_j)^T  over F2,
+m <= q+1.
+```
+
+Then the total abstract copy charge satisfies
+
+```
+sum_j c(R_j,A_j) >= qd.
+```
+
+The q frame rectangles attain qd. Thus the bound is sharp, even when non-clean rectangles and cancellation are allowed.
+For d>=2, split one frame reader support into two nonempty parts with the same full-frame source support.
+This gives q+1 active totals at the same charge qd. The verifier checks both E8 witnesses.
+The theorem fixes B. It does not bound other fitting matrices or decompositions with q+2 or more totals.
+It assumes additive pairing-rank charges, not a physical supplier implementation.
+
+For the pinned Eisenstein E8 frame partition, q=10 and d=4 over Q(omega), giving charge at least 40 for every decomposition with at most eleven totals.
+For a direct rational interpretation, each port represents the two-dimensional subspace span_Q(r_i,Jr_i) in Q^8.
+Each frame partitions Q^8 into four mutually orthogonal two-dimensional subspaces.
+The complement argument below remains valid for such subspace ports: replace each vector by its entire subspace.
+Its unnormalized dimension bound is eight; divide all pairing ranks and deficits by two to obtain charge 40.
+The binary factorization argument is unchanged: its dimension q counts frames, not geometric coordinates.
+The pinned geometry verifies J^2+J+I=0 and orthogonality of J.
+Thus all support spans and pairing kernels are J-invariant and have even rational dimension.
+This also justifies the Eisenstein rank normalization without choosing complex floating-point coordinates.
+The current necessary construction screen needs charge at most 31, before other obligations.
+Hence this complete one-extra-total mechanism cannot pass that screen.
+No new kappa, supplier, global decoder optimum, or full multiplication theorem follows.
+
+## The frame code
+
+Let C be the binary span of the q disjoint frame indicators.
+It has dimension q. Both the row space and column space of B equal C.
+Every nonzero word in C contains a complete frame, so its geometric span is V.
+This uses the orthogonal-basis condition only through full spanning.
+
+Remove any zero rectangle from the factorization.
+This preserves B and its charge and cannot increase the number of totals.
+Write B=U Vt, where U's columns are the reader indicators and Vt's rows are the source indicators.
+Both factors have rank at least q, and rank(B)=q.
+
+If m<q, no such factorization exists.
+If m=q, both factors have rank q; their column and row spaces equal C.
+Each nonzero factor support therefore spans V, so each rectangle costs d and the total is qd.
+
+Now suppose m=q+1.
+The factors cannot both have rank q+1, since then U is injective and Vt is surjective, forcing rank(B)=q+1.
+At least one factor has rank q.
+If both have rank q, both support families lie in C and every active rectangle costs d.
+That gives (q+1)d, already at least qd.
+
+It remains to consider rank(U)=q+1 and rank(Vt)=q; the opposite case follows by transposition.
+Since U is injective, rowspace(Vt)=rowspace(B)=C.
+Each nonzero source support A_j spans V, so
+
+```
+c(R_j,A_j) = dim X_(R_j).
+```
+
+The column space of U is a one-dimensional binary extension of C.
+Choose any p outside C in that extension. Each reader support lies in C or p+C.
+The columns of U are independent, so all reader supports are distinct.
+Supports in C have geometric rank d. Only distinct supports in p+C can reduce the charge.
+
+## Orthogonal-complement lemma for one coset
+
+For every distinct support R in one nonzero coset p+C, put Y_R = X_R^perp.
+These subspaces are pairwise orthogonal.
+
+Indeed, R and S differ by a nonzero codeword, which is a union of complete frames.
+Choose a frame F on which their bits differ.
+Because the coefficient field is F2, S intersect F equals F minus R.
+The frame vectors form an orthogonal basis of V. Therefore
+
+```
+Y_R is contained in span(F minus R),
+Y_S is contained in span(R intersect F).
+```
+
+The two right-hand spaces are orthogonal.
+This proves the claim for each distinct pair R,S, even though the chosen frame may depend on the pair.
+
+Pairwise orthogonal subspaces in a positive-definite d-dimensional space have a direct sum.
+Consequently, for any finite set of distinct coset supports,
+
+```
+sum_R (d - dim X_R) = sum_R dim Y_R <= d.
+```
+
+Apply this to the outside-code columns of U. Inside-code columns have deficit zero.
+There are q+1 active rectangles, so
+
+```
+sum_j c(R_j,A_j)
+ = (q+1)d - sum_j (d - dim X_(R_j))
+ >= (q+1)d-d = qd.
+```
+
+This completes the proof. It does not rely on the finite census below.
+Distinctness is necessary in the lemma: repeating one support can repeat the same nonzero complement without bound.
+The full-column-rank reduction supplies exactly that distinctness.
+
+## Exact E8 corroboration
+
+The pinned PR798 geometry and PR1794 deterministic cover specify the concrete ten frames.
+The primary check enumerates all 772 line-spanned flats.
+Every support with geometric rank below four lies in a proper flat, so enumerating every subset of every proper flat is complete.
+Rank-first enumeration assigns each support its least spanning rank.
+The result contains 164110 nonempty supports: 40 of rank one, 1230 of rank two, and 162840 of rank three.
+
+The quotient map toggles a frame whenever its chosen pivot bit is one.
+The disjoint frame indicators make this a canonical representative modulo C.
+There are 159270 nonzero cosets among the proper-span supports.
+Their aggregate deficits are one for 153920 cosets, two for 4950 cosets, and four for 400 cosets.
+No coset has deficit above four. Some contain four rank-three supports.
+This is a check of the lemma on the exact E8 instance, not a new assumption in its proof.
+
+An independent traversal examines all 10700 sets of one, two or three port generators.
+It uses Gaussian elimination modulo the prime 65537, rather than the primary rank-adjoining integer traversal.
+Every input row has squared norm eight, so Hadamard bounds each minor of at most eight rows by 4096.
+No nonzero minor can vanish modulo 65537; all these ranks and membership tests equal their rational values.
+Every proper support span has an Eisenstein basis of at most three ports, so this generator traversal covers every proper flat.
+It finds 770 nonzero proper flats and generates their subsets by combinations of port indices.
+The resulting full support-to-rank dictionary agrees with the primary dictionary on all 164110 entries.
+The two traversals share only the pinned geometric input, not enumeration or row-reduction functions.
+
+The independent coordinate check groups its own support list using per-frame numeric complements, rather than pivot elimination.
+Separate Fraction Gaussian elimination checks all 9200 complements in the 4360 cosets with multiple members.
+It checks all 5470 complement pairs for orthogonality.
+This checks ranks and the lemma on every nontrivial coset after the separate complete-support comparison.
+
+A separate direct factorization model uses two orthogonal bases of Q^2: (e1,e2) and ((1,1),(1,-1)).
+It computes the pairing charge for all 225 nonzero binary rectangles on four ports.
+It exhausts 50625 ordered rectangle pairs, then obtains the uniquely required third rectangle by matrix XOR.
+This finds all six ordered two-term decompositions and all 618 ordered three-term decompositions of the frame-block target.
+Both minimum charges are four; one term is impossible.
+That enumeration uses neither the factor-rank reduction nor the coset lemma.
+It corroborates the reduction through a different mathematical model on a small geometry.
+Neither finite check proves the universal theorem; the written argument above supplies that proof.
+The expected-output file records regression values from the checks, not independent evidence by itself.
+
+## Cost and research decision
+
+The known ten-frame construction costs 40, and adding one total cannot lower that amount.
+The necessary PR1794 threshold is at most 31 across its allowed stage/window template.
+Helpers, source access, frame changes, routing, restoration, recursive children, and assembly obligations can only add to this abstract copy bill.
+Thus physical synthesis stops for this fixed B with at most eleven totals.
+A changed fitting matrix or at least two extra totals is outside this theorem.
+Even those changes still need a complete physical invoice; this result does not certify that they can succeed.
+
+## Credit and limits
+
+Jonathan Lam / PR798 supplies the Eisenstein geometry, pairing-rank model and general clique certificate.
+Joel Pulikkan / GamingPuzzled / PR620 supplies the retained order-three construction.
+Maximooch / PR1794 supplies the orthogonal-frame witness and the necessary cost threshold.
+Josie Elliston / PR1977 reports a stronger general lower bound through different non-clique minrank certificates; this work does not repeat that search.
+The new result is the general one-extra-total obstruction and its fixed-decoder specialization.
+The source methods retain their original attribution and licenses.
+
+Substantial OpenAI Codex assistance covers derivation, implementation, verification, and writing.
+The proof is written mathematics, not a proof-assistant certificate or independent human review.
+Finite replay does not verify the entire conditional multiplication theorem.
diff --git a/research/eisenstein-eleven-total-seed22/README.md b/research/eisenstein-eleven-total-seed22/README.md
new file mode 100644
index 0000000000..4d3d404c52
--- /dev/null
+++ b/research/eisenstein-eleven-total-seed22/README.md
@@ -0,0 +1,87 @@
+# One extra total cannot improve the orthogonal-frame decoder
+
+**Research note / scoped negative result.** For the fixed rank-ten Eisenstein
+orthogonal-frame decoder, every binary decomposition into at most eleven totals
+has abstract pairing charge at least **40**. Both ten and eleven totals attain
+40. Non-clean supports and cancellation are allowed.
+
+The result follows from a general theorem for any partition into orthogonal
+frames. It closes a complete one-extra-total mechanism, rather than a sampled
+neighborhood. The inherited necessary supplier screen requires charge at most
+31, so this mechanism cannot improve the selected complex supplier.
+
+The result fixes the binary decoder matrix. Other fitting matrices and twelve
+or more totals remain open. It gives no supplier, new kappa, unrestricted
+copy optimum, or complete multiplication theorem.
+
+## Argument and evidence
+
+Read [PROOF.md](PROOF.md) for the claim, quantifiers and complete argument.
+With one extra factor, at least one factor space remains the frame code.
+The other factor space extends that code by at most one dimension.
+Distinct supports in one coset have pairwise orthogonal geometric complements.
+Their total rank deficit cannot exceed the ambient dimension.
+This gives the sharp lower bound.
+
+The standard-library verifier supplies three forms of finite corroboration:
+
+- The primary exact census covers 164110 nonempty proper-span E8 supports in
+  159270 cosets. The maximum aggregate deficit is four.
+- An independent traversal checks all 10700 sets of at most three port
+  generators over the prime 65537. A determinant bound makes its ranks exact
+  over the rationals. Combination-based subset enumeration recovers the same
+  complete support-to-rank dictionary. Separate rational elimination then
+  checks 9200 complements and 5470 pairs in all 4360 nontrivial cosets.
+- A direct four-port model enumerates all 225 nonzero rectangles and 50625
+  ordered pairs. Matrix XOR finds every possible third term. All six ordered
+  two-term and 618 ordered three-term decompositions have charge at least four.
+  This check uses neither the factor-space reduction nor the coset argument.
+
+Both E8 sharp witnesses replay exactly. Controls reject a duplicated frame and
+an altered geometric rank. Repeating a low-rank support violates the deficit
+bound and shows why the proof needs distinctness. A direct full-span Gram check
+catches the one-unit underpricing error.
+
+[EXPECTED.json](EXPECTED.json) records regression outputs, not independent
+expected answers. Source pins protect the inherited input files. No proof
+assistant or independent human reviewer has checked the universal theorem.
+The written proof and the finite checks have different roles.
+
+## Reproduce
+
+From the repository root, with standard-library CPython:
+
+```sh
+python3 -B research/eisenstein-eleven-total-seed22/verify.py
+```
+
+Expected final line: `PASS_EISENSTEIN_ELEVEN_TOTAL`.
+The JSON output records the interpreter and exact finite coverage.
+The primary research run uses stable CPython 3.15.0.
+The generic manifest retains the repository's explicit Python 3.12 environment;
+validation records its separate compatibility replay.
+
+## Open next questions
+
+The charge of 40 is already larger than the necessary limit of 31 in PR1794.
+Helpers, source access, frames, copies, restoration, recursive children and
+assembly still require payment. No physical synthesis follows from this note.
+The next question is whether a changed fitting matrix or at least two extra
+totals can lower the complete invoice. Start with an optimistic paid budget.
+No obstruction for that larger scope is established here.
+
+## Provenance and credit
+
+[SOURCES.json](SOURCES.json) pins the base commit and inherited files.
+[TASK.json](TASK.json) records the scope refinement and open question.
+The actual run identifier, seed22 and timing appear in [VALIDATION.md](VALIDATION.md).
+
+Jonathan Lam / PR798 provides the E8 geometry and pairing-rank charge model.
+GamingPuzzled / Joel Pulikkan / PR620 provides the order-three construction.
+Maximooch / PR1794 provides the frame witness and necessary cost screen.
+Josie Elliston / PR1977 studies stronger general minrank bounds; its search is not repeated here.
+This note contributes the general one-extra-total theorem and its specialization.
+
+Charles Bethin, with substantial OpenAI Codex assistance in derivation,
+implementation, verification and writing. New work is Apache-2.0.
+Preserve all predecessor notices. The selected frontier and upstream files are unchanged.
diff --git a/research/eisenstein-eleven-total-seed22/SOURCES.json b/research/eisenstein-eleven-total-seed22/SOURCES.json
new file mode 100644
index 0000000000..910d2222c0
--- /dev/null
+++ b/research/eisenstein-eleven-total-seed22/SOURCES.json
@@ -0,0 +1,42 @@
+{
+  "schema_version": 1,
+  "base_commit": "6aff82d6d346fb2238d061ef45066b82d48a9b67",
+  "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": "research/eisenstein-clique-copy-bound/PROOF.md",
+      "usage": "input",
+      "git_blob": "5c5fd2f87ce3c4e61ed782ceaa623edd80811349",
+      "sha256": "b75539c196ed45f23cf238413da9684dcba503f6630ad68a9648ecacf6aada3f"
+    },
+    {
+      "path": "research/eisenstein-clique-copy-bound/geometry.py",
+      "usage": "input",
+      "git_blob": "a92c16295d6fcf2a7ffeb7d38444613f939db6cb",
+      "sha256": "248df3fb820b5165ca485ad4d43f0271043498c45a59ac1edc310a124073644c"
+    },
+    {
+      "path": "research/eisenstein-phase-cost-screen/README.md",
+      "usage": "input",
+      "git_blob": "288365822b01c077cc8a010ae130dc73a8b06b20",
+      "sha256": "a01595e6f187b7dc607ceeb968a207aaac7a438e8beb6181935cc5ce4e5a349c"
+    },
+    {
+      "path": "research/eisenstein-phase-cost-screen/verify.py",
+      "usage": "input",
+      "git_blob": "cbd95c9c67d47d73db18f5aaa14b557dfa4d814a",
+      "sha256": "c157e9b7e8ab89170ca306e4f5732954a48084853281ee940768b8df606993cd"
+    }
+  ]
+}
diff --git a/research/eisenstein-eleven-total-seed22/TASK.json b/research/eisenstein-eleven-total-seed22/TASK.json
new file mode 100644
index 0000000000..ae3c8b5508
--- /dev/null
+++ b/research/eisenstein-eleven-total-seed22/TASK.json
@@ -0,0 +1,66 @@
+{
+  "schema_version": 1,
+  "task_id": "complex-rank-shape-decoder",
+  "priority_revision": 3,
+  "base_commit": "6aff82d6d346fb2238d061ef45066b82d48a9b67",
+  "original_card": {
+    "id": "complex-rank-shape-decoder",
+    "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?",
+    "starting_points": [
+      "research/complex-local-word-ceiling/README.md",
+      "research/complex-decoder-field-extension-seed44/README.md",
+      "research/complex-frame-pair-decoders/README.md"
+    ],
+    "methods": [
+      "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.",
+      "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration."
+    ],
+    "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/complex-local-word-ceiling/verify.py"
+      ],
+      "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING",
+      "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.",
+      "scope": "Positive control and planning budget only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).",
+    "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.",
+    "allowed_variations": [
+      "One masked, overcomplete or block decoder family with exact labels and supports.",
+      "A scoped lower bound on effective rank for one alphabet.",
+      "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."
+    ],
+    "scope_change_triggers": [
+      "Repacking idle remainders of an unchanged word (covered by the packing ceiling).",
+      "Repeating the eight-term all-pairs search inside its proved scope."
+    ],
+    "overlap_terms": [
+      "rank shape",
+      "block climb",
+      "masked decoder",
+      "overcomplete",
+      "effective rank"
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "Prove a sharp pairing-charge lower bound for every binary decomposition of the fixed orthogonal-frame decoder with at most one extra total.",
+  "scope_change_reason": "The user assigned seed22 to complex suppliers. A rank-ten frame decoder with eleven totals changes the minimal-factorization contract without duplicating the clean-support or general minrank searches.",
+  "bottleneck_link": "The current Eisenstein supplier template needs abstract copy charge at most 31. The theorem proves charge at least 40 for every at-most-eleven-total decomposition of the fixed frame decoder, including non-clean cancellation. This closes one complete mechanism before physical synthesis.",
+  "budget_minutes": 45,
+  "stop_rule": "Stop after the universal argument, complete primary E8 proper-support census, independent coordinate and direct-factorization checks, negative controls, and overlap review.",
+  "outcome": "negative-result",
+  "evidence": "PROOF.md proves the general q-frame theorem. verify.py checks 164110 proper-span supports, 159270 cosets, an independent 10700-generator traversal with all 164110 support ranks compared, 9200 exact complements, 5470 orthogonal complement pairs, and all decompositions with at most three active totals in a separate four-port model. Ten- and eleven-total E8 witnesses attain charge 40. These finite checks do not constitute a proof-assistant certificate or independent human review.",
+  "author": "Charles Bethin, with substantial OpenAI Codex assistance",
+  "ai_assistance": "Substantial OpenAI Codex assistance in the proof, implementation, verification, and writing. No external human review or proof-assistant validation.",
+  "open_questions": [
+    {
+      "question": "Can a different fitting matrix or at least twelve totals lower the full Eisenstein decoder charge below 32?",
+      "why_it_matters": "The fixed frame decoder with at most eleven totals cannot meet the inherited necessary cost gate.",
+      "first_step": "Price the complete optimistic invoice, then study two-dimensional extensions or a changed fitting matrix with exact pairing charges.",
+      "blocked_by": "No mathematical blocker established; the present theorem leaves this scope open."
+    }
+  ]
+}
diff --git a/research/eisenstein-eleven-total-seed22/VALIDATION.md b/research/eisenstein-eleven-total-seed22/VALIDATION.md
new file mode 100644
index 0000000000..132f902a8b
--- /dev/null
+++ b/research/eisenstein-eleven-total-seed22/VALIDATION.md
@@ -0,0 +1,112 @@
+# Validation and acceptance record
+
+Status: research note with a proved scoped obstruction and exact finite corroboration.
+No independent human review or proof-assistant verification is claimed.
+
+## Origin
+
+- Task: `01a1335e-7a24-73c3-a549-9bcb5496a363`.
+- Start: `2026-10-14T16:57:56.445376+00:00`.
+- Base: `6aff82d6d346fb2238d061ef45066b82d48a9b67`.
+- OS draw: `secrets.randbelow(100)` gives 22; assigned track: complex supplier.
+- Scope selection ends at `17:03:42Z`, inside the nine-minute orientation budget.
+- Seed22 selects one extra total through `1 + 22 mod 2`.
+  The exhaustive checks are deterministic; no experiment sampling occurs.
+- Deadline: `17:42:56Z`. Verification begins before the reserved final quarter.
+
+The three candidates were canonical Eisenstein B0, coordinate-plane rails, and
+one extra total for the frame decoder. B0 has binary rank forty.
+PR1996 overlaps coordinate-plane rails. The third candidate changes the
+minimal-factorization contract and has a complete cost-screen stopping rule.
+
+## Four acceptance gates
+
+1. **Precise claim.** The theorem quantifies over every binary factorization
+   of a fixed frame-block matrix with at most q+1 nonzero rectangles.
+   The geometric form is positive definite. Charge is the pairing rank.
+   The rational E8 specialization normalizes two-dimensional port planes by two.
+2. **Complete argument.** Factor ranks reduce the nonminimal case to distinct
+   members of one frame-code coset. Their orthogonal complements are pairwise
+   orthogonal. The dimension bound gives the sharp total qd.
+   Zero factors, both rank-q factors, the transposed case and distinctness
+   each receive explicit treatment in PROOF.md.
+3. **Different validation.** A rank-adjoining exact-integer traversal and an
+   independent generator-combination modular traversal compare every proper
+   support and rank. Separate rational complements validate the geometric
+   mechanism. Direct outer-product enumeration checks the factorization claim
+   on a small geometry without using the proof reduction.
+4. **Concrete value.** Every at-most-eleven-total decomposition of this decoder
+   costs at least 40, while the inherited template requires at most 31.
+   This excludes non-clean cancellations across the complete specified class.
+   Other decoder matrices and twelve or more totals remain open.
+
+These gates do not turn code replay into a proof of integer multiplication.
+The universal theorem depends on the written mathematical argument.
+The source geometry is shared input to both implementations.
+EXPECTED.json is a regression receipt generated from the implementation.
+It is not, by itself, independent verification.
+
+## Exact coverage
+
+The primary traversal finds 772 flats and 164110 nonempty proper-span supports.
+Their ranks are `{1:40, 2:1230, 3:162840}`.
+The independent traversal visits 10700 generator sets and finds 770 nonzero
+proper flats. It reconstructs all 164110 support ranks with a separate traversal.
+A Hadamard minor bound of 4096 makes reduction modulo 65537 exact for this input.
+
+The support list has 159270 cosets, with aggregate deficits
+`{1:153920, 2:4950, 4:400}`.
+The coordinate check verifies 9200 complements and 5470 orthogonal pairs in
+all 4360 cosets that contain multiple low-rank supports.
+
+The direct four-port model covers all 225 nonzero binary rectangles and
+50625 ordered pairs. XOR determines each possible third rectangle uniquely.
+There are six ordered two-term and 618 ordered three-term target factorizations.
+Both minimum charges are four. No one-term target factorization exists.
+The E8 witnesses with ten and eleven active totals both cost forty.
+
+## Replay and controls
+
+Primary interpreter: CPython 3.15.0, stable release checked on python.org.
+
+```text
+3.15.0 (main, Oct  9 2026, 11:16:41) [Clang 21.0.0 (clang-2100.3.34.2)]
+/opt/homebrew/opt/python@3.15/bin/python3.15
+```
+
+All research executions use the Math project's research-python wrapper.
+The repository's explicit generic-manifest environment is a compatibility
+exception: CPython 3.12.12 runs the registered package separately.
+It does not replace the primary research interpreter.
+
+Recorded checks include normal and optimized (`-O -B`) execution, package
+metadata and source pins, the explicit Python 3.12 registered replay, and
+relocation under an unrelated working directory with read-only source files.
+The relocated verifier rejects altered pinned geometry and a changed receipt.
+Internal controls reject duplicated frames and altered geometric ranks.
+A repeated support demonstrates the necessity of distinct coset members.
+A full-span Gram block has charge two in the small model, ruling out a
+one-unit pricing error.
+
+The predecessor cost screen replays its necessary integer threshold of 31.
+The selected-result check, baseline source-binding check, and five selected
+record unit tests pass. These checks are not the complete selected cold replay.
+No selected-source change requires that expensive historical replay here.
+
+## Overlap and review boundary
+
+At `17:17:19Z`, a complete refresh covers 368 open PRs and 653 Discussion
+records, plus 1381 local records. Targeted frame-code and one-extra-total
+terms find no competing claim for this result. This search is not a novelty
+certificate or a literature-wide priority claim.
+No pinned coordination issue exists, so the claim remains in the local capture.
+
+PR1977 remains open at `ea021c002e61fea7f2f9cd1b613f65b88f7eb7e9`.
+Its author is Josie Elliston; its general minrank result has different scope.
+PR798 and PR1794 supply the retained geometry, accounting and cost threshold.
+This note neither reviews nor certifies PR1977's stronger general claim.
+
+Hosted research-library tools are unavailable. The local fallback supplies
+context and checkpoints; the remote inbox is unavailable.
+The entry coverage reports 4009 pending sources and 2196 unavailable sources.
+These gaps preclude treating a missing library result as missing prior work.
diff --git a/research/eisenstein-eleven-total-seed22/VERIFY.json b/research/eisenstein-eleven-total-seed22/VERIFY.json
new file mode 100644
index 0000000000..3043dfa964
--- /dev/null
+++ b/research/eisenstein-eleven-total-seed22/VERIFY.json
@@ -0,0 +1,23 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/eisenstein-clique-copy-bound/PROOF.md",
+    "research/eisenstein-clique-copy-bound/geometry.py",
+    "research/eisenstein-phase-cost-screen/README.md",
+    "research/eisenstein-phase-cost-screen/verify.py"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Two complete E8 support traversals with all ranks compared; separate rational complements; direct four-port decompositions with at most three totals; sharp witnesses and negative controls. Prints PASS_EISENSTEIN_ELEVEN_TOTAL. Review the universal proof separately."
+    }
+  ]
+}
diff --git a/research/eisenstein-eleven-total-seed22/independent.py b/research/eisenstein-eleven-total-seed22/independent.py
new file mode 100644
index 0000000000..a3afb336b7
--- /dev/null
+++ b/research/eisenstein-eleven-total-seed22/independent.py
@@ -0,0 +1,193 @@
+"""Independent coordinate and direct-factorization checks. Apache-2.0.
+Charles Bethin, with substantial OpenAI Codex assistance.
+No predecessor geometry or primary traversal functions are imported here.
+"""
+from fractions import Fraction
+from itertools import combinations
+from collections import defaultdict
+
+
+def require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def rref(rows, width):
+    a = [[Fraction(x) for x in row] for row in rows]
+    pivots = []
+    h = 0
+    for j in range(width):
+        k = next((i for i in range(h, len(a)) if a[i][j]), None)
+        if k is None:
+            continue
+        a[h], a[k] = a[k], a[h]
+        scale = a[h][j]
+        a[h] = [x / scale for x in a[h]]
+        for i in range(len(a)):
+            if i != h and a[i][j]:
+                scale = a[i][j]
+                a[i] = [x - scale*y for x, y in zip(a[i], a[h])]
+        pivots.append(j)
+        h += 1
+        if h == len(a):
+            break
+    return a[:h], pivots
+
+
+def complement(rows, width):
+    a, pivots = rref(rows, width)
+    out = []
+    for j in range(width):
+        if j in pivots:
+            continue
+        v = [Fraction(0)] * width
+        v[j] = 1
+        for row, p in zip(a, pivots):
+            v[p] = -row[j]
+        out.append(v)
+    return out
+
+
+def dot(x, y):
+    return sum(a*b for a, b in zip(x, y))
+
+
+def check_frames(lines, frames):
+    full = (1 << len(lines)) - 1
+    require(sum(frames) == full and all(f.bit_count() == 4 for f in frames), 'partition')
+    require(len(set(frames)) == 10, 'frame count')
+    for f in frames:
+        ports = [i for i in range(40) if f >> i & 1]
+        rows = [v for i in ports for v in lines[i]]
+        require(len(rref(rows, 8)[0]) == 8, 'frame spanning')
+        for i, j in combinations(ports, 2):
+            require(all(dot(x, y) == 0 for x in lines[i] for y in lines[j]), 'frame orthogonality')
+
+
+def check_complements(lines, frames, low):
+    # Canonicalize each local bit pattern by numeric minimum, independently of
+    # the primary check's least-bit pivot elimination.
+    buckets = defaultdict(list)
+    for mask, rank in low.items():
+        signature = tuple(min(mask & f, f ^ (mask & f)) for f in frames)
+        buckets[signature].append((mask, rank))
+    support_count = pair_count = group_count = 0
+    for entries in buckets.values():
+        if len(entries) < 2:
+            continue
+        group_count += 1
+        spaces = []
+        for mask, rank in entries:
+            rows = [v for i in range(40) if mask >> i & 1 for v in lines[i]]
+            null = complement(rows, 8)
+            require(len(null) == 8 - 2*rank, 'independent support rank')
+            spaces.append(null)
+            support_count += 1
+        for a, b in combinations(spaces, 2):
+            require(all(dot(x, y) == 0 for x in a for y in b), 'complement orthogonality')
+            pair_count += 1
+        require(sum(map(len, spaces)) <= 8, 'rational deficit bound')
+    return {'multi_member_cosets': group_count, 'complements_checked': support_count,
+            'complement_pairs_checked': pair_count, 'independent_coset_count': len(buckets)}
+
+
+def small_factorizations():
+    # q=2,d=2. Two orthogonal bases, no frame-code reduction or coset lemma.
+    # Exhaust every ordered pair of nonempty binary supports: 15^2 rectangles.
+    # Exhaust every ordered pair of rectangles, then test the necessary third.
+    vectors = [(1, 0), (0, 1), (1, 1), (1, -1)]
+    rectangles = {}
+    for r in range(1, 16):
+        for a in range(1, 16):
+            rows = [i for i in range(4) if r >> i & 1]
+            cols = [i for i in range(4) if a >> i & 1]
+            matrix = sum(1 << (4*i+j) for i in rows for j in cols)
+            gram = [[dot(vectors[i], vectors[j]) for j in cols] for i in rows]
+            cost = len(rref(gram, len(cols))[0])
+            rectangles[matrix] = cost
+    target = sum(1 << (4*i+j) for i in range(4) for j in range(4) if i//2 == j//2)
+    minima = [rectangles.get(target)]
+    best2 = best3 = 100
+    exact2 = exact3 = 0
+    for x, cx in rectangles.items():
+        for y, cy in rectangles.items():
+            if x ^ y == target:
+                best2 = min(best2, cx+cy)
+                exact2 += 1
+            z = target ^ x ^ y
+            if z in rectangles:
+                best3 = min(best3, cx+cy+rectangles[z])
+                exact3 += 1
+    minima.extend([best2, best3])
+    require(minima == [None, 4, 4], 'direct small factorization minimum')
+    # A full-span/full-span rectangle costs dimension two, not one.
+    require(rectangles[(1 << 16)-1] == 2, 'underpriced full-span control')
+    return {'ports': 4, 'rectangles': len(rectangles), 'ordered_pairs': len(rectangles)**2,
+            'exact_two_term_decompositions': exact2, 'exact_three_term_decompositions': exact3,
+            'minimum_charge_by_active_terms_1_2_3': minima}
+
+
+def independent_supports(lines):
+    """Independent flat coverage by all 1-, 2-, 3-port generator sets.
+
+    Every input row has norm sqrt(8). Every minor of at most eight rows
+    has absolute determinant <= sqrt(8)^8 = 4096 < 65537. Thus rank over
+    this prime agrees with rational rank, including all membership tests.
+    No rank-adjoining traversal or predecessor row reduction is used.
+    """
+    prime = 65537
+    require(len(lines) == 40 and all(len(pair) == 2 for pair in lines), 'line dimensions')
+    require(all(dot(row, row) == 8 for pair in lines for row in pair), 'minor norm bound')
+    def reduce(rows):
+        a = [[x % prime for x in row] for row in rows]
+        h = 0
+        for col in range(8):
+            pivot = next((i for i in range(h, len(a)) if a[i][col]), None)
+            if pivot is None:
+                continue
+            a[h], a[pivot] = a[pivot], a[h]
+            scale = pow(a[h][col], -1, prime)
+            a[h] = [(x*scale) % prime for x in a[h]]
+            for i in range(len(a)):
+                if i != h and a[i][col]:
+                    scale = a[i][col]
+                    a[i] = [(x-scale*y) % prime for x, y in zip(a[i], a[h])]
+            h += 1
+            if h == len(a):
+                break
+        return tuple(tuple(row) for row in a[:h])
+    bases = set()
+    tested = 0
+    for size in (1, 2, 3):
+        for ports in combinations(range(40), size):
+            basis = reduce([v for i in ports for v in lines[i]])
+            require(len(basis) in (2, 4, 6), 'proper rank parity')
+            bases.add(basis)
+            tested += 1
+    flats = []
+    for basis in bases:
+        def member(row):
+            row = [x % prime for x in row]
+            for b in basis:
+                pivot = next(i for i, x in enumerate(b) if x)
+                scale = row[pivot]
+                row = [(x-scale*y) % prime for x, y in zip(row, b)]
+            return not any(row)
+        mask = 0
+        for i, pair in enumerate(lines):
+            yes = [member(v) for v in pair]
+            require(yes[0] == yes[1], 'independent J closure')
+            if yes[0]:
+                mask |= 1 << i
+        flats.append((len(basis)//2, mask))
+    require(len(set(flats)) == len(bases), 'independent flat distinction')
+    low = {}
+    for rank, mask in sorted(flats):
+        ports = [i for i in range(40) if mask >> i & 1]
+        for size in range(1, len(ports)+1):
+            for subset in combinations(ports, size):
+                support = sum(1 << i for i in subset)
+                low.setdefault(support, rank)
+    return low, {'prime': prime, 'minor_absolute_bound': 4096,
+                 'generator_sets': tested, 'proper_nonzero_flats': len(flats),
+                 'proper_nonempty_supports': len(low)}
diff --git a/research/eisenstein-eleven-total-seed22/verify.py b/research/eisenstein-eleven-total-seed22/verify.py
new file mode 100644
index 0000000000..4cc8985418
--- /dev/null
+++ b/research/eisenstein-eleven-total-seed22/verify.py
@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""Exact scoped corroboration of the frame-code theorem. Apache-2.0.
+Charles Bethin, with substantial OpenAI Codex assistance.
+Geometry: Jonathan Lam, PR798; order-three construction: GamingPuzzled, PR620.
+Frame exact-cover order: Maximooch, PR1794.
+"""
+import hashlib
+import importlib.util
+import json
+from collections import Counter, defaultdict
+from itertools import combinations
+from pathlib import Path
+import sys
+import independent as I
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+
+
+def require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def load_geometry():
+    pins = json.loads((HERE/'SOURCES.json').read_text())
+    for item in pins['files']:
+        if item['usage'] == 'input':
+            actual = hashlib.sha256((ROOT/item['path']).read_bytes()).hexdigest()
+            require(actual == item['sha256'], 'source hash: '+item['path'])
+    spec = importlib.util.spec_from_file_location('geometry', ROOT/'research/eisenstein-clique-copy-bound/geometry.py')
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def partition(G, adj):
+    orth = [((1<<40)-1) ^ adj[i] ^ (1<<i) for i in range(40)]
+    frames = []
+    def visit(left):
+        if not left:
+            return True
+        v = min(G.bits(left), key=lambda t: (orth[t] & left).bit_count())
+        for a, b, c in combinations(list(G.bits(orth[v] & left)), 3):
+            if (orth[a] >> b)&1 and (orth[a] >> c)&1 and (orth[b] >> c)&1:
+                f = (1<<v)|(1<<a)|(1<<b)|(1<<c)
+                frames.append(f)
+                if visit(left & ~f):
+                    return True
+                frames.pop()
+        return False
+    require(visit((1<<40)-1), 'orthogonal cover missing')
+    return frames
+
+
+def syndrome(mask, frames):
+    for f in frames:
+        if mask & (f & -f):
+            mask ^= f
+    return mask
+
+
+def census(G, reps, images, frames):
+    flats = G.flats(reps, images)
+    low = {}
+    for mask, basis, _ in flats:
+        rank = len(basis)//2
+        if rank >= 4:
+            continue
+        sub = mask
+        while sub:
+            low.setdefault(sub, rank)
+            sub = (sub-1) & mask
+    groups = defaultdict(list)
+    for mask, rank in low.items():
+        groups[syndrome(mask, frames)].append((mask, rank))
+    require(0 not in groups, 'proper support in frame code')
+    deficits = [sum(4-r for _, r in members) for members in groups.values()]
+    require(max(deficits) == 4, 'coset deficit')
+    return low, {'flat_count': len(flats), 'support_count': len(low),
+                 'rank_counts': dict(sorted(Counter(low.values()).items())),
+                 'coset_count': len(groups),
+                 'deficit_counts': dict(sorted(Counter(deficits).items())),
+                 'maximum_coset_deficit': max(deficits),
+                 'maximum_coset_members': max(map(len, groups.values()))}
+
+
+def witness(G, reps, images, frames):
+    terms = [(f, f) for f in frames]
+    f = frames[0]
+    p = f & -f
+    eleven = [(p, f), (f ^ p, f)] + terms[1:]
+    def decode(terms):
+        rows = [0]*40
+        cost = 0
+        for r, a in terms:
+            for i in G.bits(r):
+                rows[i] ^= a
+            rb = G.echelon([v for i in G.bits(r) for v in (reps[i], images[i])])
+            ab = G.echelon([v for i in G.bits(a) for v in (reps[i], images[i])])
+            cost += G.pairing_rank(rb, ab)
+        return rows, cost
+    ten_rows, ten_cost = decode(terms)
+    eleven_rows, eleven_cost = decode(eleven)
+    require(ten_rows == eleven_rows and ten_cost == eleven_cost == 40, 'sharp witnesses')
+    # Independent coordinate check of the split: ranks 2+6 over Q, hence 1+3.
+    lines = list(zip(reps, images))
+    split = [len(I.rref([v for i in range(40) if r >> i & 1 for v in lines[i]], 8)[0])//2
+             for r in (p, f ^ p)]
+    require(split == [1, 3], 'independent split ranks')
+    return {'ten_total_charge': ten_cost, 'eleven_total_charge': eleven_cost,
+            'eleven_terms': eleven}
+
+
+def negative_controls(lines, frames, low):
+    bad = frames.copy()
+    bad[0] = frames[1]
+    try:
+        I.check_frames(lines, bad)
+    except ValueError:
+        pass
+    else:
+        raise ValueError('duplicate-frame control accepted')
+    # Same coset, repeated singleton: deficit six > four. This demonstrates
+    # why full-column rank/distinctness is essential; it is not an admissible U.
+    singleton = frames[0] & -frames[0]
+    require(2*(4-low[singleton]) == 6, 'duplicate-support negative control')
+    f = frames[0]
+    require(syndrome(singleton, frames) == syndrome(f ^ singleton, frames), 'split coset')
+    tampered = dict(low)
+    tampered[singleton] = 2
+    try:
+        I.check_complements(lines, frames, tampered)
+    except ValueError as exc:
+        require('support rank' in str(exc), 'wrong rank-control failure')
+    else:
+        raise ValueError('rank tampering accepted')
+    return ['duplicate frame rejected', 'repeated support violates distinct-coset deficit',
+            'tampered support rank rejected', 'full-span charge checked in direct small model']
+
+
+def main():
+    G = load_geometry()
+    reps, images, adj, _, _ = G.geometry()
+    frames = partition(G, adj)
+    lines = list(zip(reps, images))
+    I.check_frames(lines, frames)
+    low, primary = census(G, reps, images, frames)
+    independent_low, independent_coverage = I.independent_supports(lines)
+    require(low == independent_low, 'independent complete support coverage')
+    independent = I.check_complements(lines, frames, independent_low)
+    result = {'frames': frames, 'primary': primary, 'independent_coverage': independent_coverage, 'coordinate_check': independent,
+              'direct_factorizations': I.small_factorizations(),
+              'sharp_witness': witness(G, reps, images, frames),
+              'negative_controls': negative_controls(lines, frames, low)}
+    expected = json.loads((HERE/'EXPECTED.json').read_text())
+    require(json.loads(json.dumps(result)) == expected, 'receipt mismatch')
+    print(json.dumps({'sys_version': sys.version, 'sys_executable': sys.executable,
+                      'result': result}, indent=2))
+    print('PASS_EISENSTEIN_ELEVEN_TOTAL')
+
+
+if __name__ == '__main__':
+    main()