diff --git a/research/encoded-minimum-root-prefix/EVIDENCE.md b/research/encoded-minimum-root-prefix/EVIDENCE.md
new file mode 100644
index 0000000000..d06ec5d50e
--- /dev/null
+++ b/research/encoded-minimum-root-prefix/EVIDENCE.md
@@ -0,0 +1,75 @@
+# Validation record
+
+Canonical base: df0137efd35e11b4445734bf612bdd4c7ebc330c.
+Priority revision: 7. Selected conditional kappa: 0.00310045.
+All values are source-relative; the selected frontier is unchanged.
+
+## Completed normal checks
+
+Python 3.14.7 passed both original checker phases. RESULT.json records their
+full output. The arithmetic phase covers 1,251 cases, including 771 with
+non-power divisors and 316 where R<S<2R. Three cases use the historical
+2,642-bit production divisor. Six invalid inputs reject and return all
+scratch. All 29 source plan fields remain present. The search peak is 14
+live leases in a fixed pool of 32.
+
+Measured search work is 4,273,750 physical reads, 858,487 writes and
+4,087,798 moves. It includes output cleanup, but excludes input construction,
+verifier observation and final caller destruction of the borrowed inputs.
+This is a positive finite operation receipt, not a whole-root cost claim.
+
+Seven complete dirty roots pass an independent butterfly Walsh oracle.
+Four retain the production parameter formulas with reduced guard exponent
+two. Three fast roots use the explicit reduced parameter law and complete
+C2 fixture. Two of them use six families, stock six and real four-to-six row
+padding. The same six-family layer is reused. The full run has 35 recursive
+entries and 35 returns. Planner pool peaks are 32 for the direct tests and
+47 for both fast variants. Payload and descriptor bytes, head positions,
+blank owned roles and closed pools pass. A nonzero returned padding row
+rejects; the same padding engine then succeeds on a valid packet.
+
+The registered phases split these same domains into four bounded commands.
+Their data sequences restart per phase, so their digests can differ from
+the original combined root receipt. Each endpoint uses its own independent
+oracle; no expected digest is copied from the implementation.
+
+## Source and scope
+
+The four input files are pinned to retention commit
+244e717163e902558b3e7ce5e767b38fc4413db6. The retained source archive has
+74 exact regular files, including the historical source's required selected
+record and nested primitive archives. Every member has its Git blob,
+SHA256 and size checked before activation. No source execution body changes.
+The archive is an isolated dependency closure, not a frontier update.
+
+No production O73/GL64 payload, complete changed QQ16 invoice, full selected
+frontier verification, proof-assistant acceptance or independent human
+review ran. The shallow checkout does not support a full-history publication
+preflight; exact input bytes and immediate retained-source ancestry are
+checked. No bound beyond the written source-relative interface is claimed.
+
+## Registered replay and bounded retry
+
+All four registered commands passed on Python 3.12.14. The first attempt
+used a 180-second cap for the direct fixtures and timed out without an
+assertion failure. The checker had computed each expensive fractional-power
+plan twice. It now records the plan from the actual root call through a
+verifier-only subclass. The production planner is unchanged. The direct cap
+is 400 seconds; all four declared caps sum to 1,200 seconds. The rerun passes.
+
+The final overlap check used all 7,676 main note records, 389 open PRs and
+5,030 Discussion records through 2026-10-26 07:30 UTC. Separate literal-term
+and cached-body scans found the released PR5515/5688 handoffs and this claim;
+no competing encoded-planner claim appeared. Main was fetched again and is
+still the stated base. No merge, closure or frontier change was made.
+
+## Export and optimized replay
+
+Scientific commit 1470cc5f2ddf1332701f35d1492c71b5202e17ae passes the
+14-file committed-byte check and official export/check. All four final
+commands pass with Python 3.12.14 under -I -O -B, no Git checkout and an
+empty PATH. All 15 exported files, including the export manifest, keep their
+bytes and read-only modes. An actual change to the retained source archive
+fails authentication before execution. RESULT.json records the receipt.
+The final closeout adds only this evidence and receipts; executable bytes
+remain those checked in the scientific commit.
diff --git a/research/encoded-minimum-root-prefix/PREFIX-PROOF.md b/research/encoded-minimum-root-prefix/PREFIX-PROOF.md
new file mode 100644
index 0000000000..fbb40eab49
--- /dev/null
+++ b/research/encoded-minimum-root-prefix/PREFIX-PROOF.md
@@ -0,0 +1,229 @@
+# Minimum row-reservation prefix at the actual root core
+
+This is a conditional root-interface theorem and an exact reference compiler.
+It concerns the original 73-dimensional physical backend retained by QQ16.
+It does not install a production Count frontend or prove a new kappa.
+
+## 1. Source contract and changed parameter
+
+The retained RootPlan has precision p>=2, global width
+`d=floor(p^(997/1000))`, spacing `K=floor(d^(1/500))`, selected width n<=d,
+`G=4 ceil(log2 p)+6`, and H=dG. Keep these fields and
+
+```text
+qF=ceil(2H/K),  qB=ceil(H/K),  M=n-qF-qB,
+F=14336 Gamma,  Gamma=2^1296 product_(j=1..36)(2^(2j)-1).
+```
+
+The selected-C backend has ranks {1,2,3,4,5,7,8,48}. It tests w<73 or
+w^1000<d before its remainder step. PR5515 supplies the exact depth
+
+```text
+T=max(73,ceil(d^(1/1000))),
+D(w)=0 for w<T; otherwise D(w)=1+D(48 floor(w/73)).
+```
+
+D is nondecreasing. All reached selected-C row divisions are positive and
+exact if and only if F^D(w) divides the incoming rows. This is inherited
+from PR5515; it is not a new depth theorem. Native/Ordinary internals retain
+the source's complete endpoint and admission contracts.
+
+The old plan uses `q0=2642 D0(d)`, where D0 ignores the height cutoff and
+2642=ceil(log2 F). It then creates **2^(K q0)** original rows. Thus q0 is
+an axis count, not a bit count. Every reserved axis already supplies K row
+bits. A shorter depth alone does not use this large difference.
+
+If M<=0, use the direct root leaf. Assume M>0 below. For a proposed integer
+q with 0<=q<M, the remaining core has width M-q. Define
+
+```text
+S(q)=F^D(M-q),       R(q)=2^(Kq),
+P(q)=ceil(R(q)/S(q)) S(q).
+```
+
+P is the padded row count. We retain the original strict volume promise
+`P(q)<2 R(q)`, complete prefixes, complete zero padding, and exact division
+by S(q). This is the format in which the minimum below is proved.
+
+## 2. Exact feasibility and minimum
+
+For positive integers S,R,
+
+```text
+ceil(R/S) S < 2R    if and only if    S < 2R.
+```
+
+If S>R, the left side is just S<2R. If S<=R, then
+`ceil(R/S) S < R+S <=2R`, including equality R=S in the second inequality.
+Thus the equivalence holds. For R=2^(Kq), it becomes
+
+```text
+floor(log2 S(q)) <= Kq.                                      (1)
+```
+
+This includes powers of two with the correct strict boundary. The source
+condition R>=S is sufficient but stronger: a stock between R and 2R also
+fits. The reference compiler uses `(S.bit_length()-1)`, with S=1 allowed.
+
+The left side of (1) is nonincreasing in q, and the right side is increasing.
+There is a unique least feasible q. The value q=M-1 is feasible because its
+core has width one and S=1. A smaller known upper bound is
+
+```text
+U=min(M-1, ceil(2642 D(M)/K)).
+```
+
+If the second branch applies, K U>=2642 D(M)>=log2 S(U). The first branch
+was already proved feasible. Binary search between the failed sentinel -1
+and U gives the exact minimum q*. Its certificate is the exact power-bit
+comparison at q* and the failed comparison at q*-1, unless q*=0.
+This proves the compiler for all inputs in the stated format; a finite
+width scan is not used as its proof.
+
+No smaller prefix in this same complete-row format can keep the strict
+factor-two volume bound. A different row encoding, a different permitted
+volume factor or a different supplier can have a different minimum.
+
+## 3. Bind the complete root interface
+
+Set the plan's q0=q*, depth=D(M-q*), and stock=S(q*). Recompute all dependent
+fields with the source formulas. Keep qF,qB and all global precision fields.
+The actual consumers are recorded in CONSUMER-INVENTORY.json. Both a lexical
+pass and an AST literal pass cover all 32 Python files in the retained
+physical-complex-controller directory. Tests are distinguished from production.
+The package pins all those files; it does not rely on their moving checkout.
+
+The production use chain is complete within this source module:
+
+1. RootPlan.compute derives Q0, original_rows, stock, padded_rows, core_width
+   and row_bits. No independent downstream depth consumer exists there.
+2. RootLayer.reserved_leaves uses q0+qF at the high selected end and qB at
+   the low end. These leave exactly M-q0 core axes.
+3. RootLayer.fast_core passes both row counts to RowPadding and passes
+   padded_rows as Machine's rows. It passes global d unchanged.
+4. RowPadding copies every genuine row under every prefix, appends zero
+   rows, and checks every removed padding bit on return. Machine divides
+   its incoming rows by F at each nonterminal selected-C node.
+
+The following identities hold for any admissible q0, not only the old choice:
+
+```text
+core_front=qF K-2H,     core_back=qB K-H+right,
+core_front+3H+(n-q0-qF-qB)K+core_back=(n-q0)K+right,
+prefixes=outer_rows*2^left,
+original_rows*2^((n-q0)K+right)=2^(nK+right).
+```
+
+Thus the root address partition and row serialization remain those proved
+by Jose Manuel and independently refined by Sagar Thakrar. There is no
+truncated high field, changed original payload or free private row. The
+three selected-axis regions are disjoint and cover all n axes. At the
+completed rowwise linear recursive endpoint, each added zero row is again
+zero, even if intermediate operations mix rows. The unchanged removal test
+therefore remains valid under that inherited endpoint premise.
+
+Since P is a positive multiple of F^depth, PR5515's exact-depth contract
+supplies every reached row quotient. Sequential children reuse it. No
+additional factor is lost at a sibling. Complete spectators stay in the
+source rectangle. This is a source-relative proof; it does not reprove the
+native, Ordinary, Compact or numerical endpoint.
+
+The compact guard also remains valid. Fast entry requires n>q0+qF+qB and
+n<=d, hence K>3G. The source's sufficient inequality
+`K>=3G+1>G+4 ceil(log2 p)+10` follows unchanged. Front/back residues lie in
+[0,K). The changed q0 is at most the old 2642D0(d). Its reserved-leaf count
+and descriptor extents therefore do not exceed that source allowance. The
+recursive core stays at most d; padded volume remains strictly below twice
+the original volume. The original exponent estimate can retain its former
+upper bounds. No improved total exponent follows from this finite reduction.
+
+For source inputs that were direct only because of the old q0, the new plan
+may choose a fast branch. The same guard and full endpoint argument apply;
+this does not grant a zero cost to the new core or the reserved leaves.
+
+## 4. One axis suffices eventually
+
+Fix the source divisor F. For every integer p>=2^14000 and every source
+selected width with M>0, the minimum is
+
+```text
+q*=0 if M<T; otherwise q*=1.                                (2)
+```
+
+Here is an explicit integer proof. Put u=floor(log2 p),
+`v=floor(997u/500000)`. Then K>=2^v and v>=27. Two maximum child steps
+contract by less than one half, since `2*48^2<73^2`. Hence
+
+```text
+D0(d)<=2 ceil(log2 d),
+2642 D0(d)<=5284(u+1).
+```
+
+For v>=27, `u+1 <= ceil(500000(v+1)/997)+1`. At v=27,
+
+```text
+2^27 = 134217728 > 74208496
+      = 5284(ceil(500000*28/997)+1).
+```
+
+Each increase in v raises the right side by at most 5284*502=2652568.
+The right side at 27 already exceeds this increment. Doubling the left
+side therefore preserves the strict inequality by induction. It follows
+that K>2642D0(d). For q=1 this is more than the required stock bit count
+at any core width at most d. If M>=T, q=0 has S>=F>1 and fails (1); q=1
+has a positive core and succeeds. If M<T, q=0 has S=1 and succeeds. This
+proves (2), with no floating logarithm and no unstated eventual constant.
+
+## 5. Exact source geometry at p=2^8500
+
+Use d=isqrt(2^16949), K=126519, T=356 and G=34006. The old coarse depth is
+13999 and its prefix is 36985358 axes.
+
+For n=d, the exact minimum is **293 axes**, with reached depth13993. The
+stock floor logarithm is36959276. The chosen row address has37070067 bits;
+292 axes have too few bits. Independent inverse thresholds from PR5515
+confirm the reached depth. No giant payload or row-count array is built.
+
+For the same selected input widths used by the old lambda45 and lambda72
+QQ16 band fixtures, the new minimum is **one axis**. The new cores have
+widths36988642 and36990613, both with depth28 and stock floor logarithm73955.
+This changes their internal core: the old one-generation C8 interpretation
+must not be carried over. These are root-plan witnesses, not a new matched
+QQ16 caller bill or the old call program with work silently removed.
+
+## 6. Construction cost and execution limits
+
+The reference compiler uses exact host integers. It is not a physical Count
+implementation. A direct encoded construction is as follows. Use the source
+fixed-degree integer-root routines to compute T. Store the endpoints and
+midpoint of the bounded binary search as Counts. For each candidate, subtract
+q from M, iterate the fixed maximum child map until below T, multiply a
+Count initially one by the fixed F once per level, scan its binary length,
+and compare that length minus one with Kq. Close each temporary before the
+next candidate. Save the final q and depth. Then use the existing source
+formulas to form stock, original_rows and padded_rows.
+
+With B=ceil(log2(p+2)) and fixed F, the depth is O(B), the search interval
+is O_F(B), and each trial stores O_F(B)-bit values. The T computation uses
+O(B) binary-search trials and fixed-degree integer products. A direct tape
+implementation can charge O_F(B^5) read/write/move actions and O_F(B^2)
+visited scratch bits, using scans for every indexed arithmetic access.
+These loose positive bounds include counters, copies, comparisons, returns
+and clearing. They require no random-access oracle or free host arithmetic.
+They are constructive planning bounds, not measurements of the retained
+Count routines. Integration must use actual Count primitives and meter it.
+
+The final original_rows descriptor can have O_F(B+K) bits: the known upper
+bound gives Kq*<=2642D0(d)+K. Its construction is separately charged by the
+source's output-bit scans; it is not hidden in the O(B)-bit trial workspace.
+The former bound was O_F(KB). All payload, parking, leaf and native costs
+remain paid. This package does not install a production frontend or execute
+production O73/GL64 payloads.
+
+The checker independently enumerates20000 minima using actual padded integer
+row counts, checks10245 all-child depth entries, and tests21 complete finite
+layout/tensor endpoints on dirty data. Those reduced layouts are declared
+address controls, not production p-geometries. Exact production descriptors
+and both sides of each claimed minimum are checked separately. The written
+proof supplies the all-parameter result. No proof-kernel or independent human
+acceptance is claimed.
diff --git a/research/encoded-minimum-root-prefix/PROOF.md b/research/encoded-minimum-root-prefix/PROOF.md
new file mode 100644
index 0000000000..7041db856e
--- /dev/null
+++ b/research/encoded-minimum-root-prefix/PROOF.md
@@ -0,0 +1,135 @@
+# Encoded minimum root prefix at the complete caller
+
+Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0.
+
+This package implements the minimum-prefix construction of PR5688 on the
+retained physical Count interface. The numeric minimum and its production
+witnesses belong to that predecessor. The new result is an encoded search,
+a complete RootPlan adapter, and completed reduced RootLayer executions.
+There is no new complete kappa bound.
+
+## Domain and exact search
+
+Fix integers 1<=r<m<=73, F>1, and T>=m. The three borrowed input Counts
+encode M>=1, K>=1 and T. They start in canonical form at their first digit.
+The fixed constants m,r,F belong to the compiled construction. Define
+
+```text
+D(w)=0 if w<T; otherwise D(w)=1+D(r floor(w/m)),
+S(q)=F^D(M-q), R(q)=2^(Kq), P(q)=ceil(R(q)/S(q)) S(q).
+```
+
+The retained PREFIX-PROOF.md proves that P(q)<2R(q) is equivalent to
+floor(log2 S(q))<=Kq. It proves monotonicity and the feasible upper bound
+U=min(M-1,ceil(cD(M)/K)), where c=ceil(log2 F). These statements hold also
+when R(q)<S(q)<2R(q). This package uses them without a stronger rounding
+condition.
+
+`reached_profile` keeps a Count for the current width. After i iterations,
+it contains the i-fold maximum child width; the other two Counts contain
+i and F^i. The width strictly decreases at every iteration. The loop stops
+exactly when the current width is below T. It returns D(w) and F^D(w).
+
+`floor_log2` scans the stock digits, increments an encoded digit count,
+and subtracts one. The stock is positive, so this subtraction is defined.
+The only host bit-length operation in planner.py is `(F-1).bit_length()`.
+F is fixed at construction. No input-dependent Count is decoded.
+
+The search maintains a closed interval [lower,upper] that contains the
+least feasible q. Initially lower=0 and upper=U. It computes the encoded
+floor midpoint, evaluates the exact predicate, and replaces the appropriate
+endpoint. If the midpoint fails, monotonicity excludes every value below
+or equal to it. If it succeeds, the minimum is no larger. The interval
+strictly decreases until its endpoints agree. The final profile is computed
+at that q. Thus the output is the least prefix in the specified complete-row
+format for every valid input. Exhaustive finite tests are separate evidence.
+
+## Root interface
+
+`MinimumRootPlan` inherits the source constructor, all 29 named roles,
+`count`, `clear`, and the 256-tape scratch pool. Its production parameter law
+is unchanged: d=floor(p^(997/1000)), K=floor(d^(1/500)),
+G=4 ceil(log2 p)+6, H=dG and delta=d*2^guard_exponent. The default guard
+exponent remains 210000. The selected width, residue, coefficient and row
+domains remain the source domains.
+
+It keeps qF=ceil(2H/K) and qB=ceil(H/K). For M=n-qF-qB>0 it computes
+T=max(m,ceil(d^(1/1000))), then saves the encoded minimum q0, exact depth
+and stock. For M<=0 it uses the direct branch. Every dependent field uses
+the source formula, including Q0, the two row counts, row_bits, core_width,
+core_front and core_back. Unused direct-branch depth is zero. Source address,
+guard, row-divisibility and zero-row endpoint arguments are retained from
+PR5688 and the physical controller; they are not new native proofs here.
+
+The existing RootLayer constructor accepts a plan. This is the sole
+integration point. This package changes no retained execution body and
+adds no runtime patch. The root applies the actual phase sweeps, reserved
+leaves, row padding, recursive Machine, normalization and truncation. The
+non-power fixture has q0=2, depth=1, stock=6, four original rows and six
+padded rows. It reaches the complete Walsh endpoint and removes the two
+zero rows. A nonzero added row is rejected by the source removal routine.
+
+The complete fast fixtures use an explicit reduced parameter law
+(d,K,G,H,delta)=(8,1,1,1,32). They use the complete elementary C2 fixture.
+One or three disjoint copies of its two-family group give divisors two
+or six. Copying a complete group changes the row divisor but not its
+rowwise endpoint. The fixed source Ordinary backend uses q=2. These tests
+are not production O73/GL64 payloads. Four direct-root fixtures keep the
+production parameter formulas but use guard exponent two.
+
+## Ownership and positive cost
+
+All trial values are physical Count tapes. Their arithmetic is the retained
+serial tape code. Each trial closes its core, depth, stock, digit count and
+product before the next trial. Every borrowed input is rewound. Only the
+three returned Counts remain live on success. Invalid domain controls leave
+no live scratch lease. The caller closes the three outputs.
+
+The standalone search needs at most 14 simultaneous owned leases. Before a
+trial it has one, dimension_count, last, lower, upper and midpoint: six.
+Core, returned depth and stock raise this to nine. The logarithm scan has
+two local Counts and one subtraction result, for a peak of twelve. Its
+returned bit count leaves ten live. Count.product temporarily needs factor,
+scan and result, plus the one copy used by Count.add, for a peak of fourteen.
+The initial profile, upper-bound division and final profile stay below that
+peak. Compare, normalization and small fixed arithmetic need no extra lease.
+The verifier checks this against a fixed pool of 32 tapes.
+
+The root has fewer than 96 retained expression results and fewer than 32
+simultaneous primitive temporaries. These are fixed source expression counts,
+not functions of input width. The new search is below that temporary bound.
+The inherited pool of 256 therefore remains sufficient. The tested roots
+record their actual peaks. Empty pools and blank owned role tapes are checked
+at complete returns; borrowed records and descriptor bytes are preserved.
+
+Put B=ceil(log2(p+2)) and fix the construction constants. The trial interval
+has O_F(B) values and each candidate uses O_F(B)-bit Counts. Serial copy,
+comparison, schoolbook products, division, counters, rewinds and clearing
+have positive costs. The loose O_F(B^5) tape-action and O_F(B^2) scratch-bit
+bounds from PR5688 cover this direct implementation and the fixed-degree
+threshold computation. The final original_rows descriptor can have
+O_F(B+K) bits. Its construction and the other root output descriptors are
+charged separately by their source scans. Payload copies, leaves, native
+calls, parking and normalization remain paid.
+
+The finite action receipt counts physical reads, writes and moves from
+entry to output cleanup for 1,251 searches. It excludes input construction,
+verifier observations and the caller's final destruction of borrowed inputs.
+It is not a complete root bill or a measured production speedup. The fixed
+search pool and the unchanged root pool add no input-dependent tape count.
+
+## Frozen source and validation limits
+
+The physical cohort authenticates a historical selected record. The retained
+archive contains its exact source closure, with a per-member Git blob,
+SHA256 and byte count in SOURCE-INDEX.json. It includes that historical
+record only inside the isolated archive. The live selected frontier is not
+changed. `retained.py` verifies all members before it activates the source
+cohort. The source's own activation adapters are unchanged and remain part
+of its inherited contract. Temporary extraction does not modify the package.
+
+The source hash control, optimized Git-free run, bounded integer oracle,
+complete reduced endpoint tests and ownership checks establish the stated
+executable evidence. They do not establish the complete production physical
+refinement, a literal universal transition table, independent human or
+formal acceptance, an improved QQ16 invoice, or a new multiplication theorem.
diff --git a/research/encoded-minimum-root-prefix/README.md b/research/encoded-minimum-root-prefix/README.md
new file mode 100644
index 0000000000..74fe723642
--- /dev/null
+++ b/research/encoded-minimum-root-prefix/README.md
@@ -0,0 +1,67 @@
+# Encoded minimum root prefix
+
+This implements PR5688's minimum root-prefix search on the actual Count
+tapes, then supplies all 29 RootPlan fields to the unchanged RootLayer.
+It closes the predecessor's encoded integration gap. The complete kappa
+calculation does not change.
+
+The [proof](PROOF.md) gives the search invariants, caller contract and
+positive costs. The [evidence](EVIDENCE.md) separates exact bounded checks,
+complete reduced payloads and omitted production obligations. Source pins
+are in [SOURCES.json](SOURCES.json); each retained archive member is in
+[SOURCE-INDEX.json](SOURCE-INDEX.json).
+
+The search uses no input-dependent host integer decoder. It returns the
+least q with `ceil(2^(Kq)/S)*S < 2^(Kq+1)`, where `S=F^D(M-q)`.
+The unchanged physical caller executes a stock-six case with four original
+rows and six padded rows. The exact endpoint, borrowed state, empty pools
+and erased owned fields all pass. Repeated use and nonzero-padding rejection
+are tested. These fast payloads use the declared reduced parameter law and
+complete C2 fixture, not the production O73/GL64 backend.
+
+## Reproduce
+
+Use Python 3.12 and its standard library:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/encoded-minimum-root-prefix
+```
+
+The four commands report `PASS_ENCODED_MINIMUM_ROOT_PREFIX_ARITHMETIC`,
+`PASS_ENCODED_MINIMUM_ROOT_PREFIX_ROOTS-DIRECT`,
+`PASS_ENCODED_MINIMUM_ROOT_PREFIX_ROOTS-TWO` and
+`PASS_ENCODED_MINIMUM_ROOT_PREFIX_ROOTS-SIX`. The runner then reports
+`PASS_REGISTERED_RESEARCH_PACKAGE`. Its declared total cap is 1,200 seconds.
+A Git-free export uses the same four commands in VERIFY.json.
+
+The archive holds the exact historical source closure required by the
+physical cohort. Its historical selected record is isolated inside the
+archive. Loading it does not change the live selected frontier. The source
+activation adapters remain inherited code; this package adds no runtime
+patch or changed source execution body.
+
+## Credit
+
+Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. No subagents.
+This uses the same assistant family as
+[PR #5688](https://github.com/CrocSwap/integer-mult-bounds/pull/5688), which
+supplied the numeric minimum, root field argument and one-axis theorem.
+This is not an independent human audit of that theorem.
+
+Jose Manuel's [PR #3385](https://github.com/CrocSwap/integer-mult-bounds/pull/3385)
+supplied the physical controller, Count cohort, complete root and C2 fixtures.
+`compute` is adapted from that source. commdata2338's
+[PR #5515](https://github.com/CrocSwap/integer-mult-bounds/pull/5515)
+supplied the exact reached-depth rule. Nick Petalas's
+[PR #4865](https://github.com/CrocSwap/integer-mult-bounds/pull/4865)
+and Sagar Thakrar's
+[address refinement](https://github.com/CrocSwap/integer-mult-bounds/blob/df0137efd35e11b4445734bf612bdd4c7ebc330c/research/complex-root-address-refinement/PROOF.md)
+supply the retained geometry and address context. All source notices and
+nested predecessor archives remain intact.
+
+## Open next questions
+
+- Recompute a complete QQ16 or signed caller invoice at the changed core
+  geometry. A shorter prefix alone does not establish an exponent gain.
+- Review the all-size physical refinement against the pinned Count and
+  native contracts. Reduced complete payloads do not discharge it.
diff --git a/research/encoded-minimum-root-prefix/RESULT.json b/research/encoded-minimum-root-prefix/RESULT.json
new file mode 100644
index 0000000000..061a17e867
--- /dev/null
+++ b/research/encoded-minimum-root-prefix/RESULT.json
@@ -0,0 +1,250 @@
+{
+  "normal_python": "3.14.7",
+  "arithmetic": {
+    "cases": 1251,
+    "failure_controls": 6,
+    "fixed_pool_capacity": 32,
+    "non_power_divisor_cases": 771,
+    "peak_live_leases": 14,
+    "plan_fields": 29,
+    "production_divisor_bits": 2642,
+    "rows_below_stock_cases": 316,
+    "source_inputs": 4,
+    "status": "PASS_ENCODED_MINIMUM_ROOT_PREFIX_ARITHMETIC",
+    "tape_moves": 4087798,
+    "tape_reads": 4273750,
+    "tape_writes": 858487
+  },
+  "complete_roots": {
+    "packets": 7,
+    "padding_failure_controls": 1,
+    "plan_pool_peaks": [
+      32,
+      47,
+      47
+    ],
+    "plans": [
+      {
+        "core_width": 0,
+        "depth": 0,
+        "families": 2,
+        "original_rows": 1,
+        "padded_rows": 1,
+        "q0": 0,
+        "reduced_law": false,
+        "stock": 1
+      },
+      {
+        "core_width": 0,
+        "depth": 0,
+        "families": 2,
+        "original_rows": 1,
+        "padded_rows": 1,
+        "q0": 0,
+        "reduced_law": false,
+        "stock": 1
+      },
+      {
+        "core_width": 0,
+        "depth": 0,
+        "families": 2,
+        "original_rows": 1,
+        "padded_rows": 1,
+        "q0": 0,
+        "reduced_law": false,
+        "stock": 1
+      },
+      {
+        "core_width": 0,
+        "depth": 0,
+        "families": 2,
+        "original_rows": 1,
+        "padded_rows": 1,
+        "q0": 0,
+        "reduced_law": false,
+        "stock": 1
+      },
+      {
+        "core_width": 3,
+        "depth": 1,
+        "families": 2,
+        "original_rows": 4,
+        "padded_rows": 4,
+        "q0": 2,
+        "reduced_law": true,
+        "stock": 2
+      },
+      {
+        "core_width": 3,
+        "depth": 1,
+        "families": 6,
+        "original_rows": 4,
+        "padded_rows": 6,
+        "q0": 2,
+        "reduced_law": true,
+        "stock": 6
+      },
+      {
+        "core_width": 3,
+        "depth": 1,
+        "families": 6,
+        "original_rows": 4,
+        "padded_rows": 6,
+        "q0": 2,
+        "reduced_law": true,
+        "stock": 6
+      }
+    ],
+    "recursive_events": {
+      "enter": 35,
+      "return": 35
+    },
+    "scope": "Production root formulas with reduced guard; fast roots use an explicit reduced parameter law and complete C2 fixture.",
+    "sha256": "7d9c80ba345d63406931bce0c6964f367296ef4d90ca689102f19f06be490ef5",
+    "source_inputs": 4,
+    "status": "PASS_ENCODED_MINIMUM_ROOT_PREFIX_ROOTS"
+  },
+  "optimized_git_free": {
+    "readonly_files_unchanged": 15,
+    "optimized_git_free": true,
+    "empty_path": true,
+    "source_corruption_rejected": true,
+    "python": "Python 3.12.14"
+  },
+  "registered_python": "3.12.14",
+  "registered_phases": [
+    {
+      "cases": 1251,
+      "failure_controls": 6,
+      "fixed_pool_capacity": 32,
+      "non_power_divisor_cases": 771,
+      "peak_live_leases": 14,
+      "plan_fields": 29,
+      "production_divisor_bits": 2642,
+      "rows_below_stock_cases": 316,
+      "source_inputs": 4,
+      "status": "PASS_ENCODED_MINIMUM_ROOT_PREFIX_ARITHMETIC",
+      "tape_moves": 4087798,
+      "tape_reads": 4273750,
+      "tape_writes": 858487
+    },
+    {
+      "packets": 4,
+      "padding_failure_controls": 0,
+      "plan_pool_peaks": [
+        32
+      ],
+      "plans": [
+        {
+          "core_width": 0,
+          "depth": 0,
+          "families": 2,
+          "original_rows": 1,
+          "padded_rows": 1,
+          "q0": 0,
+          "reduced_law": false,
+          "stock": 1
+        },
+        {
+          "core_width": 0,
+          "depth": 0,
+          "families": 2,
+          "original_rows": 1,
+          "padded_rows": 1,
+          "q0": 0,
+          "reduced_law": false,
+          "stock": 1
+        },
+        {
+          "core_width": 0,
+          "depth": 0,
+          "families": 2,
+          "original_rows": 1,
+          "padded_rows": 1,
+          "q0": 0,
+          "reduced_law": false,
+          "stock": 1
+        },
+        {
+          "core_width": 0,
+          "depth": 0,
+          "families": 2,
+          "original_rows": 1,
+          "padded_rows": 1,
+          "q0": 0,
+          "reduced_law": false,
+          "stock": 1
+        }
+      ],
+      "recursive_events": {},
+      "scope": "Production root formulas with reduced guard; fast roots use an explicit reduced parameter law and complete C2 fixture.",
+      "sha256": "7f8bbe22031f01ae52b0d7699cff93171572909f492e26a8b9ac137a6dc16116",
+      "source_inputs": 4,
+      "status": "PASS_ENCODED_MINIMUM_ROOT_PREFIX_ROOTS-DIRECT"
+    },
+    {
+      "packets": 1,
+      "padding_failure_controls": 0,
+      "plan_pool_peaks": [
+        47
+      ],
+      "plans": [
+        {
+          "core_width": 3,
+          "depth": 1,
+          "families": 2,
+          "original_rows": 4,
+          "padded_rows": 4,
+          "q0": 2,
+          "reduced_law": true,
+          "stock": 2
+        }
+      ],
+      "recursive_events": {
+        "enter": 5,
+        "return": 5
+      },
+      "scope": "Production root formulas with reduced guard; fast roots use an explicit reduced parameter law and complete C2 fixture.",
+      "sha256": "0453fc3adc4496256eb0d6051edf406c2dae6a5be49ccd1cbd02214ccd6b2cc9",
+      "source_inputs": 4,
+      "status": "PASS_ENCODED_MINIMUM_ROOT_PREFIX_ROOTS-TWO"
+    },
+    {
+      "packets": 2,
+      "padding_failure_controls": 1,
+      "plan_pool_peaks": [
+        47
+      ],
+      "plans": [
+        {
+          "core_width": 3,
+          "depth": 1,
+          "families": 6,
+          "original_rows": 4,
+          "padded_rows": 6,
+          "q0": 2,
+          "reduced_law": true,
+          "stock": 6
+        },
+        {
+          "core_width": 3,
+          "depth": 1,
+          "families": 6,
+          "original_rows": 4,
+          "padded_rows": 6,
+          "q0": 2,
+          "reduced_law": true,
+          "stock": 6
+        }
+      ],
+      "recursive_events": {
+        "enter": 30,
+        "return": 30
+      },
+      "scope": "Production root formulas with reduced guard; fast roots use an explicit reduced parameter law and complete C2 fixture.",
+      "sha256": "49daec25f16a513b862a267ad8f208e33ef2e81f8d501589e19c5b23b9a2028a",
+      "source_inputs": 4,
+      "status": "PASS_ENCODED_MINIMUM_ROOT_PREFIX_ROOTS-SIX"
+    }
+  ]
+}
diff --git a/research/encoded-minimum-root-prefix/SOURCE-INDEX.json b/research/encoded-minimum-root-prefix/SOURCE-INDEX.json
new file mode 100644
index 0000000000..c899b4bda0
--- /dev/null
+++ b/research/encoded-minimum-root-prefix/SOURCE-INDEX.json
@@ -0,0 +1,446 @@
+[
+  {
+    "path": "certificates/selected-result.json",
+    "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81",
+    "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129",
+    "size": 10725
+  },
+  {
+    "path": "notes/compact-control-layout.tex",
+    "git_blob": "16f4d233471a7d189163ae7e7902becadecbba64",
+    "sha256": "2bc28e50f3eb092195294cafa81213e520f6d42e7935e9905ad8a6199e2a7c87",
+    "size": 6075
+  },
+  {
+    "path": "notes/compact-control-movement.tex",
+    "git_blob": "06b6a9ef24245ac7b724c53a204635415b402357",
+    "sha256": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6",
+    "size": 9009
+  },
+  {
+    "path": "research/bit2234-stock-threshold/README.md",
+    "git_blob": "ede0d322c477af91d4c2cc33db0fd10958f45eab",
+    "sha256": "1e050c9f963421d751d9208092f9a15321ed77810e03912df8eb5eb56bbb06e7",
+    "size": 9746
+  },
+  {
+    "path": "research/community-frontier1094-audit/selected-replay.tar.gz",
+    "git_blob": "c24daf067f9c543421d89ca2eeaa4eb78a57fb6f",
+    "sha256": "f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6",
+    "size": 6095634
+  },
+  {
+    "path": "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz",
+    "git_blob": "9eafb8776cbf78c72124f833534469ddfa5e98ec",
+    "sha256": "0357b7cfbd7c29b4983982baf153c8a9f1e1e412690cd7fa9fc3d23d7963b20f",
+    "size": 799504
+  },
+  {
+    "path": "research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json",
+    "git_blob": "44006542202ca6037533a754f0bcd00549d7e088",
+    "sha256": "0058c491d839142aa99ef86a5ec697ce99857632228531512ea3fa74fb24d734",
+    "size": 5827833
+  },
+  {
+    "path": "research/complex-grid-prefix-audit/PROOF.md",
+    "git_blob": "30f019e14866200660cbd2ad82f3bff707003210",
+    "sha256": "9c2473e080a64de5139abf66680534043143ec9f4488ceabf62403702047a3ad",
+    "size": 10225
+  },
+  {
+    "path": "research/e8-bit-p111-tuned/tune/EXPECTED.json",
+    "git_blob": "e293ddc557742637f9f679f083a1a282d87b1b13",
+    "sha256": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4",
+    "size": 5987
+  },
+  {
+    "path": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz",
+    "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a",
+    "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f",
+    "size": 42353
+  },
+  {
+    "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/engines/base_two_moment.py",
+    "git_blob": "14a90fa0e788217856f070382c9e61bd7c603c61",
+    "sha256": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098",
+    "size": 1742
+  },
+  {
+    "path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r740-replica32/code/engines/moment.py",
+    "git_blob": "7d697cb45203fe72d97037403d6da41f71f3b7fd",
+    "sha256": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482",
+    "size": 5562
+  },
+  {
+    "path": "research/gaussian-normalization-stream/PROOF.md",
+    "git_blob": "4becf18cde48ecf83d0fccf164590a957c64ce77",
+    "sha256": "733862ab7afe5074c4aac2d3db25c1bfb01a7935cc584013024f287bda085c64",
+    "size": 10121
+  },
+  {
+    "path": "research/gaussian-normalization-stream/SOURCES.json",
+    "git_blob": "58fce750dc2814f36ac096b407dd28293539bf8f",
+    "sha256": "c434302f4489366c1763f918ba59e2f57efc0a41d72310fd3c6bbe1553370275",
+    "size": 7035
+  },
+  {
+    "path": "research/gaussian-normalization-stream/normalizer.py",
+    "git_blob": "5d1a0961ace6b7edccb26c05780623c5509a7597",
+    "sha256": "2b0acaa831219faf3e7776969bdcffc3f0f9c608b15d6b4c343ff20cf6a50107",
+    "size": 6933
+  },
+  {
+    "path": "research/gaussian-parity-synthesis/REVIEW.md",
+    "git_blob": "0a6a4c7c1e8bef9c9aa9c7fb636e5ad6c0c411ae",
+    "sha256": "7d7b9ac63ccd2927f592e9edac1b4c11d58a6c74c5813d488e112f729090f60c",
+    "size": 5935
+  },
+  {
+    "path": "research/gaussian-parity/gaussian-parity-certificates.tex",
+    "git_blob": "e364cff719a12a5dfd52f2975cd07cc0318da511",
+    "sha256": "e21e1063141cbc798e73052e22d01eec57f1c173a580041e55aa196b1b0479f8",
+    "size": 21007
+  },
+  {
+    "path": "research/p104-whole-word-internal-grid/README.md",
+    "git_blob": "4075bb303592ccc53cd7d29399f15ff01c89da5d",
+    "sha256": "d98c0b0a4835d766852e960299dd87112375990ed645d2c9e84edb08b79500e4",
+    "size": 11685
+  },
+  {
+    "path": "research/physical-complex-compact/PROOF.md",
+    "git_blob": "f65f38123ca0adb02f6ca69351cbfc933506e5cb",
+    "sha256": "ec6395822ae500242f3fe5e2cf40caf9a7f9fa259d475d2c14970d951ff4df48",
+    "size": 18626
+  },
+  {
+    "path": "research/physical-complex-controller/EVIDENCE.md",
+    "git_blob": "e71b5fbc4d867572695e52a1b10aa8aa074b837d",
+    "sha256": "24b50eaa5dc28570d7118703cd3547c8232e56231f3fc5ca05e19ab116678370",
+    "size": 3121
+  },
+  {
+    "path": "research/physical-complex-controller/PROOF.md",
+    "git_blob": "c505caecc7ced19a4efc35c423efedda9427bea5",
+    "sha256": "471185621c0ecce295ffd327b1244aed234efe5ff05a804aaaa11316f1a8319e",
+    "size": 15528
+  },
+  {
+    "path": "research/physical-complex-controller/README.md",
+    "git_blob": "4ac8b4effb1381aa06aadd1716f53a4c4849a306",
+    "sha256": "1ecf61d038679d5358682ea979083a7b28f378f7b002085e7f2efb1f5a4c229a",
+    "size": 6393
+  },
+  {
+    "path": "research/physical-complex-controller/SOURCES.json",
+    "git_blob": "a56a247ecb28c77fcb055fac031be471b291777d",
+    "sha256": "c9c47d9df2445fc554673316d42f68f0a1b800ea3593ac568835c9b063025eb4",
+    "size": 9766
+  },
+  {
+    "path": "research/physical-complex-controller/TASK.json",
+    "git_blob": "e53fdf548ea61cd6fed640b3ea927accfe0b2ffc",
+    "sha256": "f09fe7031571b6e75be752dfe15c75a8d7831d680b9fb13ddfc59baeaa4f099d",
+    "size": 7047
+  },
+  {
+    "path": "research/physical-complex-controller/VERIFY.json",
+    "git_blob": "7f224fc308f7810b1dc0605c3808a8bc4eee69be",
+    "sha256": "f7c2ed28478c41e445a15ecd6f94be1c1e980145bfd721687b000068bd6dbd61",
+    "size": 3039
+  },
+  {
+    "path": "research/physical-complex-controller/bank_packets.py",
+    "git_blob": "defda707199e8eba83ee483daf5ae7acb642c43c",
+    "sha256": "83e2f80fb72c906ccc7857f2b5139758ca8a997b17f51a5db29e2bb3c1143477",
+    "size": 7911
+  },
+  {
+    "path": "research/physical-complex-controller/check_bank.py",
+    "git_blob": "330eb42a6e9a1c2d98bd00265a05639607fd9dad",
+    "sha256": "6a5cd81ad980565c06f9e0df8c81eb6946dc69caf3704ee5b233ebdef6fb83c5",
+    "size": 3424
+  },
+  {
+    "path": "research/physical-complex-controller/check_bounds.py",
+    "git_blob": "c83df54069979344cd183c16c9c8f79bb0fe8230",
+    "sha256": "697606202fbef8463f6ee736007b9630c55034246dcda17c23b03e97d270dcc7",
+    "size": 4072
+  },
+  {
+    "path": "research/physical-complex-controller/check_cover.py",
+    "git_blob": "18c7bd933c7885dfdf9b87f0e67c91ad2b924c72",
+    "sha256": "d50271a051d9d944dd7a5541756b508c8b19248d8d37bd30e729aaf7210435fd",
+    "size": 2456
+  },
+  {
+    "path": "research/physical-complex-controller/check_failures.py",
+    "git_blob": "5af8131d29e82a7a077071a8344c4425a3f4fe43",
+    "sha256": "785e9ff582aad9a6cee7cf339134309a863c8d4fa79367c31b2cc03b31282a5f",
+    "size": 2936
+  },
+  {
+    "path": "research/physical-complex-controller/check_grid.py",
+    "git_blob": "9c4109d1006dbf7385c97d5103c3fe9cf67bb0bd",
+    "sha256": "a08092d0bbcbb69459d936e2f6f7f431134cba9c31ffdc173c82878d00ea98e3",
+    "size": 3586
+  },
+  {
+    "path": "research/physical-complex-controller/check_machine.py",
+    "git_blob": "66456cf6458ce15fe4557a310cf8f31f94f67c65",
+    "sha256": "57deb4aac01d98bc5af7bdfbaf6624367fa5f84595b2b5902acada824db53eab",
+    "size": 4648
+  },
+  {
+    "path": "research/physical-complex-controller/check_monomial.py",
+    "git_blob": "0369562c62d0c79c41a7ebed7a0e7b894908f4b1",
+    "sha256": "a301d39afb7475615716e2426c3df8fe0f6e8fa710c13f70ecb2a9026f52cd6d",
+    "size": 5049
+  },
+  {
+    "path": "research/physical-complex-controller/check_parking.py",
+    "git_blob": "80d512368bd6631e55ba7567bf3d2bd4349fbbf2",
+    "sha256": "7c84fa78dae732895ea016fcf3d1892f2519655dc5634b7e43a81b4ba7e187d8",
+    "size": 2677
+  },
+  {
+    "path": "research/physical-complex-controller/check_prime.py",
+    "git_blob": "a19b07762d064b8fc0cd1d81cfabd2d22a4c9096",
+    "sha256": "791a0233fa704eafa634b6968c68f81a83b95170b30c527ba93599b8b8e76643",
+    "size": 7922
+  },
+  {
+    "path": "research/physical-complex-controller/check_root.py",
+    "git_blob": "355439791107c6e3f21bdedaa051d4871a922324",
+    "sha256": "7f7be44511d67aa4920cf7de4a88b3b78aab39cc210d20c06a456ee807f53614",
+    "size": 6192
+  },
+  {
+    "path": "research/physical-complex-controller/check_root_plan.py",
+    "git_blob": "c2bbb4f6b1bf80a841c94cad3c135a3ffff5e4e8",
+    "sha256": "9f900532e6d564efd6af462f536f19301cb7674ab1b0670c0fc717ab63403da9",
+    "size": 3759
+  },
+  {
+    "path": "research/physical-complex-controller/check_root_streams.py",
+    "git_blob": "f2416f9a83967548268821c3b006a76e1871bf63",
+    "sha256": "46711e474f8cd4b20c99c8a790c416f055da64e293e2cf9a33db9e60294cc0ed",
+    "size": 3578
+  },
+  {
+    "path": "research/physical-complex-controller/check_scalar.py",
+    "git_blob": "8c24a7a5050d0c5987ed88f21495b2476a0c1978",
+    "sha256": "23b3077ed0bb15c3f5f402d841fbf36845a00a63bbbc845f776c221050c943a4",
+    "size": 3400
+  },
+  {
+    "path": "research/physical-complex-controller/check_selected.py",
+    "git_blob": "b79301403dc452990aec7ee2cc74b64ff58019f8",
+    "sha256": "3572fa98bbb0312e66fd15a7e0ed494db5c4f7b32087a8c87aeee2528b83daea",
+    "size": 4863
+  },
+  {
+    "path": "research/physical-complex-controller/cohort.py",
+    "git_blob": "3876ab737f3c2a90100749e4ba141f1923caff79",
+    "sha256": "8fb650c0cc3dfaad94811149b0c0e725777a8cff195c5f21e21a7576494e84f1",
+    "size": 5952
+  },
+  {
+    "path": "research/physical-complex-controller/cover.py",
+    "git_blob": "2b9b9df832a747bcb02505d5495f79d38deffa43",
+    "sha256": "d797daec10275f439f6019c596b89afbc32a7716cb657648adfcaae2408949da",
+    "size": 4996
+  },
+  {
+    "path": "research/physical-complex-controller/fixture_binding.py",
+    "git_blob": "447ddc84d7dd9905c767c91acc7467a495093475",
+    "sha256": "efcb94cf050412ccd2d5eea592d77f294f6124f6feebc86580b16a73e5c2c202",
+    "size": 1847
+  },
+  {
+    "path": "research/physical-complex-controller/grid_boundary.py",
+    "git_blob": "387576fc2f0701709237430febed7ea5b730828b",
+    "sha256": "55f32b8cfaa3482d5d62127ac90c2370fc0dc8122263815e1564ee95093ffccc",
+    "size": 7076
+  },
+  {
+    "path": "research/physical-complex-controller/machine.py",
+    "git_blob": "92f9467ffd3346d672a0e2c56f2508e33ed21689",
+    "sha256": "b648792a361fdf98597a2f56c634767508be8e818b82e482fbfc60b5c63cc855",
+    "size": 21396
+  },
+  {
+    "path": "research/physical-complex-controller/monomial_packets.py",
+    "git_blob": "5b4eaf49b3847cafa7bd99e7147c8818b248a021",
+    "sha256": "6856e80c13ebf3b6e9e0e142ed65420579b5a1b4892f23859d3c6e5f17a334b4",
+    "size": 3514
+  },
+  {
+    "path": "research/physical-complex-controller/native_program.py",
+    "git_blob": "7d1c54c7d1394de28585d48b1a703d4b00069e98",
+    "sha256": "177d87445659d7ddbef11370d0b4cdc0596732147ed26c1fa11bad16ae53c93b",
+    "size": 6613
+  },
+  {
+    "path": "research/physical-complex-controller/parking.py",
+    "git_blob": "34bc6a0bd0daade7ccc69d0c236984f024d22ef4",
+    "sha256": "33e6d2a6fcdc648de31b374132bf885259eec9748bafa6facca3822a78427e94",
+    "size": 5314
+  },
+  {
+    "path": "research/physical-complex-controller/production_native.py",
+    "git_blob": "045b0dd1aa6ec47051730fc01fa8b3c6a825ab72",
+    "sha256": "4c1f8f69212162bd297010c6e21a32e31755cbfe2e40f9935b8d87a9e4260d46",
+    "size": 1222
+  },
+  {
+    "path": "research/physical-complex-controller/root_layer.py",
+    "git_blob": "389efd17af0f8d68711f0e7c6d8b6be65421e846",
+    "sha256": "247b82feefecedc12142379fd7c9c6cdd5ac7e5309e443c4b4fa703d6b995c21",
+    "size": 7214
+  },
+  {
+    "path": "research/physical-complex-controller/root_plan.py",
+    "git_blob": "78390164c3551bfcce8da6b0f23197a4048a7e5e",
+    "sha256": "494cad3edc376928684f380cd16568076b286a53bd763d910d49efa5b03f07c9",
+    "size": 8963
+  },
+  {
+    "path": "research/physical-complex-controller/root_streams.py",
+    "git_blob": "213144a6c905ac5dfbec9aaadc43f14eb4b1044d",
+    "sha256": "b67daf3de591b6788220a016b0394cfe2cc8e94ffd41426bb2544ad578b715c8",
+    "size": 5893
+  },
+  {
+    "path": "research/physical-complex-controller/scalar_packets.py",
+    "git_blob": "66ea778399423005695bdea1e43ef9dcde903402",
+    "sha256": "cc48f726325c000ab2304eb691feb950ff4abeab5c537d6165d5b3322dc45c35",
+    "size": 1062
+  },
+  {
+    "path": "research/physical-complex-controller/scalar_program.py",
+    "git_blob": "30ba678c7b828285d549e923b34e315e439b8452",
+    "sha256": "4c005167b4c2fe0d98d2dd93b7f931b251259417ff4392b67ee0fbe290f6d48a",
+    "size": 5412
+  },
+  {
+    "path": "research/physical-complex-controller/selected_binding.py",
+    "git_blob": "5fe097ff688f5304a45945054e9d4a4af05f13d8",
+    "sha256": "d6583458d00e4933c3a3fd83cc376f21c059e9fc6aa338c00d66c1deeaa0e985",
+    "size": 11214
+  },
+  {
+    "path": "research/physical-complex-controller/selected_source.py",
+    "git_blob": "6bdc133472e85d2230d59c91813390b3547caf8d",
+    "sha256": "02601c9e7d88e58e62d63509ff709c6498a40fbbc0f95fab328379ae6acaa87a",
+    "size": 2698
+  },
+  {
+    "path": "research/physical-complex-controller/verify.py",
+    "git_blob": "8c475ffaf8f2961bec5bfcfef5c3139451413998",
+    "sha256": "529f7a1e90b279f03ba4c8c5b0aeb98cd6935a50b95eb3475e9eada5cb5670cb",
+    "size": 1544
+  },
+  {
+    "path": "research/physical-gaussian-leaf/PROOF.md",
+    "git_blob": "e98db470cdb8bfc49e9da86c39c0d6ae16e92716",
+    "sha256": "29ebd43146f921077f980a408915ecc3a5199a07fcdadc624a8282c06b0b8104",
+    "size": 12417
+  },
+  {
+    "path": "research/physical-gaussian-leaf/SOURCES.json",
+    "git_blob": "2ae5d4a9bd2b62bf21fee81106fa9e38bbd84bd0",
+    "sha256": "c693fc79212652d7427560189ad8eb5e841fe71325e6d7a0d61e05f97438a5e1",
+    "size": 7341
+  },
+  {
+    "path": "research/physical-gaussian-leaf/axis_stream.py",
+    "git_blob": "ba8230443fdb0370b72a7a617ba7d88eb23a9c37",
+    "sha256": "40dea1c6fa41effd8e7a61f39a3a599e897370ca118e332ee5301a905dbb2998",
+    "size": 2574
+  },
+  {
+    "path": "research/physical-gaussian-leaf/coefficient_engine.py",
+    "git_blob": "dff2f099b60c23310a10665cd81e443282b249e8",
+    "sha256": "fff28cbc27b95ed546ac65f70279fa41a933421f1cd32b988ae8910632f0efcf",
+    "size": 6770
+  },
+  {
+    "path": "research/physical-gaussian-leaf/inputs/pr3087.tar",
+    "git_blob": "6daedf70a927fa1359caec68d56fc0cbdaeb54dd",
+    "sha256": "d7e9c04a5e6d3f76158555d84080786c7cd8028ca31a61c9399de2b2c67bfd53",
+    "size": 1710080
+  },
+  {
+    "path": "research/physical-gaussian-leaf/leaf_sources.py",
+    "git_blob": "31c33dbed6061ca7c0455a9170fd05fb388f4607",
+    "sha256": "e0f958a0169257ba08eac5e025a3fc7ce99009efc18974cdd231f16758004014",
+    "size": 1761
+  },
+  {
+    "path": "research/physical-gaussian-leaf/signed_linear.py",
+    "git_blob": "d17018a976ea4af15b6b5828a091d799435bacfc",
+    "sha256": "5b86afc33042e1c43eaa6957f94e0ebf403d1b07bb26d30ba89aa14d71f76078",
+    "size": 3624
+  },
+  {
+    "path": "research/physical-scalar-stream/scalar_engine.py",
+    "git_blob": "aea19253f6a772047f22d2f0e1927b9bf319aba9",
+    "sha256": "be74c74862ff2b152d3752cb887c6682ddf2d889bc9f16f6328e418618e4c8b6",
+    "size": 5065
+  },
+  {
+    "path": "research/physical-scalar-stream/scalar_words.py",
+    "git_blob": "36919dc569678656a1696f23454cba2d1fb0f393",
+    "sha256": "f4293c5ea5a7b65be920997f2ff33ce046ae3d9707ecbcecb3bd163d821dfd00",
+    "size": 3968
+  },
+  {
+    "path": "research/pr589-five-helper-hosting/PROOF.md",
+    "git_blob": "bbd3f12b9a32b3ad3cba85a2d5a1b3054214fa02",
+    "sha256": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647",
+    "size": 12438
+  },
+  {
+    "path": "research/pr589-five-helper-hosting/verify.py",
+    "git_blob": "dbc71f56bb4205ebe378ada1f9f4ea88630d1d39",
+    "sha256": "cf90e19ae9991b0698be03d395a8cc29061ecb307eb7fea19adfb2d23c25a367",
+    "size": 21449
+  },
+  {
+    "path": "research/recursive-parking-boundary/README.md",
+    "git_blob": "251f335ebaccc11d69393ee7aeb5a2e84526d0bb",
+    "sha256": "491aa208391ee4c2936510b1a5c5c018dd5509d9a0e88687c72ab8406cd77b18",
+    "size": 15680
+  },
+  {
+    "path": "research/selected-bit-local-ring-sweeps/PROOF.md",
+    "git_blob": "4330de85dd9862ed15d84ab917887d249753df99",
+    "sha256": "846c59440cc99e28bae93ad2af99525bc769de29368080071b8427141215b4f7",
+    "size": 16491
+  },
+  {
+    "path": "research/selected-bit-recursive-closure/PROOF.md",
+    "git_blob": "6c410cab5713979214a45835091fbeb9ee9b8531",
+    "sha256": "74cc8de20f21acb5123fe2d20996fe0925ea6e51b3dec633bd5221fb719b3344",
+    "size": 23425
+  },
+  {
+    "path": "research/selected-complex-layer-closure/PROOF.md",
+    "git_blob": "d7ec0d101405a5f099f55f6a73e9791731737fd0",
+    "sha256": "43feda0342c07a9429699c3a44e8936a3f3fb57ce9b32f38ff3dc06ac887b265",
+    "size": 23627
+  },
+  {
+    "path": "research/selected-complex-layer-closure/arithmetic.py",
+    "git_blob": "009d7b7166718832ebbf11893cb1ef258184a4f9",
+    "sha256": "31e4b21bb64924d723d1248a7eccf4e9c80d323ba8784804af79a75da18c346a",
+    "size": 6217
+  },
+  {
+    "path": "upstream/build/sections/02-streams.tex",
+    "git_blob": "088fceea1867abc76271d7efe7532b779fee9039",
+    "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab",
+    "size": 11311
+  }
+]
diff --git a/research/encoded-minimum-root-prefix/SOURCES.json b/research/encoded-minimum-root-prefix/SOURCES.json
new file mode 100644
index 0000000000..edcab2a10c
--- /dev/null
+++ b/research/encoded-minimum-root-prefix/SOURCES.json
@@ -0,0 +1,46 @@
+{
+  "schema_version": 1,
+  "base_commit": "df0137efd35e11b4445734bf612bdd4c7ebc330c",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8",
+      "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602",
+      "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72"
+    },
+    {
+      "path": "research/encoded-minimum-root-prefix/source-snapshot.tar",
+      "usage": "input",
+      "git_blob": "991cfca61a091e10168b1647e1ae55c644cdcd85",
+      "sha256": "3e901efd15eafce0d9b1f11d452a294229e08b0cc06ddb6fc0bef8157dc3c08f",
+      "pin": "head:244e717163e902558b3e7ce5e767b38fc4413db6:research/encoded-minimum-root-prefix/source-snapshot.tar"
+    },
+    {
+      "path": "research/encoded-minimum-root-prefix/SOURCE-INDEX.json",
+      "usage": "input",
+      "git_blob": "c899b4bda006b247a909751f8e9c51190c111032",
+      "sha256": "a82d9be25cc5457a0dea248d51558da5b5b68fbde0c342238bc500fab50da4ef",
+      "pin": "head:244e717163e902558b3e7ce5e767b38fc4413db6:research/encoded-minimum-root-prefix/SOURCE-INDEX.json"
+    },
+    {
+      "path": "research/encoded-minimum-root-prefix/reference.py",
+      "usage": "input",
+      "git_blob": "5d3bd76fb77f9bed5a15f6d51ee1cb79a36f8683",
+      "sha256": "6ea4f1622c1c8de490bcf66e58937a2098af67c9a154cfbe7a7d3416887a032a",
+      "pin": "head:244e717163e902558b3e7ce5e767b38fc4413db6:research/encoded-minimum-root-prefix/reference.py"
+    },
+    {
+      "path": "research/encoded-minimum-root-prefix/PREFIX-PROOF.md",
+      "usage": "input",
+      "git_blob": "fbb40eab4928307212cd4daa0b5cfee770252014",
+      "sha256": "29a346f4d23f04d1898ceb796b90ea2fc07f52b1a6fb58f21df8c086b2f2876d",
+      "pin": "head:244e717163e902558b3e7ce5e767b38fc4413db6:research/encoded-minimum-root-prefix/PREFIX-PROOF.md"
+    }
+  ]
+}
diff --git a/research/encoded-minimum-root-prefix/TASK.json b/research/encoded-minimum-root-prefix/TASK.json
new file mode 100644
index 0000000000..1efb3cbf1d
--- /dev/null
+++ b/research/encoded-minimum-root-prefix/TASK.json
@@ -0,0 +1,91 @@
+{
+  "schema_version": 1,
+  "task_id": "uniform-transfer-audit",
+  "priority_revision": 7,
+  "base_commit": "df0137efd35e11b4445734bf612bdd4c7ebc330c",
+  "original_card": {
+    "id": "uniform-transfer-audit",
+    "question": "Does one quantified step of the proposed #4100 all-size construction hold at its actual caller?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "research/unconditional-batched-crt/README.md"
+    ],
+    "methods": [
+      "Prove one missing implication with explicit quantified hypotheses.",
+      "Find an exact counterexample at the claimed interface boundary."
+    ],
+    "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read PROOF.md and AUDIT.md in #4100. Select one distinct obligation: CRT total repair, native/free-algebra lifting, precision/conditioning, or complete fixed-tape cost. This is an author-submitted proof, not an accepted unconditional theorem.",
+      "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately."
+    },
+    "first_experiment": "Check live handoffs; name one proposition, its caller, quantified domain and dependency closure. Independently prove the implication or exhibit a precise gap/counterexample. Prioritize CRT.md total repair or COMPLEX.md free-algebra lift only if unclaimed. Stop at the chosen obligation; do not substitute finite samples or root arithmetic for an all-size proof, or launch the complete package by default.",
+    "bottleneck_link": "Finite supplier improvements are useful only under the retained transfer obligations.",
+    "allowed_variations": [
+      "One CRT repair, native lift, precision/conditioning or tape-cost proposition, with its exact caller."
+    ],
+    "scope_change_triggers": [
+      "Replacing a quantified obligation with another finite smoke test.",
+      "Treating archive intake, an author PASS receipt or a finite composed fixture as discharge of the universal hypotheses."
+    ],
+    "overlap_terms": [
+      "uniform transfer",
+      "all-size",
+      "precision",
+      "4100",
+      "unconditional-batched-crt"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.",
+        "evidence": "research/unconditional-batched-crt/README.md",
+        "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.",
+        "status": "author-checked",
+        "source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      }
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Implement the released PR5688 minimum root prefix on the retained physical Count interface, preserve every RootPlan field, and execute complete dirty reduced RootLayer callers with actual non-power row padding.",
+  "scope_change_reason": "The selected audit card is narrowed to a distinct caller obligation in Discussion4744. PR5688 proved the numerical minimum but explicitly left actual encoded integration open. This contribution supplies that interface, not another numeric search.",
+  "bottleneck_link": "A cheaper admissible root reservation is usable only when the complete encoded planner and its caller preserve address, padding, cost and cleanup contracts. This implementation removes that concrete integration gap; no complete kappa improvement is claimed.",
+  "budget_minutes": 120,
+  "stop_rule": "Require exact minimum against integer padding oracles, fixed scratch ownership, complete reduced physical endpoints including non-power padding, failure cleanup and sealed source replay. Do not substitute reduced fixtures for production O73/GL64 execution or a full caller bill.",
+  "outcome": "completed",
+  "evidence": "See EVIDENCE.md and the registered arithmetic and complete-root receipts. All tests and omissions are stated there.",
+  "author": "Ali Romman with substantial OpenAI Codex assistance",
+  "ai_assistance": "Substantial OpenAI Codex assistance in mathematics, code, verification and prose. No subagents. Same assistant family as PR5688; no independent human or formal review.",
+  "open_questions": [
+    {
+      "question": "Can the changed root geometry improve an actual complete QQ16 or signed invoice?",
+      "why_it_matters": "Fewer reserved axes do not by themselves improve complete kappa.",
+      "first_step": "Recompute the changed core depth and all reserved-leaf, native, padding and descriptor terms at the same input.",
+      "blocked_by": "No complete changed-geometry caller bill is supplied here."
+    },
+    {
+      "question": "Can an independent reviewer certify the all-size physical refinement at this plan boundary?",
+      "why_it_matters": "Reduced complete executions do not validate the full production controller.",
+      "first_step": "Check the written Count invariants and root field identities against the pinned source and retained native contracts.",
+      "blocked_by": "Independent review and the source production refinement obligations."
+    }
+  ],
+  "discussion": "https://github.com/CrocSwap/integer-mult-bounds/discussions/4744#discussioncomment-19189972",
+  "expansion_decision": {
+    "decision": "Close the explicit encoded interface and full reduced consumer, rather than repeat the predecessor numeric minimum.",
+    "proved_costs": "Physical Count work and fixed scratch ownership are charged. Root payload and native costs remain paid.",
+    "unknowns": "Production O73/GL64 execution, full physical refinement and a recomputed complete QQ16 or signed invoice remain open."
+  },
+  "freshness": {
+    "canonical_main": "df0137efd35e11b4445734bf612bdd4c7ebc330c",
+    "overlap_checked_utc": "2026-10-26T07:30:10Z",
+    "coverage": "All 7676 main notes, 389 open PRs and 5030 Discussion records. Separate literal terms and an independent cached-body scan found only released predecessor RootPlan scopes and this active claim. Main was fetched again before publication."
+  }
+}
diff --git a/research/encoded-minimum-root-prefix/VERIFY.json b/research/encoded-minimum-root-prefix/VERIFY.json
new file mode 100644
index 0000000000..5213de9042
--- /dev/null
+++ b/research/encoded-minimum-root-prefix/VERIFY.json
@@ -0,0 +1,58 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/encoded-minimum-root-prefix/source-snapshot.tar",
+    "research/encoded-minimum-root-prefix/SOURCE-INDEX.json",
+    "research/encoded-minimum-root-prefix/reference.py",
+    "research/encoded-minimum-root-prefix/PREFIX-PROOF.md"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py",
+        "--phase",
+        "arithmetic"
+      ],
+      "timeout_seconds": 60,
+      "checks": "1251 exact minima; physical Count work; fixed inventory; six invalid-domain controls; all 29 root fields."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py",
+        "--phase",
+        "roots-direct"
+      ],
+      "timeout_seconds": 400,
+      "checks": "Four complete dirty roots with the production parameter law and reduced guard."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py",
+        "--phase",
+        "roots-two"
+      ],
+      "timeout_seconds": 240,
+      "checks": "Complete dirty fast root with the reduced law and the two-family C2 fixture."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py",
+        "--phase",
+        "roots-six"
+      ],
+      "timeout_seconds": 500,
+      "checks": "Two complete dirty fast roots with actual stock-six padding; reuse, borrowed state, dirty-padding rejection and recovery."
+    }
+  ]
+}
diff --git a/research/encoded-minimum-root-prefix/planner.py b/research/encoded-minimum-root-prefix/planner.py
new file mode 100644
index 0000000000..7a94b98a8f
--- /dev/null
+++ b/research/encoded-minimum-root-prefix/planner.py
@@ -0,0 +1,221 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Minimum prefixes on the retained physical Count interface.
+
+RootPlan.compute is adapted from Jose Manuel's physical-complex-controller.
+New search and integration: Ali Romman with substantial OpenAI Codex assistance.
+"""
+import retained
+retained.activate()
+from cardinal_counts import Count, positive
+from compact_counts import power_two
+from encoded import atom_width, compare, subtract
+from machine import copy_symbols
+from root_plan import RootPlan, ceil_divide, ceil_log2, floor_power
+from session import sealed_constructors
+from words import RIGHT, need
+
+
+def floor_log2(value):
+    positive(value)
+    digits=Count.literal(0)
+    one=Count.literal(1)
+    value.rewind()
+    try:
+        while value.read()!=RIGHT:
+            need(value.read() in (0,1),'binary stock digit')
+            digits.increment()
+            value.step(1)
+        return subtract(digits,one)
+    finally:
+        value.rewind();digits.close();one.close()
+
+
+def reached_profile(width,threshold,dimension,maximum_rank,divisor):
+    current=Count(width)
+    depth=Count.literal(0)
+    stock=Count.literal(1)
+    try:
+        while compare(current,threshold)>=0:
+            current.divide_small(dimension)
+            if maximum_rank>1:current.multiply_small(maximum_rank)
+            depth.increment();stock.multiply_small(divisor)
+        return depth,stock
+    except BaseException:
+        depth.close();stock.close();raise
+    finally:
+        current.close()
+
+
+def minimum_prefix(remaining,spacing,threshold,dimension,maximum_rank,divisor):
+    """Return owned q, reached depth and exact stock. Borrow all input Counts."""
+    need(type(dimension) is int and type(maximum_rank) is int and type(divisor) is int
+         and 1<=maximum_rank<dimension<=73 and divisor>1,'fixed prefix constants')
+    positive(remaining);positive(spacing)
+    one=Count.literal(1);bound=None;depth=None;stock=None;upper=None;lower=None;last=None;mid=None
+    dimension_count=Count.literal(dimension)
+    try:
+        need(compare(threshold,dimension_count)>=0,'global cutoff at least dimension')
+        depth,stock=reached_profile(remaining,threshold,dimension,maximum_rank,divisor)
+        bound=Count(depth)
+        factor=(divisor-1).bit_length()
+        if factor>1:bound.multiply_small(factor)
+        upper=ceil_divide(bound,spacing)
+        depth.close();depth=None;stock.close();stock=None;bound.close();bound=None
+        last=subtract(remaining,one)
+        if compare(upper,last)>0:
+            upper.close();upper=Count(last)
+        lower=Count.literal(0)
+        while compare(lower,upper)<0:
+            mid=Count(lower);mid.add(upper);mid.divide_small(2)
+            core=d=s=bits=paid=None
+            try:
+                core=subtract(remaining,mid)
+                d,s=reached_profile(core,threshold,dimension,maximum_rank,divisor)
+                bits=floor_log2(s);paid=Count.product(spacing,mid)
+                accepted=compare(bits,paid)<=0
+            finally:
+                for value in (core,d,s,bits,paid):
+                    if value is not None:value.close()
+            if accepted:
+                upper.close();upper=mid;mid=None
+            else:
+                mid.increment();lower.close();lower=mid;mid=None
+        core=subtract(remaining,lower)
+        try:
+            depth,stock=reached_profile(core,threshold,dimension,maximum_rank,divisor)
+        finally:core.close()
+        answer=Count(lower)
+        result=(answer,depth,stock);depth=stock=None
+        return result
+    finally:
+        for value in (one,bound,depth,stock,upper,lower,last,mid,dimension_count):
+            if value is not None:value.close()
+
+
+class MinimumRootPlan(RootPlan):
+    def parameters(self,precision):
+        """Return owned d, K, G, H and delta for the source parameter law."""
+        owned=[];logarithm=None
+        try:
+            d=floor_power(precision,997,1000);owned.append(d)
+            K=floor_power(d,1,500);owned.append(K)
+            logarithm=ceil_log2(precision)
+            G=Count(logarithm);owned.append(G);G.multiply_small(4)
+            for _ in range(6):G.increment()
+            H=Count.product(d,G);owned.append(H)
+            delta=Count(d);owned.append(delta)
+            if self.guard_exponent:delta.multiply_small(1<<self.guard_exponent)
+            return tuple(owned)
+        except BaseException:
+            for value in reversed(owned):value.close()
+            raise
+        finally:
+            if logarithm is not None:logarithm.close()
+
+    def compute(self, precision, selected, left, right, coefficients, outer_rows, residue):
+        need(self.closed and not self.pool.live, "closed root planning entry")
+        self.clear()
+        self.closed = False
+        inputs = dict(precision=precision, selected=selected, left=left, right=right,
+                      coefficients=coefficients, outer_rows=outer_rows, residue=residue)
+        need(all(isinstance(v, Count) for v in inputs.values()), "encoded root inputs")
+        for name, value in inputs.items():
+            copy_symbols(value.tape, self.roles[name])
+        owned = []  # A fixed number of compiled expression results, independent of input widths.
+
+        def keep(value):
+            owned.append(value)
+            return value
+
+        def literal(value):
+            return keep(Count.literal(value))
+
+        def plus(*values, constant=0):
+            result = literal(constant)
+            for value in values:
+                result.add(value)
+            return result
+
+        def times(a, b):
+            return keep(Count.product(a, b))
+
+        def scaled(value, constant):
+            if constant == 0:
+                return literal(0)
+            result = keep(Count(value))
+            if constant > 1:
+                result.multiply_small(constant)
+            return result
+
+        def save(name, value):
+            copy_symbols(value.tape, self.roles[name])
+            return value
+
+        try:
+            with sealed_constructors(), self.scope.installed():
+                save("zero", literal(0))
+                two = literal(2)
+                need(compare(precision, two) >= 0, "root precision at least two")
+                positive(coefficients)
+                positive(outer_rows)
+                parameters = self.parameters(precision)
+                for value in parameters:
+                    keep(value)
+                d, K, G, H, delta = parameters
+                for name, value in zip(("d", "K", "G", "H", "delta"), parameters):
+                    save(name, value)
+                need(compare(selected, d) <= 0, "selected width within root domain")
+                need(compare(residue, K) < 0, "selected root residue")
+                qF = save("qF", keep(ceil_divide(scaled(H, 2), K)))
+                qB = save("qB", keep(ceil_divide(H, K)))
+                margins = plus(qF, qB)
+                if compare(selected, margins) > 0:
+                    remaining = keep(subtract(selected, margins))
+                    threshold = keep(atom_width(d, 1, 1000))
+                    dimension_count = literal(self.dimension)
+                    if compare(threshold, dimension_count) < 0:
+                        threshold = dimension_count
+                    prefix, exact_depth, exact_stock = minimum_prefix(
+                        remaining, K, threshold, self.dimension, self.maximum_rank, self.level_divisor)
+                    q0 = save("q0", keep(prefix))
+                    depth = save("depth", keep(exact_depth))
+                    stock = keep(exact_stock)
+                else:
+                    q0 = save("q0", literal(0))
+                    depth = save("depth", literal(0))
+                    stock = literal(1)
+                Q0 = save("Q0", plus(q0, qF, qB))
+                save("input_bits", plus(precision, constant=2))
+                work_bits = save("work_bits", plus(precision, scaled(delta, 2), constant=3))
+                active_bits = times(selected, K)
+                addresses = keep(power_two(plus(left, active_bits, right)))
+                save("gaussians", times(times(addresses, coefficients), outer_rows))
+                self.fast = compare(selected, Q0) > 0
+                if self.fast:
+                    save("core_width", keep(subtract(selected, Q0)))
+                    save("core_front", keep(subtract(times(qF, K), scaled(H, 2))))
+                    save("core_back", plus(keep(subtract(times(qB, K), H)), right))
+                    row_axes = times(q0, K)
+                    original_rows = save("original_rows", keep(power_two(row_axes)))
+                    prefix_count = save("prefixes", times(outer_rows, keep(power_two(left))))
+                    save("stock", stock)
+                    multiples = keep(ceil_divide(original_rows, stock))
+                    save("padded_rows", times(multiples, stock))
+                    rectangle = plus(keep(subtract(active_bits, row_axes)), right)
+                    row_gaussians = times(keep(power_two(rectangle)), coefficients)
+                    save("row_bits", scaled(times(row_gaussians, work_bits), 2))
+                else:
+                    for name in ("core_width", "core_front", "core_back", "row_bits"):
+                        save(name, literal(0))
+                    for name in ("prefixes", "original_rows", "padded_rows", "stock"):
+                        save(name, literal(1))
+        except BaseException:
+            for tape in self.roles.values():
+                tape.clear()
+            raise
+        finally:
+            for value in reversed(owned):
+                value.close()
+            self.pool.empty()
+            self.closed = True
+        return self
diff --git a/research/encoded-minimum-root-prefix/reference.py b/research/encoded-minimum-root-prefix/reference.py
new file mode 100644
index 0000000000..5d3bd76fb7
--- /dev/null
+++ b/research/encoded-minimum-root-prefix/reference.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""Exact reference compiler for the root row prefix.
+
+This uses host integers. It does not execute physical Count or payload code.
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+from functools import lru_cache
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def floor_root(n, degree):
+    need(type(n) is int and n >= 0 and type(degree) is int and degree > 0, 'root domain')
+    lo, hi = 0, 1 << ((n.bit_length()+degree-1)//degree)
+    while lo+1 < hi:
+        mid = (lo+hi)//2
+        if mid**degree <= n:
+            lo = mid
+        else:
+            hi = mid
+    return hi if hi**degree <= n else lo
+
+
+def depth(width, threshold, dimension=73, maximum_rank=48):
+    need(type(width) is int and width >= 0, 'nonnegative width')
+    need(type(threshold) is int and threshold >= dimension > maximum_rank > 0, 'depth domain')
+    result = 0
+    while width >= threshold:
+        width = maximum_rank*(width//dimension)
+        result += 1
+    return result
+
+
+class PrefixCompiler:
+    def __init__(self, divisor, threshold, dimension=73, maximum_rank=48):
+        need(type(divisor) is int and divisor > 1, 'positive nontrivial divisor')
+        need(threshold >= dimension > maximum_rank > 0, 'compiler domain')
+        self.divisor = divisor
+        self.threshold = threshold
+        self.dimension = dimension
+        self.maximum_rank = maximum_rank
+
+    def active_depth(self, width):
+        return depth(width, self.threshold, self.dimension, self.maximum_rank)
+
+    @lru_cache(maxsize=256)
+    def stock_bits(self, levels):
+        return (self.divisor**levels).bit_length()-1
+
+    def feasible(self, remaining, spacing, prefix):
+        need(0 <= prefix < remaining and spacing >= 1, 'positive core')
+        levels = self.active_depth(remaining-prefix)
+        return self.stock_bits(levels) <= spacing*prefix
+
+    def compile(self, remaining, spacing):
+        need(type(remaining) is int and remaining >= 1 and type(spacing) is int and spacing >= 1, 'prefix domain')
+        # This known feasible upper bound avoids a search through the root width.
+        conservative = self.active_depth(remaining)*(self.divisor-1).bit_length()
+        upper = min(remaining-1, (conservative+spacing-1)//spacing)
+        lower = -1
+        while upper-lower > 1:
+            middle = (lower+upper)//2
+            if self.feasible(remaining,spacing,middle):
+                upper = middle
+            else:
+                lower = middle
+        levels = self.active_depth(remaining-upper)
+        need(self.feasible(remaining,spacing,upper), 'feasible minimum')
+        need(upper == 0 or not self.feasible(remaining,spacing,upper-1), 'strict minimality')
+        return {'q0':upper, 'depth':levels, 'stock_floor_log2':self.stock_bits(levels),
+                'row_address_bits':spacing*upper,
+                'previous_stock_floor_log2':None if upper==0 else self.stock_bits(self.active_depth(remaining-upper+1))}
diff --git a/research/encoded-minimum-root-prefix/retained.py b/research/encoded-minimum-root-prefix/retained.py
new file mode 100644
index 0000000000..8149c0dbea
--- /dev/null
+++ b/research/encoded-minimum-root-prefix/retained.py
@@ -0,0 +1,49 @@
+"""Load the exact historical caller in its own source tree. Apache-2.0."""
+import hashlib
+import json
+from pathlib import Path, PurePosixPath
+import sys
+import tarfile
+import tempfile
+
+HERE=Path(__file__).resolve().parent
+_temporary=None
+_ready=None
+
+
+def activate():
+    global _temporary,_ready
+    if _ready is not None:
+        return _ready
+    manifest=json.loads((HERE/'SOURCES.json').read_text())
+    for name in ('source-snapshot.tar','SOURCE-INDEX.json'):
+        row=next(r for r in manifest['files'] if r['path'].endswith('/'+name))
+        if hashlib.sha256((HERE/name).read_bytes()).hexdigest()!=row['sha256']:
+            raise ValueError('source hash: '+name)
+    entries=json.loads((HERE/'SOURCE-INDEX.json').read_text())
+    expected={r['path']:r for r in entries}
+    if len(expected)!=len(entries):
+        raise ValueError('distinct retained source paths')
+    if 'cohort' in sys.modules:
+        raise ValueError('cold retained root namespace required')
+    _temporary=tempfile.TemporaryDirectory(prefix='encoded-root-source-')
+    root=Path(_temporary.name)
+    seen=set()
+    with tarfile.open(HERE/'source-snapshot.tar','r:') as archive:
+        for entry in archive:
+            path=PurePosixPath(entry.name)
+            if path.is_absolute() or '..' in path.parts or not entry.isfile() or entry.name in seen or entry.name not in expected:
+                raise ValueError('exact regular retained source member')
+            seen.add(entry.name)
+            raw=archive.extractfile(entry).read();row=expected[entry.name]
+            blob=hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()
+            if len(raw)!=row['size'] or hashlib.sha256(raw).hexdigest()!=row['sha256'] or blob!=row['git_blob']:
+                raise ValueError('retained source member hash')
+            dest=root/entry.name;dest.parent.mkdir(parents=True,exist_ok=True);dest.write_bytes(raw);dest.chmod(0o444)
+    if seen!=set(expected):
+        raise ValueError('complete retained source tree')
+    sys.path.insert(0,str(root/'research/physical-complex-controller'))
+    import cohort
+    cohort.activate()
+    _ready=(root,cohort)
+    return _ready
diff --git a/research/encoded-minimum-root-prefix/source-snapshot.tar b/research/encoded-minimum-root-prefix/source-snapshot.tar
new file mode 100644
index 0000000000..991cfca61a
Binary files /dev/null and b/research/encoded-minimum-root-prefix/source-snapshot.tar differ
diff --git a/research/encoded-minimum-root-prefix/verify.py b/research/encoded-minimum-root-prefix/verify.py
new file mode 100644
index 0000000000..e2859d1ed5
--- /dev/null
+++ b/research/encoded-minimum-root-prefix/verify.py
@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+"""Check encoded prefix arithmetic and its complete reduced root caller."""
+import argparse
+import ast
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+import sys
+from types import SimpleNamespace
+
+HERE=Path(__file__).resolve().parent
+sys.path.insert(0,str(HERE))
+
+
+def need(ok,message):
+    if not ok:raise ValueError(message)
+
+
+def authenticate():
+    manifest=json.loads((HERE/'SOURCES.json').read_text())
+    for row in manifest['files']:
+        if row['usage']!='input':continue
+        path=HERE/Path(row['path']).name
+        raw=path.read_bytes()
+        need(hashlib.sha256(raw).hexdigest()==row['sha256'],'source hash: '+path.name)
+        need(hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()==row['git_blob'],'source blob: '+path.name)
+    return sum(row['usage']=='input' for row in manifest['files'])
+
+
+def integer(count):
+    # The verifier alone decodes tapes. This read does not change a tape meter.
+    from words import RIGHT
+    physical=getattr(count.tape,'physical',count.tape)
+    digits=list(physical.cells[1:])
+    need(RIGHT in digits,'terminated Count')
+    digits=digits[:digits.index(RIGHT)]
+    need(digits and all(x in (0,1) for x in digits),'binary Count')
+    return sum(bit<<i for i,bit in enumerate(digits))
+
+
+def tape_snapshot(counts):
+    return tuple((bytes(getattr(c.tape,'physical',c.tape).cells),c.tape.head) for c in counts)
+
+
+def meter(tapes):
+    unique={id(getattr(t,'physical',t)):getattr(t,'physical',t) for t in tapes}
+    return tuple(sum(getattr(t.meter,name) for t in unique.values()) for name in ('reads','writes','moves'))
+
+
+def oracle(M,K,T,m,r,F):
+    def profile(width):
+        depth=0
+        while width>=T:
+            width=r*(width//m);depth+=1
+        return depth,F**depth
+    for q in range(M):
+        depth,stock=profile(M-q);rows=1<<(K*q)
+        padded=((rows+stock-1)//stock)*stock
+        if padded<2*rows:return q,depth,stock
+    raise ValueError('no oracle prefix')
+
+
+def syntax_checks(planner,root):
+    tree=ast.parse((HERE/'planner.py').read_text())
+    for node in ast.walk(tree):
+        if isinstance(node,ast.Attribute):
+            need(node.attr not in ('cells','head','meter','bit_count','__dict__'),'no decoded runtime tape access')
+        if isinstance(node,ast.Call) and isinstance(node.func,ast.Name):
+            need(node.func.id not in ('int','float','eval','exec','getattr','setattr','__import__'),'no host decoder or runtime patch')
+    source=(root/'research/physical-complex-controller/root_layer.py').read_text()
+    need('plan=None' in source and 'self.plan = plan if plan is not None else RootPlan(' in source,'existing root plan interface')
+    from root_plan import RootPlan,FIELDS
+    need(planner.MinimumRootPlan.count is RootPlan.count and planner.MinimumRootPlan.clear is RootPlan.clear,'source field access and cleanup retained')
+    need(set(FIELDS)==set(planner.MinimumRootPlan(2,1,2,guard_exponent=2).roles),'all source plan fields retained')
+    return len(FIELDS)
+
+
+def arithmetic(planner,root):
+    from cardinal_counts import Count
+    from scratch_pool import ScratchPool
+    from session import OuterScope,sealed_constructors
+    spec=importlib.util.spec_from_file_location('minimum_prefix_reference',HERE/'reference.py')
+    reference=importlib.util.module_from_spec(spec);spec.loader.exec_module(reference)
+    pool=ScratchPool(32);scope=OuterScope(pool)
+    totals=[0,0,0];cases=nonpower=between=0
+    domain=[]
+    for m,r,thresholds,divisors in ((2,1,(2,3,6),(2,3,6)),(3,2,(3,5),(2,5))):
+        for T in thresholds:
+            for F in divisors:
+                for M in range(1,33):
+                    for K in (1,2,4):domain.append((M,K,T,m,r,F))
+    production_divisor=14336*(1<<1296)
+    for j in range(1,37):production_divisor*=((1<<(2*j))-1)
+    domain.extend((M,K,73,73,48,production_divisor) for M,K in ((72,1),(74,4096),(147,4096)))
+    for M,K,T,m,r,F in domain:
+        counts=tuple(Count.literal(x) for x in (M,K,T))
+        before=tape_snapshot(counts);tapes=(*pool.tapes,*(c.tape for c in counts));start=meter(tapes)
+        with sealed_constructors(),scope.installed():
+            result=planner.minimum_prefix(*counts,m,r,F)
+            got=tuple(integer(c) for c in result)
+            need(got==oracle(M,K,T,m,r,F),'least strict-padding prefix')
+            prior=reference.PrefixCompiler(F,T,m,r).compile(M,K)
+            need(got[0]==prior['q0'] and got[1]==prior['depth'],'retained reference contract')
+            q,d,S=got;R=1<<(K*q)
+            need(((R+S-1)//S)*S<2*R,'strict padding at returned prefix')
+            need(tape_snapshot(counts)==before,'borrowed Count bytes and heads')
+            for c in result:c.close()
+        pool.empty()
+        stop=meter(tapes)
+        for i in range(3):totals[i]+=stop[i]-start[i]
+        for c in counts:c.close()
+        cases+=1;nonpower+=int(F&(F-1)!=0);between+=int(R<S<2*R)
+    controls=0
+    for M,K,T,m,r,F in ((0,1,2,2,1,6),(3,0,2,2,1,6),(3,1,1,2,1,6),
+                        (3,1,2,2,2,6),(3,1,2,2,1,1),(3,1,2,True,1,6)):
+        counts=tuple(Count.literal(x) for x in (M,K,T));before=tape_snapshot(counts)
+        with sealed_constructors(),scope.installed():
+            try:planner.minimum_prefix(*counts,m,r,F)
+            except ValueError:controls+=1
+            else:raise ValueError('invalid planner input accepted')
+        need(tape_snapshot(counts)==before,'failed search preserves borrowed Counts');pool.empty()
+        for c in counts:c.close()
+    need(controls==6 and all(x>0 for x in totals),'controls and positive physical planner work')
+    return dict(cases=cases,non_power_divisor_cases=nonpower,rows_below_stock_cases=between,
+                failure_controls=controls,fixed_pool_capacity=32,peak_live_leases=pool.peak,
+                tape_reads=totals[0],tape_writes=totals[1],tape_moves=totals[2],
+                production_divisor_bits=production_divisor.bit_length(),plan_fields=syntax_checks(planner,root))
+
+
+def encode(values,width):
+    return bytes((v>>bit)&1 for pair in values for v in pair for bit in range(width))
+
+
+def body(tape):
+    from words import BLANK
+    return bytes(tape.cells[1:]).rstrip(bytes([BLANK]))
+
+
+def walsh(values,D,left,right,fields,rows):
+    # In-place butterflies give an oracle independent of the physical caller.
+    addresses=1<<(left+D+right);result=[list(pair) for pair in values]
+    for row in range(rows):
+        for axis in range(D):
+            mask=1<<(right+axis)
+            for address in range(addresses):
+                if address&mask:continue
+                for field in range(fields):
+                    a=(row*addresses+address)*fields+field;b=a+mask*fields
+                    x,y=result[a][:],result[b][:]
+                    result[a]=[x[c]+y[c] for c in (0,1)]
+                    result[b]=[x[c]-y[c] for c in (0,1)]
+    divisor=1<<D
+    return [tuple((abs(v)//divisor)*(1 if v>=0 else -1) for v in pair) for pair in result]
+
+
+def roots(planner,root,phase):
+    from cardinal_counts import Count
+    from fixture_binding import FixtureBinding
+    from macro_code import Code
+    from ordinary import Ordinary
+    from records import Tape
+    from root_layer import RootLayer
+    from root_streams import RowPadding
+    from selected_binding import Group
+    from session import erase_marker
+    from words import BLANK
+    class OneCover:
+        size=1
+        @staticmethod
+        def unrank(index):
+            need(index==0,'single fixture cover');return (1,2)
+    class Observed(planner.MinimumRootPlan):
+        def compute(self,*args):
+            super().compute(*args)
+            names=('q0','depth','stock','original_rows','padded_rows','core_width')
+            self.observed={k:integer(self.count(k)) for k in names}
+            return self
+    class Reduced(Observed):
+        def parameters(self,precision):return tuple(Count.literal(v) for v in (8,1,1,1,32))
+    class Repeated(FixtureBinding):
+        def __init__(self,copies):
+            super().__init__();self.copies=copies;self.families=2*copies;self.cover=OneCover()
+        def group_count(self,event):
+            need(event==0,'fixture event');return self.copies
+        def group(self,event,subgroup,cover):
+            need(0<=subgroup<self.copies,'fixture subgroup')
+            g=super().group(event,0,cover)
+            return Group(tuple((2*subgroup+f,c) for f,c in g.keys),g.code,g.recipes)
+    packets=0;events={};digest=hashlib.sha256();plans=[];peaks=[];controls=0
+    for copies,reduced,cases in ((1,False,((5,0,1,1,2,2,0),(5,1,1,1,2,2,0),(5,2,1,0,2,1,0),(6,3,0,1,1,1,0))),
+                                  (1,True,((9,8,0,0,1,1,0),)),(3,True,((9,8,0,0,1,1,0),(9,8,0,0,1,1,0)))):
+        if phase=='roots-direct' and reduced:continue
+        if phase=='roots-two' and (not reduced or copies!=1):continue
+        if phase=='roots-six' and (not reduced or copies!=3):continue
+        binding=Repeated(copies)
+        native=Ordinary(2,SimpleNamespace(codes=SimpleNamespace(q=2)),SimpleNamespace(families=0),
+                        (Code((('unreachable',),),0),),capacity=64)
+        plan=(Reduced if reduced else Observed)(2,1,2*copies,guard_exponent=2)
+        def observe(machine,event):
+            events[event]=events.get(event,0)+1
+            need(not machine.pool.live and not layer.pool.live,'closed pools at child cut')
+        layer=RootLayer(binding,native,binding.catalogue,plan,observe)
+        for parameters in cases:
+            p,D,left,right,fields,rows,rho=parameters
+            count=rows*(1<<(left+D+right))*fields
+            values=[((2+packets)+(1 if i&1==0 else -1),
+                     (1+packets%2)*(1 if (i&3).bit_count()%2==0 else -1)) for i in range(count)]
+            raw=encode(values,p+2);expected=encode(walsh(values,D,left,right,fields,rows),p+2)
+            source=Tape()
+            for bit in raw:source.append(bit)
+            source.rewind();counts=tuple(Count.literal(v) for v in parameters);before=tape_snapshot(counts)
+            result=layer.run(source,*counts)
+            desc=plan.observed;desc['families']=2*copies;desc['reduced_law']=reduced
+            if reduced and copies==3:
+                need(desc['q0']==2 and desc['stock']==6 and desc['original_rows']==4 and desc['padded_rows']==6,'actual non-power padding case')
+            plans.append(desc)
+            need(body(result)==expected and any(body(result)),'complete dirty root endpoint')
+            need(body(source)==raw and tape_snapshot(counts)==before,'complete root borrowed state')
+            need(layer.closed and not layer.pool.live and layer.current.read()==BLANK and
+                 all(t.read()==BLANK for t in plan.roles.values()),'root-owned state cleared')
+            plan.pool.empty();digest.update(body(result))
+            result.clear();erase_marker(result);source.clear()
+            for c in counts:c.close()
+            packets+=1
+        peaks.append(plan.pool.peak)
+    if phase in ('roots','roots-six'):
+        padding=RowPadding();counts=tuple(Count.literal(v) for v in (1,1,2,2));source=Tape()
+        for bit in (1,0,1,0):source.append(bit)
+        source.rewind();controls=0
+        try:padding.run(source,*counts,remove=True)
+        except ValueError as error:
+            need('nonzero padded row' in str(error),'dirty padding failure reason');controls+=1
+        else:raise ValueError('nonzero padded row accepted')
+        need(padding.closed and not padding.pool.live and body(source)==bytes((1,0,1,0)),'dirty padding cleanup')
+        source.clear()
+        for bit in (1,0,0,0):source.append(bit)
+        source.rewind();answer=padding.run(source,*counts,remove=True)
+        need(body(answer)==bytes((1,0)),'padding reuse after failure')
+        answer.clear();erase_marker(answer);source.clear()
+        for c in counts:c.close()
+    return dict(packets=packets,plans=plans,recursive_events=events,padding_failure_controls=controls,
+                plan_pool_peaks=peaks,sha256=digest.hexdigest(),
+                scope='Production root formulas with reduced guard; fast roots use an explicit reduced parameter law and complete C2 fixture.')
+
+
+def main():
+    parser=argparse.ArgumentParser();parser.add_argument('--phase',choices=('arithmetic','roots','roots-direct','roots-two','roots-six'),required=True)
+    args=parser.parse_args();inputs=authenticate()
+    import planner,retained
+    root,_=retained.activate()
+    result=arithmetic(planner,root) if args.phase=='arithmetic' else roots(planner,root,args.phase)
+    print(json.dumps(dict(status='PASS_ENCODED_MINIMUM_ROOT_PREFIX_'+args.phase.upper(),source_inputs=inputs,**result),sort_keys=True,indent=2))
+
+
+if __name__=='__main__':main()