diff --git a/research/p104-unread-path-resynthesis/LOCAL-EDITS.json b/research/p104-unread-path-resynthesis/LOCAL-EDITS.json
new file mode 100644
index 0000000000..f725d2bb87
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/LOCAL-EDITS.json
@@ -0,0 +1,6 @@
+[
+  [
+    "8 <= owned <= 25",
+    "8 <= owned <= 29"
+  ]
+]
diff --git a/research/p104-unread-path-resynthesis/NOTICE b/research/p104-unread-path-resynthesis/NOTICE
new file mode 100644
index 0000000000..8fc3f76cc0
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/NOTICE
@@ -0,0 +1,113 @@
+Unread-register path resynthesis
+Copyright 2026 Ali Romman. Apache-2.0.
+
+New construction, code, calculations and prose: Ali Romman with substantial
+OpenAI Codex assistance. No subagents. All new checks are author-side.
+
+Mason Hale supplied PR5811, the complete two-block composition and the exact
+role92 remapping and fourth accumulation. The earlier elementary accumulation,
+retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied
+R22. Dugongue supplied the concurrent baseline composition proof. Their source
+notice and proof are retained byte for byte under inputs/pr5811-*.
+
+The source closure retains flyingviper, Cinna Davis, David Arias, Gareth
+Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc,
+Scratch-net and all native/helper/controller/compiler/geometry/analytic
+predecessors. The exact PR5786 source archive and its nested notices remain.
+This package does not claim any predecessor construction as new.
+
+Exact PR5811 vendor/accumulated/NOTICE follows. Source head:
+33d7760d0a6fea6394aefd014eea68f0af02a92e
+
+Accumulated native updates
+New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+No subagents. The same assistant made the construction and the author checks.
+
+Concurrent scope: Discussion5125 now tests retained copies in the transposed
+supplier. That route uses the same source/destination duality. This package
+claims the three fixed forward-supplier groups and their complete result,
+not the elementary accumulation identity or the broader transposed search.
+
+Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25.
+The complete predecessor notice follows unchanged.
+
+Asynchronous helper hubs
+New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+
+Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae.
+All prior credit follows unchanged.
+
+Paid intermediate meetings and collective helper splits.
+Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0.
+No subagents. All checks are author-side calculations.
+
+The complete PR5718 notice follows unchanged.
+
+Four paid interior public-basis changes.
+Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0.
+No subagents.
+
+The following exact notice is retained from PR5660.
+
+New helper-subspace construction, proof and replay:
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+The same assistant performed the construction and author-side checks.
+
+Retained contributions:
+flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613
+relay/split compositions.
+Scratch-net: PR5606 prepared-helper identities and target debit.
+Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source.
+Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame
+change, PR5580 contact step,
+and PR5544/5545 complete P104 caller.
+Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff.
+DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools.
+thu-nmrc: PR5551 contact improvements.
+Gareth Davidson (bitplane): PR2305 source composition.
+David Arias: PR2152 coalesced P104 word.
+Cinna Davis: PR2219 private reuse and the controller lineage.
+Jacob Alan Sussman: productive mixed-target recursion.
+zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage.
+GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept.
+The retained source notices preserve earlier geometry, BIT and analytic credit.
+
+The elementary rank-one basis identity is not claimed as a new general
+linear-algebra theorem. The contribution is its explicit independent-target
+use on this P104 word and the complete conditional kappa improvement.
+
+New contribution: Ali Romman, with substantial OpenAI Codex assistance.
+The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644.
+The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit.
+The compensated triangle method retains Cinna Davis PR4692 credit.
+No subagents were used for this contribution. Apache-2.0.
+
+Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by
+Ali Romman corroborates it. This package credits that released composition
+and contributes the further four-gate placement.
+
+New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices.
+
+Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial
+OpenAI Codex assistance, including independent AI review agents. Apache-2.0.
+
+Retained native-copy construction
+Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents.
+The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance.
+The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled
+PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included.
+The retained-copy mechanism, exact constructor, source-specific verification,
+new price and proof are the contribution of this package. Apache-2.0.
+
+Exact PR5811 vendor/blocks/NOTICE follows. Source head:
+33d7760d0a6fea6394aefd014eea68f0af02a92e
+
+The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged.
+
+The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution.
+
+New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0.
+
+The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged.
+
+The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations.
diff --git a/research/p104-unread-path-resynthesis/PLAN.json b/research/p104-unread-path-resynthesis/PLAN.json
new file mode 100644
index 0000000000..dc269304a4
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/PLAN.json
@@ -0,0 +1,105 @@
+{
+  "start": 13815,
+  "old": [
+    [
+      "MOVE",
+      773,
+      1031,
+      597,
+      true
+    ],
+    [
+      "ADD",
+      709,
+      773,
+      "1",
+      597
+    ],
+    [
+      "MOVE",
+      733,
+      3,
+      597,
+      false
+    ],
+    [
+      "ADD",
+      733,
+      773,
+      "1",
+      597
+    ],
+    [
+      "MOVE",
+      695,
+      3,
+      597,
+      false
+    ],
+    [
+      "ADD",
+      695,
+      733,
+      "1",
+      597
+    ],
+    [
+      "MOVE",
+      695,
+      597,
+      1031,
+      false
+    ]
+  ],
+  "new": [
+    [
+      "ADD",
+      695,
+      733,
+      "1",
+      3
+    ],
+    [
+      "MOVE",
+      695,
+      3,
+      1031,
+      false
+    ],
+    [
+      "ADD",
+      695,
+      773,
+      "1",
+      1031
+    ],
+    [
+      "MOVE",
+      773,
+      1031,
+      597,
+      true
+    ],
+    [
+      "ADD",
+      709,
+      773,
+      "1",
+      597
+    ],
+    [
+      "MOVE",
+      733,
+      3,
+      597,
+      false
+    ],
+    [
+      "ADD",
+      733,
+      773,
+      "1",
+      597
+    ]
+  ]
+}
\ No newline at end of file
diff --git a/research/p104-unread-path-resynthesis/PRICING-EDITS.json b/research/p104-unread-path-resynthesis/PRICING-EDITS.json
new file mode 100644
index 0000000000..205de29901
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/PRICING-EDITS.json
@@ -0,0 +1,18 @@
+[
+  [
+    "KAPPA, TESTED = Q('.00312265044'), Q('.003122650445')",
+    "KAPPA, TESTED = Q('0.00312476680'), Q('0.003124766805')"
+  ],
+  [
+    "PREVIOUS = Q('.00312192127')",
+    "PREVIOUS = Q('0.00312418633064')"
+  ],
+  [
+    "'kappa_decimal':'0.00312265044','previous_pr5774':PREVIOUS",
+    "'kappa_decimal':'0.00312476680','previous_pr5811':PREVIOUS"
+  ],
+  [
+    "sum(paid.values()) == 66906",
+    "sum(paid.values()) == 66870"
+  ]
+]
diff --git a/research/p104-unread-path-resynthesis/PROOF.md b/research/p104-unread-path-resynthesis/PROOF.md
new file mode 100644
index 0000000000..eae2e1b895
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/PROOF.md
@@ -0,0 +1,152 @@
+# One direct query for an unread register
+
+The exact source is PR5811 at
+`33d7760d0a6fea6394aefd014eea68f0af02a92e`. This package changes one
+seven-event interval. It retains every public input, target and boundary,
+and every owned event. The complete conditional claim is kappa 0.00312476680.
+The five inherited assumptions remain.
+
+## Four-field identity and physical frames
+
+Let a, b, c and d be the entry values of roles 695, 733, 773 and 709.
+These four values are arbitrary, including c in the owned field. Let A be
+frame 3, C be frame 597, and B be frame 1031. The exact source has
+A strictly inside C strictly inside B, at dimensions 0, 4 and 5.
+
+The source interval starts at event 13815. It performs:
+
+```text
+MOVE c: B -> C
+ADD  d += c in C
+MOVE b: A -> C
+ADD  b += c in C
+MOVE a: A -> C
+ADD  a += b in C
+MOVE a: C -> B
+```
+
+The replacement performs:
+
+```text
+ADD  a += b in A
+MOVE a: A -> B
+ADD  a += c in B
+MOVE c: B -> C
+ADD  d += c in C
+MOVE b: A -> C
+ADD  b += c in C
+```
+
+Both words leave the decoded values
+`a'=a+b+c`, `b'=b+c`, `c'=c` and `d'=d+c` in the same exit frames.
+The first new ADD reads b before its update. The second reads c before
+its reverse native query. No outside event occurs inside this interval.
+Thus the replacement preserves every later source observation, including
+all 23 COPY payloads. The constructor also compares the entire owned-event
+subsequence byte for byte.
+
+The constructor checks the exact interval and its unique location. A
+separate four-by-four rational transfer calculation compares all entry
+coefficients. The full forward replay checks all 799 input coordinates,
+including owned input columns. A dense integer transpose interpreter checks
+the same endpoint in reverse order with binary denominators. Each interpreter
+checks 638401 coefficients. All arbitrary public helper inputs are retained.
+
+## Native and ordinary costs
+
+The two public queries A to C and C to B have ranks 4 and 1. Their
+replacement A to B has rank 5. Every native map must implement the actual
+frame change, including its absolute phase. Exact Clifford lowering and a
+separate native interpreter check all 2918 distinct maps. The checks also
+cover 208 main adapters and 1124 helper normalizers.
+
+Write H_r(t)=r^t. The exact local changes are
+
+```text
+Delta paid = -H1-H4+H5
+Delta targets = 0
+```
+
+The signed gain is H1+H4-H5. It is positive for every 0<t<1 because
+`(1+4)^t < 1+4^t`. This argument concerns this replacement, not all
+possible native words. Both paid and productive rank masses stay fixed.
+
+The replacement adds one scalar ADD. Its eight real scalar primitives
+raise the local allowance from 225038 to 225046. The word still has
+25984 events, 770 public inputs, 29 owned labels and 31 owned lifetimes.
+Peak owned storage remains 13. No new COPY, INIT, CLEAR or storage is used.
+The local checker retains all source predicates; its declared owned-label
+cap is raised from the older PR5786 value 25 to the existing PR5811 value 29.
+The native nesting and phase conditions are unchanged.
+
+The final local profiles are:
+
+| Kind | Profile |
+|---|---|
+| Paid | 2225H1 + 456H2 + 498H3 + 98H4 + 163H5 + 9H6 + 6H7 |
+| Helpers | 18H1 + 7H2 + 4H3 + 107H4 + 14H5 + 9H7 + 18H8 + 385H9 |
+
+The local paid rank mass is 5934. Each scalar and route is charged. Local
+routes cost at most 5327000 ordinary primitives. Scalars and routes fit
+inside the retained local allowance of 10000000.
+
+## Complete caller and strict price
+
+The unchanged physical p16/a7 caller makes 18 forward local calls, 15 query
+shears and 3120 whole idle jobs. Its complete paid profile is
+
+```text
+P = 18 P_local + 1560 H1
+    + 208 sum over L in {7,8}, j=1..L of H_(8(j+1)).
+T = 18 T_local + 208 H145
+    + 208 sum over L in {7,8}, j=1..L of H_(1+8(j+1)).
+```
+
+The event invoice and this separate formula agree. There are 66870 paid
+calls and 13444 productive targets. The rank-mass surplus remains 760.
+The full ordinary bound is 184647552, below the retained 1000000000 budget.
+No thin query, idle, adapter, normalizer, route or owned operation is omitted.
+
+Two rational interval engines verify a strict raw crossing inside
+`(0.00312476681507,0.00312476681508)`. A negative derivative bound proves
+uniqueness on `[0,0.0034]`. This is the ceiling of the fixed invoice in that
+interval, not a limit on other words. The source invoice fails at the new
+claim. The exact declared gain over PR5811 is 0.00000058046936, about
+0.01858 percent. This is a small step; it does not meet the donor's requested
+large improvement.
+
+The tested saving is 0.003124766805. Completion uses cutoff 16, floor 17,
+offset 1/7, power 1024, reserve 10^-12, decay 125/128 and block length 128.
+All three tail ratios, splitting, rounding and complement capacity checks
+pass. The finite compiler threshold is `H=80511200000000000`. The full
+outer calculation has 54 strict inequalities and four functional conditions;
+each is positive. The unchanged admitted BIT saving is 0.0034.
+
+## Controls, scope and credit
+
+Controls reject a missing early observation, a wrong late sign, a missing
+native query, a late read of the old value, a changed source interval,
+an omitted paid call and an extra productive target. The retained caller
+control rejects a missing central translation. Four direct source corruptions
+reject before import. The native phase control and the old completion,
+offset, cutoff and BIT controls also run. All failures use explicit errors
+and remain active under optimized Python.
+
+The source word, proof, result and notice are retained with size, Git blob
+and SHA256 pins. The authenticated PR5786 archive supplies the unchanged
+native, caller, interval and compiler closure. No pending source Git object
+is required during replay. The source claim is independently recounted; its
+stored result is evidence, not a substitute for the new calculation.
+
+The assumptions native_all_columns, owned_erasure, compiler, precision_tape
+and analytic_recovery remain. The large uniform word and rounded multiplier
+are not materialized. Author-side replay is not independent human acceptance
+or formal-kernel verification. The selected frontier is unchanged.
+
+Mason Hale supplied PR5811's exact composition, role92 remapping and full
+price. Ali Romman supplied the earlier accumulation and second-block work.
+Joel Pulikkan supplied R22. Dugongue supplied the concurrent composition
+proof. All source notices and their native, helper, controller, compiler,
+BIT and analytic credits remain. The new seven-event path identity and this
+verification are by Ali Romman with substantial OpenAI Codex assistance.
+No subagents. Apache-2.0.
diff --git a/research/p104-unread-path-resynthesis/README.md b/research/p104-unread-path-resynthesis/README.md
new file mode 100644
index 0000000000..e663d06944
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/README.md
@@ -0,0 +1,90 @@
+# Conditional kappa 0.00312476680 from one unread path
+
+This construction raises complete conditional kappa from PR5811's
+0.00312418633064 to **0.00312476680**. The exact gain is 0.00000058046936.
+It replaces two paid queries of ranks 4 and 1 by one rank-5 query. All
+productive targets remain. One added scalar ADD is charged.
+
+The new word changes seven events on roles 695, 709, 733 and 773. It reads
+an old source value before that value changes, then sends the destination
+directly to its final frame. The four-field transfer matrix and every later
+observation stay fixed. This is separate from PR5811's role92 accumulation.
+
+The complete caller has 66870 paid calls and 13444 productive targets,
+with rank surplus 760. Its raw crossing is strictly inside
+`(0.00312476681507,0.00312476681508)`. The fixed invoice has less than
+1.508e-11 raw headroom above the declared claim. Further gains need a changed
+invoice. This result is small and does not meet the donor's large-improvement
+target. The selected repository frontier stays unchanged.
+
+Read PROOF.md for the identity and complete cost, PLAN.json for the exact
+edit, WITNESS.json for the transfer and word hashes, RESULT.json for the
+full receipt, and SOURCES.json for all source bindings.
+
+## Reproduce
+
+Use Python 3.12 and its standard library. No network, Git or third-party
+package is needed by the scientific verifier.
+
+```sh
+python3.12 -B scripts/research_package.py --package research/p104-unread-path-resynthesis
+```
+
+Expected final line in each registered mode:
+
+```text
+PASS_P104_UNREAD_PATH_KAPPA_00312476680
+```
+
+The verifier regenerates the word and compares the complete retained outputs.
+It checks all 799 input coordinates, a separate transpose, all 2918 native
+maps and absolute phases, 1124 helper normalizers, 208 main adapters, the
+physical caller, both interval engines, completion and compiler costs, and
+54 strict plus four functional outer conditions. Rejection controls are
+listed in PROOF.md. The registered command runs normal and optimized modes.
+See VALIDATION.md for the executed commands and export receipt.
+
+## Exact inputs and credit
+
+The branch starts from canonical main
+`de5ec2e7a6074068452f45b1a191b5c72832df4a`, priority revision 8.
+The source word is [PR #5811](https://github.com/CrocSwap/integer-mult-bounds/pull/5811)
+at `33d7760d0a6fea6394aefd014eea68f0af02a92e`. Its word, proof, result and
+notice are retained byte for byte. Its published composition and role92
+step are predecessor work. The exact
+[PR #5786](https://github.com/CrocSwap/integer-mult-bounds/pull/5786) closure
+at `6b936acd68a7e0f9062037900f0fe9bc4b6fdd25` supplies the authenticated
+native, caller and compiler modules. Only the explicit checker capacity
+and price edits in LOCAL-EDITS.json and PRICING-EDITS.json are permitted.
+
+Credit Mason Hale for PR5811, Ali Romman for the accumulated-update and
+second-block lineage, Joel Pulikkan for R22, Dugongue for the concurrent
+composition proof, flyingviper and all retained source authors. NOTICE
+and the unmodified source notices give the full attribution. The new
+path rewrite, code and prose are by Ali Romman with substantial OpenAI
+Codex assistance. No subagents. Apache-2.0.
+
+## Coordination and limits
+
+The [canonical investigation](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19154639)
+records the exact source, region and hypotheses. The October 27 snapshot
+through 03:15 UTC covers 376 open PRs and 5236 Discussion records, with
+complete pagination. Sparse local notes and unpublished work remain outside
+that coverage. The role695 interval is separate from the released role92
+step and the active mixed-payload, helper-retirement and variable-caller
+investigations. No other contributor's PR is changed.
+
+The five inherited assumptions remain: native_all_columns, owned_erasure,
+compiler, precision_tape and analytic_recovery. The finite local word is
+materialized; the large uniform word and rounded multiplier are not.
+Author checks are not independent human acceptance. Hosted CI is separate.
+No merge, closure or selected-frontier change is requested.
+
+## Open next questions
+
+- Can a helper channel through a nonnested frame improve the complete
+  invoice? Check live claims, actual native ranks, independent input/output
+  delivery and every new buffer before claiming a split.
+- Can an independent reviewer confirm the seven-event identity, source
+  bindings and full sealed replay? The complete command above is the first
+  step. The inherited framework assumptions remain separate obligations.
diff --git a/research/p104-unread-path-resynthesis/RESULT.json b/research/p104-unread-path-resynthesis/RESULT.json
new file mode 100644
index 0000000000..e2e078df44
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/RESULT.json
@@ -0,0 +1,381 @@
+{
+  "complete_cost": {
+    "compiler": {
+      "H": 80511200000000000,
+      "N": "2^80511200000000000",
+      "eta": {
+        "lower": "0.000000120998313166749476106731",
+        "upper": "0.000000120998313166749476106732"
+      },
+      "gap": "1/1400000000000",
+      "integer_test_exponent": 57508,
+      "logarithm_power": 1024,
+      "theta": "63/64",
+      "uniform_saving": "2187336763/700000000000",
+      "word_materialized": false
+    },
+    "full_forward_calls": 18,
+    "gain": "7255867/12500000000000",
+    "kappa": "7811917/2500000000",
+    "kappa_decimal": "0.00312476680",
+    "margin_at_previous": {
+      "lower": "0.140241482748691693609074304632",
+      "upper": "0.140241482748691693609074304633"
+    },
+    "negative_controls": {
+      "old_BIT": "Rejected by outer inequalities",
+      "old_cutoff": "Rejected by completion-tail ratio greater than one",
+      "source_completion": "Rejected at cutoff17, floor18 and decay39/40",
+      "source_offset": "Rejected at cutoff16 with tail offset1/5"
+    },
+    "nonrecursive": {
+      "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.",
+      "local_paid_rank_mass": 5934,
+      "local_routes": 5327000,
+      "local_scalar": 225046,
+      "peak_owned_fields": 13,
+      "raw_budget": 1000000000,
+      "raw_scalar_upper": 184647552,
+      "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word."
+    },
+    "ordinary_BIT": {
+      "admitted": "17/5000",
+      "after_cover": "69/20000",
+      "atom": "1/250",
+      "before_cover": "3459/1000000",
+      "ordinary_saving": "8590884599/2500000000000",
+      "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses"
+    },
+    "outer": {
+      "functional_checks": {
+        "actual_new_BIT_stock_sublinear": "348599999999253/350000000000000",
+        "fixed_halo_explicit_metadata_branch": "26950000000001/350000000000",
+        "new_BIT_row_stock_sublinear_in_active_group": "1395799999997009/1400000000000000",
+        "new_semantic_group_guard": "3/1400000000000"
+      },
+      "margins": {
+        "boundary_algebraic_matrix": "6124542933595625326477/1960000000000000000000000",
+        "fused_gaussian": "6124542933586875979431/1960000000000000000000000",
+        "global_coordinate_router": "1093668381/350000000000",
+        "group_bit_router": "1531135733746718994857/490000000000000000000000",
+        "group_scans": "699999999999/700000000000",
+        "main_transform": "6124542932195625326477/1960000000000000000000000",
+        "microbox_face_corrections": "26950000000001/350000000000",
+        "polynomial_products": "1399999999999/1400000000000",
+        "sparse_union_movement": "802374542933595625326477/1960000000000000000000000"
+      },
+      "parameters": {
+        "a": "1093668381/350000000000",
+        "b": "174986941/56000000000",
+        "beta": "1399999999997/1400000000000",
+        "bit_saving": "17/5000",
+        "cap_xi": "1782374542932195625326477/1960000000000000000000000",
+        "complex_uniform_saving": "2187336763/700000000000",
+        "d": "1/1400000000000",
+        "epsilon": "1399999999999/1400000000000",
+        "kappa": "7811917/2500000000",
+        "lambda_": "398750093279/400000000000",
+        "lambda_prime": "1395625326477/1400000000000",
+        "layout": "1/1400000000000",
+        "q": "4374673523/1400000000000",
+        "r0": "1/14000000000000",
+        "stop": "1/1400000000000",
+        "tested_saving": "624953361/200000000000"
+      },
+      "strict_checks": {
+        "actual_bit_above_effective": "96331619/350000000000",
+        "actual_logarithmic_gamma_guard": "1/1400000000000",
+        "actual_logarithmic_group_guard": "177625457069904374673523/980000000000000000000000",
+        "alpha_logarithm_absorption": "1/14000000000000",
+        "boundary_algebraic_matrix_above_kappa": "5595625326477/1960000000000000000000000",
+        "cap_above_band": "802374542932195625326477/1960000000000000000000000",
+        "cap_below_cell": "177625457066404374673523/1960000000000000000000000",
+        "cap_below_phase_cell_power": "2137625457067804374673523/1960000000000000000000000",
+        "complex_above_effective": "1/1400000000000",
+        "complex_below_one_over_32": "1575013059/56000000000",
+        "complex_endpoint": "1/700000000000",
+        "epsilon_below_one": "1/1400000000000",
+        "epsilon_positive": "1399999999999/1400000000000",
+        "fine_prime_halo_umbrella": "7/2",
+        "fused_gaussian_above_kappa": "5586875979431/1960000000000000000000000",
+        "gaussian_above_main": "695625326477/980000000000000000000000",
+        "global_coordinate_router_above_kappa": "1/350000000000",
+        "global_gamma_power_slack": "9/14000000000000",
+        "group_below_dimension": "1/700000000000",
+        "group_bit_router_above_kappa": "1746718994857/490000000000000000000000",
+        "group_gauge_power_slack": "177625457069834374673523/980000000000000000000000",
+        "group_key_fits_record": "1/700000000000",
+        "group_positive": "1399999999997/1400000000000",
+        "group_scans_above_kappa": "697812663239/700000000000",
+        "halo_covers_generic_inverse_radius": "5",
+        "improvement_over_user_baseline": "696898190400418148631/500000000000000000000000",
+        "lambda_above_internal": "1/2800000000000",
+        "lambda_above_sigma": "3/2800000000000",
+        "lambda_above_tau": "1/2800000000000",
+        "lambda_prime_above_lambda": "1/2800000000000",
+        "lambda_prime_above_leaf": "111825013059/78400000000000000000000",
+        "leaf_saving_above_effective": "55825013059/78400000000000000000000",
+        "main_transform_above_kappa": "4195625326477/1960000000000000000000000",
+        "membership_arithmetic_fits_record": "1/1400000000000",
+        "microbox_face_corrections_above_kappa": "26948906331621/350000000000",
+        "microbox_halo_volume": "110600000000003/1400000000000",
+        "new_complex_uniform_saving_above_b": "1/1400000000000",
+        "new_semantic_guard_with_C1_one": "1/1400000000000",
+        "polynomial_products_above_kappa": "1395625326479/1400000000000",
+        "positive_layout_slack": "1/1400000000000",
+        "q_below_effective": "1/1400000000000",
+        "q_below_internal": "1/1400000000000",
+        "q_below_leaf": "111825013059/78400000000000000000000",
+        "q_positive": "4374673523/1400000000000",
+        "short_record_fallback": "55825013059/56000000000",
+        "source_axis_superpolynomial": "1/1400000000000",
+        "sparse_union_movement_above_kappa": "796250000005595625326477/1960000000000000000000000",
+        "stop_below_one": "1399999999999/1400000000000",
+        "stop_positive": "1/1400000000000",
+        "strassen_integer_power_gap": "1951441519231",
+        "support_router_span": "3/1400000000000",
+        "theta_positive_polynomial_power": "2",
+        "union_header_fits_record": "3/1400000000000",
+        "union_tag_work_per_visit_fits_record": "3/1400000000000"
+      }
+    },
+    "paid": {
+      "1": 41610,
+      "16": 416,
+      "2": 8208,
+      "24": 416,
+      "3": 8964,
+      "32": 416,
+      "4": 1764,
+      "40": 416,
+      "48": 416,
+      "5": 2934,
+      "56": 416,
+      "6": 162,
+      "64": 416,
+      "7": 108,
+      "72": 208
+    },
+    "paid_calls": 66870,
+    "previous_pr5811": "39052329133/12500000000000",
+    "productive_fields": 13444,
+    "query_shears": 15,
+    "rank_mass_surplus": 760,
+    "raw_ceiling": {
+      "derivative_upper": "-367933136390632154472669927947898325700600889223675898395208059/1569275433846670190958947355801916604025588861116008628224",
+      "interval": [
+        "0",
+        "17/5000"
+      ]
+    },
+    "raw_headroom": [
+      "1507/100000000000000",
+      "377/25000000000000"
+    ],
+    "raw_root_interval": [
+      "312476681507/100000000000000",
+      "78119170377/25000000000000"
+    ],
+    "relative_gain_percent": "725586700/39052329133",
+    "strictification": {
+      "alpha": {
+        "lower": "0.999999999989768874284444177647",
+        "upper": "0.999999999989768874284444177648"
+      },
+      "cutoff": 16,
+      "delta": {
+        "lower": "0.951913152001029451974474596213",
+        "upper": "0.951913152001029451974474596214"
+      },
+      "floor": 17,
+      "gamma": {
+        "lower": "0.975606802226899703414382904960",
+        "upper": "0.975606802226899703414382904961"
+      },
+      "normalized_paid_upper": "1048576000976562501/1048576001073741824",
+      "power": 1024,
+      "reserve": "1/1000000000000",
+      "tail_block": 128,
+      "tail_decay": "125/128",
+      "tail_offset": "1/7",
+      "tested": "624953361/200000000000"
+    },
+    "targets": {
+      "1": 324,
+      "145": 208,
+      "17": 416,
+      "2": 126,
+      "25": 416,
+      "3": 72,
+      "33": 416,
+      "4": 1926,
+      "41": 416,
+      "49": 416,
+      "5": 252,
+      "57": 416,
+      "65": 416,
+      "7": 162,
+      "73": 208,
+      "8": 324,
+      "9": 6930
+    },
+    "whole_idle_jobs": 3120
+  },
+  "controls": {
+    "changed_source_interval": "One exact source interval",
+    "damaged_source_NOTICE": "Exact source SHA256: research/p104-accumulated-block-composition/NOTICE",
+    "damaged_source_PROOF.md": "Exact source SHA256: research/p104-accumulated-block-composition/PROOF.md",
+    "damaged_source_RESULT.json": "Exact source SHA256: research/p104-accumulated-block-composition/RESULT.json",
+    "damaged_source_WORD.json.gz": "Exact source SHA256: research/p104-accumulated-block-composition/WORD.json.gz",
+    "extra_target_credit": "Every productive helper has a native target",
+    "late_use_of_old_value": "Scalar destination and coefficient",
+    "missing_central_translation": "Rejected by the complete Laurent endpoint",
+    "missing_direct_query": "Scalar destination and coefficient",
+    "missing_early_observation": "All public and owned rows",
+    "unpaid_query": "Complete field and call counts",
+    "wrong_late_sign": "All public and owned rows"
+  },
+  "limits": [
+    "All five inherited framework assumptions remain.",
+    "This is a small gain and does not meet the donor large-improvement target.",
+    "The large uniform word and rounded multiplier are not materialized.",
+    "Author checks do not establish independent acceptance.",
+    "The selected frontier is unchanged."
+  ],
+  "local": {
+    "endpoint_coefficients": 638401,
+    "helpers": {
+      "1": 18,
+      "2": 7,
+      "3": 4,
+      "4": 107,
+      "5": 14,
+      "7": 9,
+      "8": 18,
+      "9": 385
+    },
+    "owned_fields": 29,
+    "owned_lifetimes": 31,
+    "paid": {
+      "1": 2225,
+      "2": 456,
+      "3": 498,
+      "4": 98,
+      "5": 163,
+      "6": 9,
+      "7": 6
+    },
+    "paid_rank_mass": 5934,
+    "peak_owned_fields": 13,
+    "public_inputs": 770,
+    "real_scalar_allowance": 225046
+  },
+  "native": {
+    "distinct_maps": 2918,
+    "helper_normalizers": 1124,
+    "helpers": {
+      "1": 18,
+      "2": 7,
+      "3": 4,
+      "4": 107,
+      "5": 14,
+      "7": 9,
+      "8": 18,
+      "9": 385
+    },
+    "main_adapters": 208,
+    "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width",
+    "recipe_payload_sha256": "fdaf779e9bf6affff9a356b0182f7971b2bddb41b2dc8f40cdbfbccb7735e803",
+    "wrong_phase_rejected": true
+  },
+  "paid_delta": {
+    "1": -1,
+    "4": -1,
+    "5": 1
+  },
+  "physical_caller": {
+    "central_square_columns": 53248,
+    "full_calls": 18,
+    "main_targets": {
+      "145": 208,
+      "17": 416,
+      "25": 416,
+      "33": 416,
+      "41": 416,
+      "49": 416,
+      "57": 416,
+      "65": 416,
+      "73": 208
+    },
+    "new_paid_jobs": 0,
+    "physical_contacts": 7488,
+    "ports": 104,
+    "route_payload_sha256": "7f4f0ca768ffbc4f93dcff575592c4c67411f46b4289e45b73f715a2ad47b142",
+    "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.",
+    "whole_idle_jobs": {
+      "16": 416,
+      "24": 416,
+      "32": 416,
+      "40": 416,
+      "48": 416,
+      "56": 416,
+      "64": 416,
+      "72": 208
+    },
+    "wrapper_sites": [
+      1,
+      3,
+      5,
+      7,
+      9,
+      11,
+      13,
+      15,
+      17,
+      19,
+      21,
+      23,
+      25,
+      27,
+      29,
+      31
+    ]
+  },
+  "separate_columns": {
+    "arithmetic": "Dense integer rows with binary denominators; reverse chronology",
+    "coefficients": 638401,
+    "columns": 799
+  },
+  "source_commit": "33d7760d0a6fea6394aefd014eea68f0af02a92e",
+  "source_local": {
+    "endpoint_coefficients": 638401,
+    "helpers": {
+      "1": 18,
+      "2": 7,
+      "3": 4,
+      "4": 107,
+      "5": 14,
+      "7": 9,
+      "8": 18,
+      "9": 385
+    },
+    "owned_fields": 29,
+    "owned_lifetimes": 31,
+    "paid": {
+      "1": 2226,
+      "2": 456,
+      "3": 498,
+      "4": 99,
+      "5": 162,
+      "6": 9,
+      "7": 6
+    },
+    "paid_rank_mass": 5934,
+    "peak_owned_fields": 13,
+    "public_inputs": 770,
+    "real_scalar_allowance": 225038
+  },
+  "source_margin_upper_at_new_claim": "-440220558061576121529811506669002615477042299180450565263/3138550867693340381917894711603833208051177722232017256448",
+  "status": "PASS_P104_UNREAD_PATH_KAPPA_00312476680",
+  "target_delta": {}
+}
diff --git a/research/p104-unread-path-resynthesis/SOURCES.json b/research/p104-unread-path-resynthesis/SOURCES.json
new file mode 100644
index 0000000000..4531538f26
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/SOURCES.json
@@ -0,0 +1,193 @@
+{
+  "schema_version": 1,
+  "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8",
+      "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    }
+  ],
+  "source_archive": {
+    "local_path": "inputs/pr5786-source.tar",
+    "sha256": "9ca76daeb8db6b623d7329628248fae114946f35fb036c3171fcdba868131dc2",
+    "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+    "package": "research/p104-asynchronous-helper-hubs"
+  },
+  "archived_files": [
+    {
+      "path": "research/p104-asynchronous-helper-hubs/LOCAL-EDITS.json",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 168,
+      "sha256": "1118183d04913fd5c525a7aa85d727b6d9d36992b9d8490c5a866434b2754cec",
+      "git_blob": "13b3d3af9a5c2791fc34ab0cb7ce9becafd83682"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/NOTICE",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 3559,
+      "sha256": "2feedebb4a059025670699f807baa90818f0088267e8549f773de3e0ea296158",
+      "git_blob": "f3c2f7136cafafc77aa03c951eabd039ad8449ce"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/PLAN.json",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 3840,
+      "sha256": "2c4878f78dc393339f8cccf24441d9bfb50257784459c2f253ebcb27c964211c",
+      "git_blob": "9cf72d400fdb2adef54eca047c752a657a0d4a33"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/PRICING-EDITS.json",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 501,
+      "sha256": "25efa817a0474631afc3a1c09611cf50ca30314e66901f1dff802946915a04fa",
+      "git_blob": "11cc4d00e2759338c745d18df4248d8697d9c991"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/PROOF.md",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 8749,
+      "sha256": "0a2b7c13fadecf18a33320eb6b159757e5516e5e9c7b52a03db2e9f32f25f36a",
+      "git_blob": "e4cf2e4d06d9e9e8ac1c0e828693d9daace47201"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/README.md",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 3538,
+      "sha256": "742fd06e72b1f977ab9bb5e9ac0dfafc87cbc343a2e0f1c86e4eb77509e4746e",
+      "git_blob": "b48aa125fd628f96bb988f03cba23752ff907154"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/RESULT.json",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 12470,
+      "sha256": "eabb5f4ece0a4fc3ada4ea1796dc413eddb0683541fe03dd48f0f53cba1e2ea6",
+      "git_blob": "dc02cce2385d135bba9b8fcd0efc21954f75b791"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/SOURCES.json",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 15185,
+      "sha256": "3a70129e30648c647401ac1ce269bc65792f0f7d6b5649313ea78d20625b62ae",
+      "git_blob": "3343674d9bf0614fb517d86ec63fbcde9136ecbd"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/TASK.json",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 5684,
+      "sha256": "040a7af88daac30d5beca4f7db7410e5f987d46742828ba41fd42882081c6f72",
+      "git_blob": "561f2501d8820d82cb476e40d716b8403d13a1b1"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/VALIDATION.md",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 2093,
+      "sha256": "685af1e45b1a19c7bb6189321b290a49a183a4d4b8c53904319366fdc9aa5570",
+      "git_blob": "f9bd299edaa1a3497d2518ff86e9f6c461a61072"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/VERIFY.json",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 747,
+      "sha256": "eee6981e3c3243dd69d19c68042e6087dc97780016a6aa56a74fb438af1f9fd5",
+      "git_blob": "5550c891e8c17cdefe14b5dd585f4bfeaf887943"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/WITNESS.json",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 8029,
+      "sha256": "351a08afe2d427a552ed3d758f20f12429f8f4a4ca65fd2eacbe6d07a1a4cf5f",
+      "git_blob": "8ea4538a934601e3f81422f6bf532be288efe8fc"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/WORD.json.gz",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 122792,
+      "sha256": "35fbd3049ab7a731ed245944257e8fdad1eaa4c3baca71761bca7bf5f95f1243",
+      "git_blob": "e58322c358aac019a09f504b5c826108b3ab6731"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/construct.py",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 7571,
+      "sha256": "c1ded96afc454aa7f94d99f2a08c57f4eac731bc931ca034ec3b0040e1776fa7",
+      "git_blob": "4cc7004b89495ee34deebc775983b2160879c8b7"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/inputs/pr5774-source.tar",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 3543040,
+      "sha256": "e47cd61d6542497287f5a69820484e92f7116aaf76663969fe59a1d85fffe497",
+      "git_blob": "f34972476e76121c7cbb0e86478eaa86969c6efd"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/local.py",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 9394,
+      "sha256": "4d6db6dae893fc4e7e31148d2a8144d7a1a2afbba4b48f4532b0a1f1a9804f9e",
+      "git_blob": "1cd672569aebeca61193a975c0513003eefb1ec9"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/pricing.py",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 11022,
+      "sha256": "55fe9194ed9de830623f69472be808a043f129cedd2ba0c97ec49f6ae41df2a1",
+      "git_blob": "0fc0ca2a118ab0b7491d40ca90049febbeafab12"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/sources.py",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 3417,
+      "sha256": "fee3e7fd1c1aa4980b593b22de2d55a3e66f8dc8c7e7f5735f45bd67491768b0",
+      "git_blob": "76d152d2e1a535fa0324ab13ab832340f55a39f3"
+    },
+    {
+      "path": "research/p104-asynchronous-helper-hubs/verify.py",
+      "commit": "6b936acd68a7e0f9062037900f0fe9bc4b6fdd25",
+      "size": 8005,
+      "sha256": "520176dd2663695b7da89e67a007de50052244650bf462dc2fe08ed85d4e63b2",
+      "git_blob": "29ea98777c17911aeca0ce6247e2672445e2711b"
+    }
+  ],
+  "direct_sources": [
+    {
+      "path": "research/p104-accumulated-block-composition/WORD.json.gz",
+      "commit": "33d7760d0a6fea6394aefd014eea68f0af02a92e",
+      "git_blob": "3633d78556932b1d66285c19d888fcd7c62cdbf1",
+      "size": 122915,
+      "sha256": "690656bfca9c6f0366527d158ca4edb14f83c410604d647953c20c7c94bea2e8",
+      "local_path": "inputs/pr5811-WORD.json.gz"
+    },
+    {
+      "path": "research/p104-accumulated-block-composition/NOTICE",
+      "commit": "33d7760d0a6fea6394aefd014eea68f0af02a92e",
+      "git_blob": "bd91106cde0cc8c201329bedc2d45af65c582b57",
+      "size": 1027,
+      "sha256": "2f87017c7497194392d41c8ae80e5e1cfcf14651627cea2f918c1c8924c9858d",
+      "local_path": "inputs/pr5811-NOTICE"
+    },
+    {
+      "path": "research/p104-accumulated-block-composition/PROOF.md",
+      "commit": "33d7760d0a6fea6394aefd014eea68f0af02a92e",
+      "git_blob": "71a8c020a59e8469cd547511766db92fa79480c4",
+      "size": 12191,
+      "sha256": "87756328c812a9076a55d5ebe1b9ea81d8fdcb166608cb39b0b43cca2cdc8593",
+      "local_path": "inputs/pr5811-PROOF.md"
+    },
+    {
+      "path": "research/p104-accumulated-block-composition/RESULT.json",
+      "commit": "33d7760d0a6fea6394aefd014eea68f0af02a92e",
+      "git_blob": "2e73d97bdd2b2c13e05e66299722e0aa30c2d050",
+      "size": 19496,
+      "sha256": "2ba9ec0c06ce0c2683cdd704cacb63e6bb9afeb90a07a16fb63ec9e55696c488",
+      "local_path": "inputs/pr5811-RESULT.json"
+    }
+  ]
+}
diff --git a/research/p104-unread-path-resynthesis/TASK.json b/research/p104-unread-path-resynthesis/TASK.json
new file mode 100644
index 0000000000..1b7c6ccdb6
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/TASK.json
@@ -0,0 +1,123 @@
+{
+  "schema_version": 1,
+  "task_id": "p104-side-correction",
+  "priority_revision": 8,
+  "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a",
+  "original_card": {
+    "id": "p104-side-correction",
+    "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?",
+    "starting_points": [
+      "docs/research/current-priorities.md",
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+      "research/p104-helper-subspace-splits/README.md",
+      "research/dyadic-helper-channel-capacity/README.md"
+    ],
+    "methods": [
+      "Construct and independently check one source-bound instance of the stated first experiment.",
+      "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+    ],
+    "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_selected_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+      "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+    },
+    "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.",
+    "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+    "allowed_variations": [
+      "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+    ],
+    "scope_change_triggers": [
+      "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+      "Treating an archived proposal or local numerical pass as complete supplier admission."
+    ],
+    "overlap_terms": [
+      "P104",
+      "helper basis",
+      "helper split",
+      "5718",
+      "dyadic capacity"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4133: literal-slot defect",
+        "evidence": "research/p104-literal-slot-defect/README.md",
+        "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.",
+        "status": "author-checked",
+        "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "PR #4136: uniform commutation gap",
+        "evidence": "research/p104-uniform-commutation-gap/README.md",
+        "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.",
+        "status": "author-checked",
+        "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "PR #4140: uniform encoding gap",
+        "evidence": "research/p104-uniform-encoding-gap/README.md",
+        "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.",
+        "status": "author-checked",
+        "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance",
+        "evidence": "research/p104-source-chart-shortcut/README.md",
+        "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.",
+        "status": "author-checked",
+        "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "PR #4154: fiber-tag seam mismatch",
+        "evidence": "research/p104-fiber-tag-seam/README.md",
+        "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.",
+        "status": "author-checked",
+        "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+        "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+        "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+        "status": "reviewed",
+        "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+        "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+      }
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Resynthesize one unread public-register path in exact PR5811, with all productive targets fixed.",
+  "scope_change_reason": "The elementary two-query path has an earlier available source. Distribute the pending update across the endpoint frames and pay one direct native query.",
+  "bottleneck_link": "Replace H1+H4 by H5 in the paid profile. Check the complete caller, compiler and outer costs.",
+  "budget_minutes": null,
+  "stop_rule": "Retain the step only after every scalar column, native phase, full caller, cost and compiler check passes.",
+  "outcome": "completed",
+  "evidence": "PROOF.md, RESULT.json, WORD.json.gz and WITNESS.json",
+  "author": "Ali Romman with substantial OpenAI Codex assistance",
+  "ai_assistance": "Substantial OpenAI Codex assistance for construction, calculations, code and prose. No subagents. All checks are author-side.",
+  "open_questions": [
+    {
+      "question": "Can a different nonnested helper cut give a larger complete gain?",
+      "why_it_matters": "This result is a small step. It does not meet the donor large-improvement objective.",
+      "first_step": "Check live scopes and true native ranks, then prove the complete arbitrary-input split.",
+      "blocked_by": "No larger construction is established."
+    },
+    {
+      "question": "Does independent review accept this path replacement and full price?",
+      "why_it_matters": "Author checks do not establish independent acceptance.",
+      "first_step": "Replay the seven-event identity and the sealed complete package.",
+      "blocked_by": "Independent review and five framework assumptions remain open."
+    }
+  ]
+}
diff --git a/research/p104-unread-path-resynthesis/VALIDATION.md b/research/p104-unread-path-resynthesis/VALIDATION.md
new file mode 100644
index 0000000000..1a3fa30e39
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/VALIDATION.md
@@ -0,0 +1,32 @@
+# Validation
+
+Python 3.12. The primary complete replay passed with --write. It regenerated
+WORD.json.gz, WITNESS.json and RESULT.json. The registered normal and optimized
+commands also passed. Every mathematical check and rejection control in
+verify.py ran in each mode.
+
+```sh
+python3.12 -B scripts/research_package.py --package research/p104-unread-path-resynthesis
+python3.12 -B scripts/check_research_commit.py --package research/p104-unread-path-resynthesis --check-modes
+python3.12 -B scripts/export_research_package.py export --package research/p104-unread-path-resynthesis --output /tmp/p104-unread-path-export.tar
+python3.12 -B scripts/export_research_package.py check --check-inputs /tmp/p104-unread-path-export.tar
+```
+
+The scientific commit is 92e5b3dacbcadd585e68e6fc7b63665471513784. Its
+23 package files pass the committed-byte and mode check. The official
+export and input-integrity checks pass.
+
+A separate read-only, Git-free export passed under -I -O -B with empty PATH
+in 136.953 seconds. All 24 exported files, including the export manifest,
+kept their bytes and modes. Its archive SHA256 is
+`e09abfb69287950597fa024f68e256232929dc485d2119eae5bc10447fb22acc`.
+This run checked the actual complete operator, native, physical caller,
+price, compiler and outer calculation. It did not only inspect saved PASS
+text. The publication update changes this report, the overlap timestamp
+and attribution text; the complete runtime and all mathematical inputs
+and receipts are unchanged.
+
+Full-history ancestry mode was not run in the shallow checkout. Hosted
+scientific CI and independent human acceptance are separate. The shared
+priority-8 assignment-test failure is known from predecessor PRs; this
+package does not modify the shared tests or claim that hosted replay passed.
diff --git a/research/p104-unread-path-resynthesis/VERIFY.json b/research/p104-unread-path-resynthesis/VERIFY.json
new file mode 100644
index 0000000000..988b054166
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/VERIFY.json
@@ -0,0 +1,30 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 600,
+      "checks": "Regenerate the path rewrite; check all input columns, native phases, complete cost and failure controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 600,
+      "checks": "Regenerate the path rewrite; check all input columns, native phases, complete cost and failure controls."
+    }
+  ]
+}
diff --git a/research/p104-unread-path-resynthesis/WITNESS.json b/research/p104-unread-path-resynthesis/WITNESS.json
new file mode 100644
index 0000000000..969ff0c9b4
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/WITNESS.json
@@ -0,0 +1,39 @@
+{
+  "new_events_sha256": "3425f3c21ed2acdd3e49f8bda2294f9a0c2c56c7c2b260f54f1b7c25159f9776",
+  "old_events_sha256": "792b9d94a9e893621ca16f8c6a31c93adfa5faedbecfb004b2d4f8d583e998d4",
+  "roles": [
+    695,
+    709,
+    733,
+    773
+  ],
+  "source_word_sha256": "a06445539ad73fe16deae66fef8c52ffc39f5f14c765eab3dc3d98e0e2d8074c",
+  "start": 13815,
+  "transfer": [
+    [
+      "1",
+      "0",
+      "1",
+      "1"
+    ],
+    [
+      "0",
+      "1",
+      "0",
+      "1"
+    ],
+    [
+      "0",
+      "0",
+      "1",
+      "1"
+    ],
+    [
+      "0",
+      "0",
+      "0",
+      "1"
+    ]
+  ],
+  "word_sha256": "d1e5ee3b9811ce7be0ad80aecf19b41cd9277e838b3a9fe52d25baa610d58782"
+}
diff --git a/research/p104-unread-path-resynthesis/WORD.json.gz b/research/p104-unread-path-resynthesis/WORD.json.gz
new file mode 100644
index 0000000000..6341a49f71
Binary files /dev/null and b/research/p104-unread-path-resynthesis/WORD.json.gz differ
diff --git a/research/p104-unread-path-resynthesis/construct.py b/research/p104-unread-path-resynthesis/construct.py
new file mode 100644
index 0000000000..7d33cb8646
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/construct.py
@@ -0,0 +1,51 @@
+"""Replace one unread path by its exact endpoint-frame updates.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+from copy import deepcopy
+from fractions import Fraction as Q
+from hashlib import sha256
+import json
+from sources import need
+
+
+def digest(value):
+    return sha256(json.dumps(value, sort_keys=True, separators=(',', ':')).encode()).hexdigest()
+
+
+def transfer(events, roles):
+    """Compute the transfer on arbitrary values at the four entry fields."""
+    rows = {r: [Q(r == s) for s in roles] for r in roles}
+    for e in events:
+        if e[0] == 'MOVE':
+            continue
+        need(e[0] == 'ADD', 'The local identity uses only ADD and MOVE')
+        _, r, s, q, _ = e
+        rows[r] = [a+Q(q)*b for a, b in zip(rows[r], rows[s])]
+    return [[str(v) for v in rows[r]] for r in roles]
+
+
+def construct(source, plan):
+    old = [['MOVE', 773, 1031, 597, True], ['ADD', 709, 773, '1', 597],
+           ['MOVE', 733, 3, 597, False], ['ADD', 733, 773, '1', 597],
+           ['MOVE', 695, 3, 597, False], ['ADD', 695, 733, '1', 597],
+           ['MOVE', 695, 597, 1031, False]]
+    new = [['ADD', 695, 733, '1', 3], ['MOVE', 695, 3, 1031, False],
+           ['ADD', 695, 773, '1', 1031]] + old[:4]
+    need(plan == {'start': 13815, 'old': old, 'new': new}, 'Exact seven-event plan')
+    program = source['program']
+    hits = [i for i in range(len(program)-len(old)+1) if program[i:i+len(old)] == old]
+    need(hits == [plan['start']], 'One exact source interval')
+    roles = [695, 709, 733, 773]
+    matrix = transfer(old, roles)
+    need(matrix == transfer(new, roles), 'All coefficients of the four-field transfer')
+    word = deepcopy(source)
+    word['program'][plan['start']:plan['start']+len(old)] = deepcopy(new)
+    need(word['initial'] == source['initial'] and word['final'] == source['final'],
+         'Every public boundary is unchanged')
+    owned = lambda w: [e for e in w['program'] if e[1] >= w['public']]
+    need(owned(word) == owned(source), 'Every owned event is unchanged')
+    need(len(word['program']) == len(source['program']) == 25984, 'Fixed event count')
+    return word, {'start': plan['start'], 'roles': roles, 'transfer': matrix,
+                  'source_word_sha256': digest(source), 'word_sha256': digest(word),
+                  'old_events_sha256': digest(old), 'new_events_sha256': digest(new)}
diff --git a/research/p104-unread-path-resynthesis/inputs/pr5786-source.tar b/research/p104-unread-path-resynthesis/inputs/pr5786-source.tar
new file mode 100644
index 0000000000..a1f7e63c7d
Binary files /dev/null and b/research/p104-unread-path-resynthesis/inputs/pr5786-source.tar differ
diff --git a/research/p104-unread-path-resynthesis/inputs/pr5811-NOTICE b/research/p104-unread-path-resynthesis/inputs/pr5811-NOTICE
new file mode 100644
index 0000000000..bd91106cde
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/inputs/pr5811-NOTICE
@@ -0,0 +1,6 @@
+Composition of accumulated native updates and two released P104 blocks.
+New integration, compatibility checks and complete price: Mason Hale with substantial OpenAI Codex assistance, including separate agent checks. Apache-2.0. No independent human acceptance is claimed.
+
+The accumulation and retained-source lineage is credited verbatim in vendor/accumulated/NOTICE. The block constructions and composition lineage are credited verbatim in vendor/blocks/NOTICE. These notices and every retained source byte are unchanged. Ali Romman supplied PR5802 and PR5795; Joel Pulikkan/GamingPuzzled supplied the R22 mechanism; Ali Romman supplied the second block PR5796 and the provisional role92 plan. All native/helper/controller/compiler/BIT/analytic credit remains in the retained notices.
+
+Dugongue (@Dugongue), PR5806 at 20e7289b63d240715aa96006571ae38a46291d97, supplied a concurrent informal proof of the same three-accumulation/two-block baseline join. The fourth role92 realization is additional to that shared composition.
diff --git a/research/p104-unread-path-resynthesis/inputs/pr5811-PROOF.md b/research/p104-unread-path-resynthesis/inputs/pr5811-PROOF.md
new file mode 100644
index 0000000000..71a8c020a5
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/inputs/pr5811-PROOF.md
@@ -0,0 +1,219 @@
+# Compatibility and complete price of the accumulated-block composition
+
+This proof concerns a fixed composition of PR5802 and PR5795, including
+PR5796 through PR5795, followed by the separately released role92 accumulation.
+It introduces no elementary accumulation or block-reframing identity. The full final-word replay checks exact scalar/transpose compatibility, role92 mutation controls, all 2919 distinct native maps with absolute phase, 1124 helper normalizers, 208 main adapters, the complete physical caller and the interval-price/compiler/outer calculation. Every
+multiplication-exponent conclusion retains the five assumptions in Section 6.
+
+## 1. Exact sources and the two-block intermediate
+
+Let W be PR5802's word at
+`9bab1ca917ec4d1a4e60f4eb8c81d7ef92908a62`. Its three accumulation steps are
+already present. Block plans and the constructor are PR5795 at
+`206cb717c0c07737d61637b93f7502ca48850348`, containing R22 edits from PR5739
+at `b93d749a0a895d260e87887170af5162bda461a4` and the second-block plan from
+PR5796 at `4b30391e633ba0c7c674f03586ae97d443e9bc9c`.
+
+The block constructor is applied to W with its exact owned-label assertion
+adapted from 25 to 28. This acknowledges W's existing buffers; the block stage
+adds none. All eight R22 old runs match uniquely and their intervals are
+disjoint. Endpoint joins are checked against their old charts. Existing chart
+1090 is reused only after verifying its exact basis `[265,194,164,75]`.
+
+The second block matches the released 90-operation and 12-operation scalar
+runs on roles 57,81,92,224,225,227,229,234,742. Their 102 operations move from
+chart 267 to new chart 1092, basis `[11,21,38,448]`; helper 742 starts and helper
+225 ends there. Existing chart 1091 has basis `[11,21,51,469]` and is retained.
+The constructor records 16 required native-edge changes, preserving earlier
+edges in query chains and every unrelated query's order.
+
+Call this intermediate V. It has 25,982 events and canonical JSON SHA256
+`99d30f1ad0861259378630443a0c430f147f6156a5443d1d1cb72a420a7e05c3`.
+The role92 step below is applied to V, not directly to the earlier source.
+
+## 2. Block compatibility and retained COPY values
+
+Decoded field values distinguish the logical state from its native encoding.
+In a common frame, ADD and SCALE induce the stated rational linear maps.
+A legal MOVE from encodings J_A to J_B must implement exactly J_B J_A^-1,
+including absolute phase. Scalar matrix equality alone does not prove this
+native obligation.
+
+For each R22 replacement, the old and new rational transfer matrices agree
+on the union of scalar operands. The largest is 9-by-9; the other nonempty
+scalar matrix is 2-by-2; the remaining edits contain only native moves. No
+replaced run contains COPY, INIT or CLEAR. Therefore, under the native-map
+obligation, each replacement preserves the complete decoded state at its exit
+for arbitrary entry values. Induction over the disjoint runs preserves the
+state at every outside observation and lifetime boundary.
+
+The second block preserves all scalar operands, coefficients and order. It
+changes common frames, their required native connections and the two stated
+helper boundaries. Its decoded scalar transfer is identical once those native
+maps are established. The entire ordered INIT/COPY/CLEAR subsequence equals
+that in W. All 23 source COPY operations retain their exact decoded payloads,
+including the thirteen retained native copies. No arbitrary public helper
+input is treated as a free zero. Exact forward replay on V covers all 798 coordinates and 636,804 coefficients.
+The separate reverse-chronological transpose check is run on the final word below.
+
+## 3. Realizing the released role92 plan after composition
+
+The [released plan](https://github.com/CrocSwap/integer-mult-bounds/discussions/5645#discussioncomment-19205168)
+was discovery evidence on exact PR5786, canonical word SHA256
+`45e3f8efd004f2a6d2c02a2ac2ebe3dd9ce04c887641ec9ab31e47f8c7f41e1b`.
+Its event and chart-node indices cannot be copied blindly to V. The remapping
+matches the actual scalar observations by operands and coefficients. Old node
+824 splits into nodes 824 and 1637, and old node 2002 becomes 2008; all other
+selected nodes keep their indices. Both pieces of node 824 are included. The
+resulting changed-node set is
+
+```text
+742,753,754,755,761,823,824,825,826,827,828,829,830,1637,2008.
+```
+
+The six source observations move from indices
+`12850,12852,12854,12856,12858,12860` to
+`12856,12858,12860,12862,12864,12866` in V. They add, with coefficient +1,
+the current values of roles `63,61,103,18,45,108` to destination 92. These are
+values at their actual observation times, not assumed unchanged initial inputs.
+
+The declared nodes are assigned anchor chart 1091. Let A be chart 267,
+with basis `[1,4,10,16,34,64,128,256]`, and B be chart 1091. Exact subspace
+checks give B⊂A, with dimensions 4 and 8 respectively. The literal constructor
+verifies all common scalar frames and nested directions after this chart
+change. It also checks that between the first and last selected additions:
+no ADD/COPY reads destination 92, and every operation writing that destination
+is one of the six declared additions. A MOVE, SCALE, INIT, CLEAR or undeclared
+write of that destination would fail the same contract.
+
+Introduce owned role 798, initialized to zero in A. Replace the six additions
+by additions to that buffer at the same observation times. After the last,
+pay its rank-four native MOVE A→B, add it to role 92 in B, and CLEAR it in B.
+The buffer contains the exact sum of the six observed values. Until delivery,
+role 92 differs by the pending sum, but that difference is unobservable because
+of the checked read barrier. Every other decoded value agrees by induction.
+Delivery restores role 92 before any later read. The new buffer's erasure is
+explicitly charged under the retained owned-erasure assumption.
+
+The final overlay includes frame changes inside the intermediate block region;
+its validity is not inferred from the intermediate's old physical maps.
+Every new map and phase must be replayed. All 83 old lifecycle opcodes, roles and coefficients remain; their charts may refit,
+and a separately computed trace confirms all 23 COPY payloads. The final word
+has 25,984 events, 770 arbitrary public inputs, 29 owned labels, 31 lifetimes
+and peak 13 live owned fields. It fits the unchanged 26,000-event and 1,000-slot
+caps. The one explicit local checker capacity adaptation is `owned <= 28` to
+`owned <= 29`; scalar allowance is recomputed as 225038. All other checks are
+retained. Forward and separate dense transpose checks cover 799 coordinates
+and 638,401 coefficients. Nine controls reject missing sum components/query,
+delivery or CLEAR, an unallocated buffer, wrong sign, stale helper boundary,
+an undeclared pending write and an early destination read.
+
+The final canonical word SHA256 is
+`a06445539ad73fe16deae66fef8c52ffc39f5f14c765eab3dc3d98e0e2d8074c`.
+The literal plan is ROLE92-PLAN.json. HUNKS.json binds both intermediate and final canonical hashes. These hashes include the package schema strings; the earlier scratch receipts used predecessor schema names.
+
+## 4. Local signs and complete caller invoice
+
+Write H_r(t)=r^t. The final local profiles are
+
+| Kind | Exact profile |
+|---|---|
+| Paid | 2226H1 +456H2 +498H3 +99H4 +162H5 +9H6 +6H7 |
+| Helpers | 18H1 +7H2 +4H3 +107H4 +14H5 +9H7 +18H8 +385H9 |
+
+For the block stage alone, direct recount relative to W gives
+
+\[
+\Delta P_B=2H_1+2H_4-2H_5,\qquad
+\Delta T_B=-2H_1+2H_4+2H_5-2H_8.
+\]
+
+Thus its signed gain is `g(t)=-4+4·5^t−2·8^t`. It is not positive on all
+`0<t<1`: g(0)=-2 and g(1)=0. Exact outward log/power bounds give
+`g'(t) < −0.8479` throughout `[0.9966,1]`.
+Consequently g(t)>0 for `0.9966≤t<1`, including the working exponent.
+
+For the role92 overlay, the independently recounted changes relative to V are
+
+\[
+\Delta P_R=-5H_1-H_4+5H_5,\qquad
+\Delta T_R=-4H_1+4H_5.
+\]
+
+Its gain is `H1+H4−H5`, strictly positive for `0<t<1` since
+`(1+4)^t<1+4^t`. Paid local call count falls by one and helper count stays
+fixed. Both rank masses increase by 16, leaving their difference unchanged;
+the final local paid rank mass is 5934. In particular, the four changed helper
+targets and all their new rank-five credit are accounted for explicitly.
+
+Let P_0 and T_0 be the final local moments above. The full p16/a7 caller has
+
+\[
+P=18P_0+1560H_1+
+208\sum_{\ell\in\{7,8\}}\sum_{j=1}^{\ell}H_{8(j+1)},
+\]
+\[
+T=18T_0+208H_{145}+
+208\sum_{\ell\in\{7,8\}}\sum_{j=1}^{\ell}H_{1+8(j+1)}.
+\]
+
+This retains 18 local invocations, 15 query shears and 3,120 whole idle jobs.
+The result is 66,888 paid calls, 13,444 productive targets and rank-mass surplus
+760. The full paid rank mass is R=239828 and the full productive rank mass
+is 240588. The global precision envelope uses this full R, distinct from the
+local paid rank mass 5934. Relative to PR5802, the signed moment gain is
+`18·(−3H1+H4+3H5−2H8)`. Every scalar, owned, native, route, normalizer,
+adapter and compiler charge still needs the actual physical caller ledger.
+
+The separate `check_total_gain.py` recounts the actual word and the complete
+invoice, authenticates all source bytes, and proves the total gain positive
+throughout `0.9966≤t<1` using only rational atanh-series log enclosures and
+`exp(-x)≥1-x`. Its derivative upper bound is less than −3.34908. Four
+corrupt receipt controls reject omitted paid work, stale rank mass, a wrong
+source head and a missing lifetime. This check complements the native replay.
+
+## 5. Exact price and funded outer parameters
+
+Define `F(k)=T(1−k)−P(1−k)`. Two rational interval implementations enclose the
+same complete moments. Strict opposite endpoint signs give the raw crossing
+
+\[
+(0.00312418633663374,\ 0.00312418633663375).
+\]
+
+An exact negative derivative upper bound throughout `0≤k≤0.0034` proves
+uniqueness in the retained admitted BIT range. The reserve margin
+`(1−10^-12)T(1−k)−P(1−k)` is also strictly decreasing.
+Its largest permitted tested `1e-14`-grid point is `0.00312418633564`; the next
+point fails the reserve. Deducting the retained `5e-12` gap gives
+
+\[
+\kappa=0.00312418633064.
+\]
+
+The gain over PR5802's published value is exactly `0.00000082576064`.
+This is a fixed-invoice, fixed-reserve calculation, not an optimum over other
+words, parameters or BIT suppliers.
+
+The pricing receipt checks cutoff 16, completion floor 17, offset 1/7, power
+1024, decay 125/128, tail block 128, strict splitting/rounding margins and the
+finite compiler threshold `H=80511200000000000`. All 54 strict outer
+inequalities and four functional conditions are positive. The nonrecursive allowance uses all 31 owned lifetimes for routes, peak 13 live owned fields, 225038 scalar primitives and paid local rank mass 5934. Allocating 29 labels is below the retained 1000-slot allowance; the physical caller and ownership checks use the actual word. This funds the
+compiler parameters under the retained compiler hypothesis; it does not
+materialize the enormous uniform word or rounded integer multiplier.
+
+## 6. Scope and attribution
+
+The five retained assumptions are `native_all_columns`, `owned_erasure`,
+`compiler`, `precision_tape` and `analytic_recovery`. The final-word native-phase, physical-caller and complete-price checks pass as author evidence within that conditional framework; this is not maintainer admission. Neither independent
+human review nor formal-kernel verification is claimed. The selected repository
+record is unchanged. General mixed-payload factorization and other active
+construction searches are outside this fixed plan.
+
+Ali Romman supplied PR5802, PR5795, PR5796, the original provisional role92
+plan and the retained-copy/hub lineage. Joel Pulikkan/GamingPuzzled supplied R22.
+Retain flyingviper, Cinna Davis, Jacob Alan Sussman, zxv, Cao Yifan and every
+predecessor native/helper/controller/compiler/BIT notice. Mason Hale's new work
+is the exact-source composition, role92 remapping, compatibility proof and
+complete repricing, with substantial OpenAI Codex and separate-agent
+assistance. The elementary identities retain their source credit. Apache-2.0.
diff --git a/research/p104-unread-path-resynthesis/inputs/pr5811-RESULT.json b/research/p104-unread-path-resynthesis/inputs/pr5811-RESULT.json
new file mode 100644
index 0000000000..2e73d97bdd
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/inputs/pr5811-RESULT.json
@@ -0,0 +1,623 @@
+{
+  "block_gain_range": {
+    "derivative_upper": "-2088075372472358500144910514320093593541331494844428204945956909409484756502923673062666167617282598997200338060631/2462625387274654950767440006258975862817483704404090416746768337765357610718575663213391640930307227550414249394176",
+    "exponent_interval": [
+      "4983/5000",
+      1
+    ],
+    "scope": "Strict gain for 1-.0034 <= t < 1; not a claim for every 0<t<1.",
+    "signed_gain_per_local": {
+      "1": -4,
+      "5": 4,
+      "8": -2
+    }
+  },
+  "canonical_word_sha256": "a06445539ad73fe16deae66fef8c52ffc39f5f14c765eab3dc3d98e0e2d8074c",
+  "complete_cost": {
+    "compiler": {
+      "H": 80511200000000000,
+      "N": "2^80511200000000000",
+      "eta": {
+        "lower": "0.000000121356847790484452657273",
+        "upper": "0.000000121356847790484452657274"
+      },
+      "gap": "1/1400000000000",
+      "integer_test_exponent": 57508,
+      "logarithm_power": 1024,
+      "theta": "63/64",
+      "uniform_saving": "136683152153/43750000000000",
+      "word_materialized": false
+    },
+    "full_forward_calls": 18,
+    "gain": "1290251/1562500000000",
+    "kappa": "39052329133/12500000000000",
+    "kappa_decimal": "0.00312418633064",
+    "margin_at_previous": {
+      "lower": "0.199537704093038969664436722064",
+      "upper": "0.199537704093038969664436722065"
+    },
+    "negative_controls": {
+      "old_BIT": "Rejected by outer inequalities",
+      "old_cutoff": "Rejected by completion-tail ratio greater than one",
+      "source_completion": "Rejected at cutoff17, floor18 and decay39/40",
+      "source_offset": "Rejected at cutoff16 with tail offset1/5"
+    },
+    "nonrecursive": {
+      "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.",
+      "local_paid_rank_mass": 5934,
+      "local_routes": 5328000,
+      "local_scalar": 225038,
+      "peak_owned_fields": 13,
+      "raw_budget": 1000000000,
+      "raw_scalar_upper": 184647552,
+      "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word."
+    },
+    "ordinary_BIT": {
+      "admitted": "17/5000",
+      "after_cover": "69/20000",
+      "atom": "1/250",
+      "before_cover": "3459/1000000",
+      "ordinary_saving": "8590884599/2500000000000",
+      "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses"
+    },
+    "outer": {
+      "functional_checks": {
+        "actual_new_BIT_stock_sublinear": "348599999999253/350000000000000",
+        "fixed_halo_explicit_metadata_branch": "26950000000001/350000000000",
+        "new_BIT_row_stock_sublinear_in_active_group": "1395799999997009/1400000000000000",
+        "new_semantic_group_guard": "3/1400000000000"
+      },
+      "margins": {
+        "boundary_algebraic_matrix": "765425651706253267391763/245000000000000000000000000",
+        "fused_gaussian": "765425651705159802175289/245000000000000000000000000",
+        "global_coordinate_router": "273366304181/87500000000000",
+        "group_bit_router": "382712825940079901087457/122500000000000000000000000",
+        "group_scans": "699999999999/700000000000",
+        "main_transform": "765425651531253267391763/245000000000000000000000000",
+        "microbox_face_corrections": "26950000000001/350000000000",
+        "polynomial_products": "1399999999999/1400000000000",
+        "sparse_union_movement": "100296675651706253267391763/245000000000000000000000000"
+      },
+      "parameters": {
+        "a": "273366304181/87500000000000",
+        "b": "546732608487/175000000000000",
+        "beta": "1399999999997/1400000000000",
+        "bit_saving": "17/5000",
+        "cap_xi": "222796675651531253267391763/245000000000000000000000000",
+        "complex_uniform_saving": "136683152153/43750000000000",
+        "d": "1/1400000000000",
+        "epsilon": "1399999999999/1400000000000",
+        "kappa": "39052329133/12500000000000",
+        "lambda_": "49843790683343/50000000000000",
+        "lambda_prime": "174453267391763/175000000000000",
+        "layout": "1/1400000000000",
+        "q": "546732608237/175000000000000",
+        "r0": "1/14000000000000",
+        "stop": "1/1400000000000",
+        "tested_saving": "78104658391/25000000000000"
+      },
+      "strict_checks": {
+        "actual_bit_above_effective": "24133695819/87500000000000",
+        "actual_logarithmic_gamma_guard": "1/1400000000000",
+        "actual_logarithmic_group_guard": "22203324348731246732608237/122500000000000000000000000",
+        "alpha_logarithm_absorption": "1/14000000000000",
+        "boundary_algebraic_matrix_above_kappa": "699453267391763/245000000000000000000000000",
+        "cap_above_band": "100296675651531253267391763/245000000000000000000000000",
+        "cap_below_cell": "22203324348293746732608237/245000000000000000000000000",
+        "cap_below_phase_cell_power": "267203324348468746732608237/245000000000000000000000000",
+        "complex_above_effective": "1/1400000000000",
+        "complex_below_one_over_32": "4922017391513/175000000000000",
+        "complex_endpoint": "1/700000000000",
+        "epsilon_below_one": "1/1400000000000",
+        "epsilon_positive": "1399999999999/1400000000000",
+        "fine_prime_halo_umbrella": "7/2",
+        "fused_gaussian_above_kappa": "698359802175289/245000000000000000000000000",
+        "gaussian_above_main": "86953267391763/122500000000000000000000000",
+        "global_coordinate_router_above_kappa": "1/350000000000",
+        "global_gamma_power_slack": "9/14000000000000",
+        "group_below_dimension": "1/700000000000",
+        "group_bit_router_above_kappa": "436679901087457/122500000000000000000000000",
+        "group_gauge_power_slack": "22203324348722496732608237/122500000000000000000000000",
+        "group_key_fits_record": "1/700000000000",
+        "group_positive": "1399999999997/1400000000000",
+        "group_scans_above_kappa": "10903329211993/10937500000000",
+        "halo_covers_generic_inverse_radius": "5",
+        "improvement_over_user_baseline": "696607955720418148631/500000000000000000000000",
+        "lambda_above_internal": "1/2800000000000",
+        "lambda_above_sigma": "3/2800000000000",
+        "lambda_above_tau": "1/2800000000000",
+        "lambda_prime_above_lambda": "1/2800000000000",
+        "lambda_prime_above_leaf": "349453267391513/245000000000000000000000000",
+        "leaf_saving_above_effective": "174453267391513/245000000000000000000000000",
+        "main_transform_above_kappa": "524453267391763/245000000000000000000000000",
+        "membership_arithmetic_fits_record": "1/1400000000000",
+        "microbox_face_corrections_above_kappa": "6737226633696319/87500000000000",
+        "microbox_halo_volume": "110600000000003/1400000000000",
+        "new_complex_uniform_saving_above_b": "1/1400000000000",
+        "new_semantic_guard_with_C1_one": "1/1400000000000",
+        "polynomial_products_above_kappa": "174453267392013/175000000000000",
+        "positive_layout_slack": "1/1400000000000",
+        "q_below_effective": "1/1400000000000",
+        "q_below_internal": "1/1400000000000",
+        "q_below_leaf": "349453267391513/245000000000000000000000000",
+        "q_positive": "546732608237/175000000000000",
+        "short_record_fallback": "174453267391513/175000000000000",
+        "source_axis_superpolynomial": "1/1400000000000",
+        "sparse_union_movement_above_kappa": "99531250000699453267391763/245000000000000000000000000",
+        "stop_below_one": "1399999999999/1400000000000",
+        "stop_positive": "1/1400000000000",
+        "strassen_integer_power_gap": "1951441519231",
+        "support_router_span": "3/1400000000000",
+        "theta_positive_polynomial_power": "2",
+        "union_header_fits_record": "3/1400000000000",
+        "union_tag_work_per_visit_fits_record": "3/1400000000000"
+      }
+    },
+    "paid": {
+      "1": 41628,
+      "16": 416,
+      "2": 8208,
+      "24": 416,
+      "3": 8964,
+      "32": 416,
+      "4": 1782,
+      "40": 416,
+      "48": 416,
+      "5": 2916,
+      "56": 416,
+      "6": 162,
+      "64": 416,
+      "7": 108,
+      "72": 208
+    },
+    "paid_calls": 66888,
+    "previous_pr5802": "312336057/100000000000",
+    "productive_fields": 13444,
+    "query_shears": 15,
+    "rank_mass_surplus": 760,
+    "raw_ceiling": {
+      "derivative_upper": "-368004547164861935742362936408609606941810029632377908485755891/1569275433846670190958947355801916604025588861116008628224",
+      "interval": [
+        "0",
+        "17/5000"
+      ]
+    },
+    "raw_headroom": [
+      "299687/50000000000000000",
+      "959/160000000000000"
+    ],
+    "raw_root_interval": [
+      "156209316831687/50000000000000000",
+      "2499349069307/800000000000000"
+    ],
+    "relative_gain_percent": "41288032/1561680285",
+    "strictification": {
+      "alpha": {
+        "lower": "0.999999999998991159042549078461",
+        "upper": "0.999999999998991159042549078462"
+      },
+      "cutoff": 16,
+      "delta": {
+        "lower": "0.951912788985453393366376508390",
+        "upper": "0.951912788985453393366376508391"
+      },
+      "floor": 17,
+      "gamma": {
+        "lower": "0.975585774172635067187356074439",
+        "upper": "0.975585774172635067187356074440"
+      },
+      "normalized_paid_upper": "1048576000976562501/1048576001073741824",
+      "power": 1024,
+      "reserve": "1/1000000000000",
+      "tail_block": 128,
+      "tail_decay": "125/128",
+      "tail_offset": "1/7",
+      "tested": "78104658391/25000000000000"
+    },
+    "targets": {
+      "1": 324,
+      "145": 208,
+      "17": 416,
+      "2": 126,
+      "25": 416,
+      "3": 72,
+      "33": 416,
+      "4": 1926,
+      "41": 416,
+      "49": 416,
+      "5": 252,
+      "57": 416,
+      "65": 416,
+      "7": 162,
+      "73": 208,
+      "8": 324,
+      "9": 6930
+    },
+    "whole_idle_jobs": 3120
+  },
+  "delta": {
+    "helpers": {
+      "1": -6,
+      "4": 2,
+      "5": 6,
+      "8": -2
+    },
+    "paid": {
+      "1": -3,
+      "4": 1,
+      "5": 3
+    }
+  },
+  "fixed_contract_grid_optimum": {
+    "accepted_margin": [
+      "25799237784018095798006296795183910842206069778194909403381/12259964326927110866866776217202473468949912977468817408000000000000",
+      "3302302436354316262144805989783540587802431539234948370961353/1569275433846670190958947355801916604025588861116008628224000000000000"
+    ],
+    "cap": "17/5000",
+    "derivative_upper": "-736009094327164435617549354859802318584324493733667377004241150850439699091/3138550867693340381917894711603833208051177722232017256448000000000000",
+    "grid": "1/100000000000000",
+    "largest_published_grid": "39052329133/12500000000000",
+    "largest_tested_grid": "78104658391/25000000000000",
+    "next_tested_grid": "62483726713/20000000000000",
+    "rejected_margin": [
+      "-195871060919199761433772328589248798766437569834401224579047/627710173538668076383578942320766641610235544446403451289600000000000",
+      "-244838826148999701792215410736560998458019814094501546915829/784637716923335095479473677900958302012794430558004314112000000000000"
+    ],
+    "reserve": "1/1000000000000",
+    "scope": "Maximum on the 1e-14 grid for this exact profile, fixed reserve and tested gap. Different compiler parameters, words and BIT caps remain outside this claim.",
+    "tested_gap": "1/200000000000"
+  },
+  "instructions": 25984,
+  "intermediate_local": {
+    "endpoint_coefficients": 636804,
+    "helpers": {
+      "1": 22,
+      "2": 7,
+      "3": 4,
+      "4": 107,
+      "5": 10,
+      "7": 9,
+      "8": 18,
+      "9": 385
+    },
+    "owned_fields": 28,
+    "owned_lifetimes": 30,
+    "paid": {
+      "1": 2231,
+      "2": 456,
+      "3": 498,
+      "4": 100,
+      "5": 157,
+      "6": 9,
+      "7": 6
+    },
+    "paid_rank_mass": 5918,
+    "peak_owned_fields": 13,
+    "public_inputs": 770,
+    "real_scalar_allowance": 225026
+  },
+  "limits": [
+    "Five inherited framework assumptions remain.",
+    "The large uniform word and rounded multiplier are not materialized.",
+    "Author-side and agent checks are not independent human or kernel acceptance.",
+    "The selected frontier is unchanged."
+  ],
+  "local": {
+    "endpoint_coefficients": 638401,
+    "helpers": {
+      "1": 18,
+      "2": 7,
+      "3": 4,
+      "4": 107,
+      "5": 14,
+      "7": 9,
+      "8": 18,
+      "9": 385
+    },
+    "owned_fields": 29,
+    "owned_lifetimes": 31,
+    "paid": {
+      "1": 2226,
+      "2": 456,
+      "3": 498,
+      "4": 99,
+      "5": 162,
+      "6": 9,
+      "7": 6
+    },
+    "paid_rank_mass": 5934,
+    "peak_owned_fields": 13,
+    "public_inputs": 770,
+    "real_scalar_allowance": 225038
+  },
+  "native": {
+    "distinct_maps": 2919,
+    "helper_normalizers": 1124,
+    "helpers": {
+      "1": 18,
+      "2": 7,
+      "3": 4,
+      "4": 107,
+      "5": 14,
+      "7": 9,
+      "8": 18,
+      "9": 385
+    },
+    "main_adapters": 208,
+    "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width",
+    "recipe_payload_sha256": "02ed1876119efe8e114384d9e5abf23b9f2ba9579034bbc5cd1b7f8edb6d6809",
+    "wrong_phase_rejected": true
+  },
+  "negative_controls": {
+    "accumulation_clear_before_delivery": "Common scalar chart",
+    "accumulation_omit_buffer_clear": "All public and owned exits",
+    "accumulation_omit_owned_storage": "Role index",
+    "accumulation_omit_paid_sum_query": "Common scalar chart",
+    "accumulation_omit_sum_component": "All public and owned rows",
+    "accumulation_omit_sum_delivery": "All public and owned rows",
+    "accumulation_read_before_delivery": "Destination is not read before the sum is delivered",
+    "accumulation_retain_old_target_credit": "All public and owned exits",
+    "accumulation_wrong_delivery_sign": "All public and owned rows",
+    "block_omit_R22_input_endpoint": "Scalar destination and coefficient",
+    "block_omit_copy_clear": "All public and owned exits",
+    "block_omit_paid_R22_query": "Common scalar chart",
+    "block_omit_paid_copy_query": "Common scalar chart",
+    "block_omit_second_block_input": "Scalar destination and coefficient",
+    "block_omit_second_block_output": "All public and owned exits",
+    "block_omit_second_block_query": "Scalar destination and coefficient",
+    "block_retain_old_R22_target": "All public and owned exits",
+    "block_wrong_copy_value": "All public and owned rows",
+    "caller_missing_central_translation": "Rejected by the complete Laurent endpoint",
+    "invent_productive_credit": "Every productive helper has a native target",
+    "omit_paid_query_from_invoice": "Complete field and call counts",
+    "role92_early_destination_read": "Destination is not read before the sum is delivered",
+    "role92_old_helper_boundary": "Scalar destination and coefficient",
+    "role92_omit_clear": "All public and owned exits",
+    "role92_omit_component": "All public and owned rows",
+    "role92_omit_delivery": "All public and owned rows",
+    "role92_omit_query": "Common scalar chart",
+    "role92_unallocated_storage": "Role index",
+    "role92_undeclared_update": "Only the declared pending additions",
+    "role92_wrong_delivery_sign": "All public and owned rows"
+  },
+  "physical_caller": {
+    "central_square_columns": 53248,
+    "full_calls": 18,
+    "main_targets": {
+      "145": 208,
+      "17": 416,
+      "25": 416,
+      "33": 416,
+      "41": 416,
+      "49": 416,
+      "57": 416,
+      "65": 416,
+      "73": 208
+    },
+    "new_paid_jobs": 0,
+    "physical_contacts": 7488,
+    "ports": 104,
+    "route_payload_sha256": "7f4f0ca768ffbc4f93dcff575592c4c67411f46b4289e45b73f715a2ad47b142",
+    "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.",
+    "whole_idle_jobs": {
+      "16": 416,
+      "24": 416,
+      "32": 416,
+      "40": 416,
+      "48": 416,
+      "56": 416,
+      "64": 416,
+      "72": 208
+    },
+    "wrapper_sites": [
+      1,
+      3,
+      5,
+      7,
+      9,
+      11,
+      13,
+      15,
+      17,
+      19,
+      21,
+      23,
+      25,
+      27,
+      29,
+      31
+    ]
+  },
+  "role92_compatibility": {
+    "copied_values_sha256": "f70e3fc94282e11e6b2a6629b25cd29394ef1d77d512a8f3b777df927856b228",
+    "delta_helpers": {
+      "1": -4,
+      "5": 4
+    },
+    "delta_paid": {
+      "1": -5,
+      "4": -1,
+      "5": 5
+    },
+    "gain_proof": "Strict subadditivity: 1^t+4^t>5^t for every 0<t<1.",
+    "local_signed_gain": {
+      "1": 1,
+      "4": 1,
+      "5": -1
+    },
+    "new_lifetime": [
+      [
+        12855,
+        [
+          "INIT",
+          798,
+          267
+        ]
+      ],
+      [
+        12856,
+        [
+          "ADD",
+          798,
+          63,
+          "1",
+          267
+        ]
+      ],
+      [
+        12858,
+        [
+          "ADD",
+          798,
+          61,
+          "1",
+          267
+        ]
+      ],
+      [
+        12860,
+        [
+          "ADD",
+          798,
+          103,
+          "1",
+          267
+        ]
+      ],
+      [
+        12862,
+        [
+          "ADD",
+          798,
+          18,
+          "1",
+          267
+        ]
+      ],
+      [
+        12864,
+        [
+          "ADD",
+          798,
+          45,
+          "1",
+          267
+        ]
+      ],
+      [
+        12866,
+        [
+          "ADD",
+          798,
+          108,
+          "1",
+          267
+        ]
+      ],
+      [
+        12867,
+        [
+          "MOVE",
+          798,
+          267,
+          1091,
+          true
+        ]
+      ],
+      [
+        12868,
+        [
+          "ADD",
+          92,
+          798,
+          "1",
+          1091
+        ]
+      ],
+      [
+        12869,
+        [
+          "CLEAR",
+          798,
+          1091
+        ]
+      ]
+    ],
+    "owned_fields": 29,
+    "owned_lifetimes": 31,
+    "peak_owned_fields": 13,
+    "prior_lifecycle_events": 83,
+    "public_inputs": 770
+  },
+  "separate_columns": {
+    "arithmetic": "Dense integer rows with binary denominators; reverse chronology",
+    "coefficients": 638401,
+    "columns": 799
+  },
+  "source_authentication": {
+    "files": 33,
+    "source_manifest_sha256": "ac35efbe8a77537fd182d976a92e81955d3ae30988a8049624387c6d36a80903"
+  },
+  "source_commits": {
+    "accumulated": "9bab1ca917ec4d1a4e60f4eb8c81d7ef92908a62",
+    "blocks": "206cb717c0c07737d61637b93f7502ca48850348"
+  },
+  "source_local": {
+    "endpoint_coefficients": 636804,
+    "helpers": {
+      "1": 24,
+      "2": 7,
+      "3": 4,
+      "4": 105,
+      "5": 8,
+      "7": 9,
+      "8": 20,
+      "9": 385
+    },
+    "owned_fields": 28,
+    "owned_lifetimes": 30,
+    "paid": {
+      "1": 2229,
+      "2": 456,
+      "3": 498,
+      "4": 98,
+      "5": 159,
+      "6": 9,
+      "7": 6
+    },
+    "paid_rank_mass": 5918,
+    "peak_owned_fields": 13,
+    "public_inputs": 770,
+    "real_scalar_allowance": 225026
+  },
+  "source_protected_contacts": {
+    "copy_events": 23,
+    "copy_value_sha256": "f70e3fc94282e11e6b2a6629b25cd29394ef1d77d512a8f3b777df927856b228",
+    "event_sha256": "4a3c28d1234a6812109488b9a5597fd878f44b25ab624b74db4fe4188c5af322",
+    "events": 1704,
+    "roles": [
+      41,
+      42,
+      57,
+      65,
+      81,
+      92,
+      106,
+      224,
+      225,
+      227,
+      229,
+      234,
+      240,
+      400,
+      401,
+      403,
+      405,
+      410,
+      741,
+      742
+    ],
+    "scope": "Protected events and boundaries stay fixed. COPY frames can change; all COPY roles, coefficients and exact decoded values stay fixed."
+  },
+  "status": "PASS_P104_ACCUMULATED_BLOCK_COMPOSITION"
+}
diff --git a/research/p104-unread-path-resynthesis/inputs/pr5811-WORD.json.gz b/research/p104-unread-path-resynthesis/inputs/pr5811-WORD.json.gz
new file mode 100644
index 0000000000..3633d78556
Binary files /dev/null and b/research/p104-unread-path-resynthesis/inputs/pr5811-WORD.json.gz differ
diff --git a/research/p104-unread-path-resynthesis/local.py b/research/p104-unread-path-resynthesis/local.py
new file mode 100644
index 0000000000..b7be846b10
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/local.py
@@ -0,0 +1,208 @@
+"""Check the complete P104 word with an independent helper inventory.
+
+Adapted from Ali Romman's PR5544/5545. David Arias supplied the word;
+Cinna Davis supplied private reuse; Gareth Davidson supplied composition.
+Prepared by Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+"""
+from collections import Counter
+from fractions import Fraction as Q
+from functools import lru_cache
+from hashlib import sha256
+from pathlib import Path
+import gzip
+import importlib.util
+import json
+import sys
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+
+def need(ok, why):
+    if not ok:
+        raise ValueError(why)
+
+def read(path):
+    raw = path.read_bytes()
+    return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw)
+
+def load(path, name):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+def add(dst, src, q):
+    for k, v in tuple(src.items()):
+        value = dst.get(k, 0) + q*v
+        if value:
+            dst[k] = value
+        else:
+            dst.pop(k, None)
+
+def span(basis):
+    out = {0}
+    for v in basis:
+        need(type(v) is int and 0 < v < 512 and v not in out, 'Independent binary basis')
+        out |= {x ^ v for x in tuple(out)}
+    return frozenset(out)
+
+def replay(w):
+    public = w['public']
+    owned = w.get('owned_fields', 8)
+    need(type(owned) is int and 8 <= owned <= 29, 'Owned inventory bound')
+    need(type(public) is int and 767 <= public <= 770, 'Public inventory bound')
+    need(len(w['initial']) == len(w['final']) == public, 'Public boundary size')
+    need(len(w['program']) < 26000, 'Fixed operation bound')
+    frames = [span(x) for x in w['frames']]
+    rows = [{r:Q(1)} for r in range(public+owned)]
+    current = list(w['initial']) + [None]*owned
+    paid, scalar, live_owned, peak = Counter(), 0, set(), 0
+    lifetimes = 0
+    for e in w['program']:
+        op, r = e[:2]
+        need(0 <= r < public+owned, 'Role index')
+        if op == 'MOVE':
+            _, r, a, b, private = e
+            need(current[r] == a and (r in live_owned) == private, 'Transport source and ownership')
+            need(frames[b] < frames[a] if private else frames[a] < frames[b], 'Nested chronological transport')
+            paid[abs(len(w['frames'][b])-len(w['frames'][a]))] += 1
+            current[r] = b
+        elif op == 'INIT':
+            need(r >= public and r not in live_owned, 'Owned initialization')
+            live_owned.add(r)
+            lifetimes += 1
+            peak = max(peak, len(live_owned))
+            rows[r] = {}
+            current[r] = e[2]
+            scalar += 2
+        elif op == 'CLEAR':
+            need(r in live_owned and current[r] == e[2], 'Owned erasure at declared frame')
+            rows[r] = {}
+            current[r] = None
+            live_owned.remove(r)
+            scalar += 2
+        else:
+            q, f = Q(e[-2]), e[-1]
+            need(q and current[r] == f, 'Scalar destination and coefficient')
+            n, d = abs(q.numerator), q.denominator
+            need(d & (d-1) == 0, 'Dyadic scalar coefficient')
+            need(abs(q)+1 < 2**16, 'Fixed scalar growth bound')
+            if op == 'SCALE':
+                need(n & (n-1) == 0, 'Dyadic unit SCALE')
+                rows[r] = {k:q*x for k,x in rows[r].items()}
+                scalar += 2*(abs(n.bit_length()-d.bit_length()) + int(q < 0))
+            else:
+                s = e[2]
+                need(s != r and 0 <= s < public+owned and current[s] == f, 'Common scalar chart')
+                if op == 'COPY':
+                    need(r in live_owned and not rows[r], 'COPY into cleared owned field')
+                    rows[r] = {k:q*x for k,x in rows[s].items()}
+                else:
+                    need(op == 'ADD', 'Scalar opcode')
+                    add(rows[r], rows[s], q)
+                scalar += 2*(3+n.bit_length()-1+n.bit_count()+d.bit_length()-1)
+    need(not live_owned and 0 < peak <= 13 and current[:public] == w['final'], 'All public and owned exits')
+    live = set(w['live'])
+    for r,row in enumerate(rows):
+        expected = {r:Q(1)} if r < public else {}
+        if r-112 in live:
+            expected[r-112] = Q(1)
+        need(row == expected, 'All public and owned rows')
+    main = live | {r+112 for r in live}
+    helpers = Counter(len(w['frames'][w['final'][r]])-len(w['frames'][w['initial'][r]]) for r in range(public) if r not in main)
+    need(len(live) == len(w['ports']) == 104 and len(main) == 208 and min(helpers) > 0, 'Independent productive inputs')
+    return {'paid':dict(paid), 'helpers':dict(helpers), 'public_inputs':public, 'owned_fields':owned, 'owned_lifetimes':lifetimes,
+            'peak_owned_fields':peak, 'real_scalar_allowance':scalar, 'endpoint_coefficients':(public+owned)*(public+owned),
+            'paid_rank_mass':sum(r*count for r,count in paid.items())}
+
+def reverse_columns(w):
+    """Check the transpose with dense dyadic rows and the reverse chronology."""
+    public = w['public']
+    n = public+w.get('owned_fields', 8)
+    rows = [[int(i == j) for j in range(n)] for i in range(n)]
+    exponents = [0]*n
+    for e in reversed(w['program']):
+        op,r = e[:2]
+        if op == 'MOVE':
+            continue
+        if op in ('INIT','CLEAR'):
+            rows[r] = [0]*n
+            exponents[r] = 0
+            continue
+        q = Q(e[-2])
+        qe = q.denominator.bit_length()-1
+        if op == 'SCALE':
+            rows[r] = [q.numerator*x for x in rows[r]]
+            exponents[r] += qe
+        else:
+            s = e[2]
+            level = max(exponents[s], exponents[r]+qe)
+            a, b = 1 << (level-exponents[s]), q.numerator << (level-exponents[r]-qe)
+            rows[s] = [a*x+b*y for x,y in zip(rows[s],rows[r])]
+            exponents[s] = level
+            if op == 'COPY':
+                rows[r] = [0]*n
+                exponents[r] = 0
+            r = s
+        while exponents[r] and not any(x & 1 for x in rows[r]):
+            rows[r] = [x//2 for x in rows[r]]
+            exponents[r] -= 1
+    for r,row in enumerate(rows):
+        expected = [0]*n
+        if r < public:
+            expected[r] = 1 << exponents[r]
+        if r in w['live']:
+            expected[r+112] = 1 << exponents[r]
+        need(row == expected, 'Independent dense transpose columns')
+    return {'columns':n, 'coefficients':n*n, 'arithmetic':'Dense integer rows with binary denominators; reverse chronology'}
+
+def native(w):
+    n = w['public']
+    C = load(ROOT/'research/p104-native-channel/vendor/clifford_exact.py', 'p104_productive_clifford')
+    V = load(ROOT/'research/p104-native-channel/vendor/native_verify.py', 'p104_productive_gaussian')
+    @lru_cache(None)
+    def chart(i):
+        return C.canonical_frame(9, tuple(w['frames'][i]))
+    recipes = {}
+    def check(a,b):
+        if (a,b) not in recipes:
+            recipe,_ = C.lower_child(chart(a).adjoint().then(chart(b)))
+            expected = V.adjoint(V.frame(w['frames'][a],9)) + V.frame(w['frames'][b],9)
+            V.equal(V.recipe(recipe),expected,'Native chart change and exact global phase')
+            need(recipe['rank'] == abs(len(w['frames'][a])-len(w['frames'][b])), 'Native boundary rank')
+            recipes[a,b] = recipe
+        return recipes[a,b]
+    for e in w['program']:
+        if e[0] == 'MOVE':
+            check(e[2],e[3])
+    main = set(w['live']) | {r+112 for r in w['live']}
+    helper_profile = Counter()
+    for r in range(n):
+        if r not in main:
+            helper_profile[check(w['initial'][r],w['final'][r])['rank']] += 1
+    adapters = []
+    for r,q in zip(w['live'],w['ports']):
+        need(w['frames'][w['initial'][r]] == [q], 'Literal central port')
+        need(span(w['frames'][w['final'][r+112]]) == frozenset(x for x in range(512) if not (x&q).bit_count()%2), 'Literal output hyperplane')
+        tests = [
+            (C.cgate(9,q,1).adjoint().then(chart(w['initial'][r])), V.adjoint((('C',q,1),))+V.frame(w['frames'][w['initial'][r]],9)),
+            (chart(w['final'][r+112]).adjoint().then(C.cgate(9,q,-1).then(C.fourier(9))), V.adjoint(V.frame(w['frames'][w['final'][r+112]],9))+(('C',q,-1),)+V.fourier(9))]
+        for actual,expected in tests:
+            recipe,_ = C.lower_child(actual)
+            need(recipe['rank'] == 0, 'Free intrinsic main adapter')
+            V.equal(V.recipe(recipe),expected,'Main endpoint phase')
+            adapters.append(recipe)
+    bad = json.loads(json.dumps(next(iter(recipes.values()))))
+    bad['left']['phase'] = (bad['left']['phase']+1)%4
+    a,b = next(iter(recipes))
+    try:
+        V.equal(V.recipe(bad),V.adjoint(V.frame(w['frames'][a],9))+V.frame(w['frames'][b],9),'Wrong phase control')
+    except ValueError:
+        pass
+    else:
+        raise ValueError('Wrong native phase accepted')
+    payload = [[a,b,recipes[a,b]] for a,b in sorted(recipes)] + adapters
+    return {'distinct_maps':len(recipes),'main_adapters':len(adapters),'helper_normalizers':2*sum(helper_profile.values()),
+            'helpers':dict(helper_profile),'recipe_payload_sha256':sha256(json.dumps(payload,sort_keys=True,separators=(',',':')).encode()).hexdigest(),
+            'wrong_phase_rejected':True, 'proof':'Every signed Pauli image and exact global phase; frame induction at every positive tensor width'}
diff --git a/research/p104-unread-path-resynthesis/pricing.py b/research/p104-unread-path-resynthesis/pricing.py
new file mode 100644
index 0000000000..f288269461
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/pricing.py
@@ -0,0 +1,184 @@
+"""Complete mixed-target price, compiler and outer transfer.
+
+The interval and compiler bounds follow zxv and Cao Yifan. The productive
+recursion is by Jacob Alan Sussman. The controller is by Cinna Davis.
+Adapted from Ali Romman's PR5544/5545 for the two coupled contact changes.
+Successor choices were prepared for thu-nmrc with OpenAI Codex assistance.
+Helper-subspace targets were added by Ali Romman with OpenAI Codex assistance.
+The source commuting-contact construction is by Pierre-Loic Doulcet (hexapode) in PR5565.
+The source coupled-frame change is by Ali Romman with OpenAI Codex in PR5601.
+Five fixed boundary relations are from Ali Romman's PR5602.
+The shared and delayed relays are from flyingviper's PR5605 and PR5612. The preparation is from
+Scratch-net's PR5606. Their costs and target debit are included.
+Ali Romman's complete caller/price proof and all predecessor credit are retained.
+The paid A2 change is from zxv PR5643. The three helper relations are from
+Ali Romman PR5644. The four-gate change is by Ali Romman with Codex assistance.
+The four interior basis changes are by Ali Romman with Codex assistance.
+Paid intermediate meetings: Ali Romman with substantial OpenAI Codex assistance.
+Apache-2.0.
+"""
+from collections import Counter
+from fractions import Fraction as Q
+import local as L
+
+KAPPA, TESTED = Q('0.00312476680'), Q('0.003124766805')
+PREVIOUS = Q('0.00312418633064')
+
+
+def encode(x):
+    if isinstance(x,Q):
+        return str(x)
+    if isinstance(x,dict):
+        return {str(k):encode(v) for k,v in x.items()}
+    if isinstance(x,(list,tuple)):
+        return [encode(v) for v in x]
+    return x
+
+
+def assemble(local, native, word, physical):
+    paid, targets = Counter(), Counter()
+    counts = Counter()
+    L.need(local['helpers'] == native['helpers'], 'Every productive helper has a native target')
+    for e in word['physical_events']:
+        counts[e[0]] += 1
+        if e[0] == 'LOCAL':
+            L.need(e[3] is False, 'Every source invocation is forward')
+            paid.update(local['paid'])
+            targets.update(local['helpers'])
+        elif e[0] == 'QUERY_SHEAR':
+            paid[1] += 104
+        elif e[0] == 'IDLE':
+            paid[8*len(e[2])] += 208
+    main = Counter()
+    idle = Counter({8*len(e[2]):0 for e in word['physical_events'] if e[0] == 'IDLE'})
+    for e in word['physical_events']:
+        if e[0] == 'IDLE':
+            idle[8*len(e[2])] += 208
+    L.need(idle == physical['whole_idle_jobs'], 'Every whole idle has a native Gaussian and full rank')
+    for term in word['diagonal']:
+        main[1+8*sum(term[1:])] += 104
+    L.need(main == physical['main_targets'], 'Every main target has its full native phase')
+    targets.update(main)
+    L.need(counts['LOCAL'] == 18 and counts['QUERY_SHEAR'] == counts['IDLE'] == 15, 'Complete call census')
+    # Recount by the two path lengths, without using emitted main diagonals.
+    second_t = Counter({r:18*n for r,n in local['helpers'].items()})
+    second_p = Counter({r:18*n for r,n in local['paid'].items()})
+    second_t[145] += 208
+    second_p[1] += 15*104
+    for length in (7,8):
+        for j in range(1,length+1):
+            second_t[1+8*(j+1)] += 208
+            second_p[8*(j+1)] += 208
+    L.need((targets,paid) == (second_t,second_p), 'Independent full invoice')
+    L.need(max(targets) == 145 and max(paid) == 72, 'Maximum recursive ranks')
+    L.need(sum(targets.values()) == 13444 and sum(paid.values()) == 66870, 'Complete field and call counts')
+    L.need(sum(r*n for r,n in targets.items())-sum(r*n for r,n in paid.items()) == 760, 'Complete rank surplus')
+    return targets,paid,counts
+
+
+def run(local,native,word,physical):
+    T,P,counts = assemble(local,native,word,physical)
+    E = L.load(L.ROOT/'research/higher-moment-strictification/verify.py','p104_productive_intervals')
+    other = L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','p104_productive_second_intervals')
+    def margin(k):
+        a,b = E.moment(T,1-k), E.moment(P,1-k)
+        return a[0]-b[1],a[1]-b[0]
+    lo,hi,grid = 0,10**12,10**14
+    while hi-lo > 1:
+        m=(lo+hi)//2
+        if margin(Q(m,grid))[0] > 0:
+            lo=m
+        else:
+            hi=m
+    lower,upper = Q(lo,grid),Q(hi,grid)
+    signed = Counter(T)
+    signed.subtract(P)
+    cap = Q('.0034')
+    derivative_upper = Q(0)
+    for rank, count in signed.items():
+        logarithm = E.log_bounds(rank)
+        low = E.mul(E.power(rank, 1-cap), logarithm)[0]
+        high = rank*logarithm[1]
+        derivative_upper -= count*(low if count >= 0 else high)
+    L.need(derivative_upper < 0, 'Unique raw crossing below the retained BIT cap')
+    L.need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure')
+    L.need(PREVIOUS < KAPPA < TESTED < lower and margin(PREVIOUS)[0] > 0, 'Changed complete bill improves the source claim')
+    t,u,v,c,b = 1-TESTED,Q(1,7),1024,16,17
+    target,paid = E.moment(T,t),E.moment(P,t)
+    tl,th = other.moment(T,TESTED)
+    pl,ph = other.moment(P,TESTED)
+    L.need(tl > ph and max(tl,target[0]) <= min(th,target[1]) and max(pl,paid[0]) <= min(ph,paid[1]), 'Two exact moment engines')
+    alpha = E.divide(paid,target)
+    gamma = E.divide(E.moment(P,t+u),E.mul(E.power(c,u),target))
+    delta = E.divide((Q(sum(T.values())*b),)*2,E.mul(E.power(c,TESTED),target))
+    reserve,decay = Q(1,10**12),Q(125,128)
+    L.need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All three charged tail ratios')
+    L.need(decay**128 < Q(1,16), 'Both tail decay blocks')
+    normalized = 1/(1+v*reserve)+Q(4,2**32)
+    L.need(normalized < 1 and c**64 < b**63, 'Full completion, splitting and rounding charges')
+    theta,power = Q(63,64),1024
+    eta = E.scale(E.power(145,-v*TESTED),t)
+    L.need(2*(c**v)**64 <= (145**v)**63 and eta[0] > theta**power, 'Shifted exits and complement capacity')
+    L.need(E.power(145,v*TESTED)[1] < 2**power, 'Compiler initial range')
+    gap = (TESTED-KAPPA)/7
+    L.need(gap.numerator == 1, 'Exact compiler integer grid')
+    step = gap.denominator
+    def wins(j):
+        return (step*j+1)**power < 2**j
+    left,right=1,2
+    while not wins(right):
+        left,right=right,2*right
+    while right-left > 1:
+        m=(left+right)//2
+        if wins(m):
+            right=m
+        else:
+            left=m
+    H=step*right
+    L.need(H > 8*v and wins(right) and not wins(right-1), 'Finite uniform threshold with predecessor rejection')
+    local_routes = (sum(local['paid'].values())+native['helper_normalizers']+native['main_adapters']+4*104+4*local['owned_lifetimes'])*1000
+    L.need(local['real_scalar_allowance']+local_routes < 10**7, 'Every local scalar, route and owned operation is funded')
+    boundary = sum(len(word['boundaries'][side+'_program']) for side in ('left','right'))
+    raw = 18*10**7 + 15*1664 + 32*104*(len(word['physical_events'])+boundary)
+    raw += 32*104*(26+1000)
+    L.need(raw < 10**9, 'Complete nonrecursive raw bound')
+    bit = L.read(L.ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT']
+    atom = Q(bit['atom'])
+    ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599')
+    admitted=Q(bit['admitted'])
+    L.need(atom > ordinary > admitted > TESTED and atom < 1-ordinary, 'Retained BIT admission and stock')
+    outer_module=L.load(L.ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','p104_productive_outer')
+    params={'kappa':KAPPA,'tested_saving':TESTED,'complex_uniform_saving':KAPPA+6*gap,
+            'b':KAPPA+5*gap,'a':KAPPA+4*gap,'q':KAPPA+3*gap,'bit_saving':admitted,
+            'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap}
+    outer=outer_module.ledger(params)
+    outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom)
+    L.need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Complete outer predicate inventory')
+    L.need(all(x > 0 for key in ('strict_checks','functional_checks') for x in outer[key].values()), 'All outer inequalities strict')
+    wrong_cutoff = E.divide((Q(sum(T.values())*21),)*2,E.mul(E.power(20,TESTED),target))
+    L.need(wrong_cutoff[0] > 1, 'Old cutoff fails with this helper inventory')
+    old_completion = E.divide((Q(sum(T.values())*18),)*2,E.mul(E.power(17,TESTED),target))
+    L.need(old_completion[0] > Q(39,40), 'PR5718 completion-tail bound fails with the new target count')
+    old_offset = E.divide(E.moment(P,t+Q(1,5)),E.mul(E.power(16,Q(1,5)),target))
+    L.need(old_offset[0] > decay, 'The old tail offset fails at the new cutoff')
+    bad=outer_module.ledger(dict(params,bit_saving=Q('.0027')))
+    L.need(any(x <= 0 for x in bad['strict_checks'].values()), 'Insufficient BIT contract rejected')
+    return encode({'kappa':KAPPA,'kappa_decimal':'0.00312476680','previous_pr5811':PREVIOUS,'gain':KAPPA-PREVIOUS,
+                   'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper],
+                   'raw_headroom':[lower-KAPPA,upper-KAPPA],
+                   'raw_ceiling':{'interval':[Q(0),cap],'derivative_upper':derivative_upper},'margin_at_previous':E.display(margin(PREVIOUS)),
+                   'targets':T,'paid':P,'productive_fields':sum(T.values()),'paid_calls':sum(P.values()),
+                   'rank_mass_surplus':760,'full_forward_calls':18,'query_shears':15,'whole_idle_jobs':3120,
+                   'strictification':{'tested':TESTED,'power':v,'cutoff':c,'floor':b,'tail_offset':u,'reserve':reserve,'tail_decay':decay,'tail_block':128,
+                                     'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta),'normalized_paid_upper':normalized},
+                   'compiler':{'theta':theta,'logarithm_power':power,'eta':E.display(eta),'gap':gap,'H':H,'N':'2^'+str(H),
+                               'integer_test_exponent':right,'uniform_saving':params['complex_uniform_saving'],'word_materialized':False},
+                   'nonrecursive':{'local_scalar':local['real_scalar_allowance'],'local_routes':local_routes,
+                                   'raw_scalar_upper':raw,'raw_budget':10**9,'peak_owned_fields':local['peak_owned_fields'],
+                                   'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.',
+                                   'local_paid_rank_mass':local['paid_rank_mass'],
+                                   'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); use local_paid_rank_mass for the whole word.'},
+                   'ordinary_BIT':bit,'outer':outer,
+                   'negative_controls':{'source_completion':'Rejected at cutoff17, floor18 and decay39/40',
+                                        'source_offset':'Rejected at cutoff16 with tail offset1/5',
+                                        'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}})
diff --git a/research/p104-unread-path-resynthesis/sources.py b/research/p104-unread-path-resynthesis/sources.py
new file mode 100644
index 0000000000..3b4c60838a
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/sources.py
@@ -0,0 +1,64 @@
+"""Authenticate and open the retained source closure.
+
+Ali Romman with OpenAI Codex assistance. Apache-2.0.
+"""
+from contextlib import contextmanager
+from hashlib import sha1, sha256
+from pathlib import Path, PurePosixPath
+import importlib.util
+import json
+import sys
+import tarfile
+import tempfile
+
+HERE = Path(__file__).resolve().parent
+
+
+def need(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def load(path, name):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def authenticate(raw, pin):
+    need(len(raw) == pin['size'], 'Exact source size: '+pin['path'])
+    need(sha256(raw).hexdigest() == pin['sha256'], 'Exact source SHA256: '+pin['path'])
+    need(sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == pin['git_blob'],
+         'Exact source Git blob: '+pin['path'])
+
+
+@contextmanager
+def sources():
+    pins = json.loads((HERE/'SOURCES.json').read_bytes())
+    for pin in pins['direct_sources']:
+        authenticate((HERE/pin['local_path']).read_bytes(), pin)
+    archive = pins['source_archive']
+    path = HERE/archive['local_path']
+    need(sha256(path.read_bytes()).hexdigest() == archive['sha256'], 'Exact source archive')
+    members = {p['path']: p for p in pins['archived_files']}
+    need(len(members) == len(pins['archived_files']) == 19, 'Exact source inventory')
+    with tempfile.TemporaryDirectory(prefix='p104-transposed-source-') as directory:
+        root = Path(directory)
+        with tarfile.open(path, 'r:') as bundle:
+            seen = set()
+            for member in bundle.getmembers():
+                name = PurePosixPath(member.name)
+                need(member.isfile() and not name.is_absolute() and '..' not in name.parts
+                     and '\\' not in member.name and ':' not in member.name,
+                     'Regular relative source file')
+                need(member.name in members and member.name not in seen, 'Unique declared source file')
+                seen.add(member.name)
+                raw = bundle.extractfile(member).read()
+                authenticate(raw, members[member.name])
+                target = root.joinpath(*name.parts)
+                target.parent.mkdir(parents=True, exist_ok=True)
+                target.write_bytes(raw)
+        need(seen == set(members), 'Complete source archive')
+        yield root/archive['package']
diff --git a/research/p104-unread-path-resynthesis/verify.py b/research/p104-unread-path-resynthesis/verify.py
new file mode 100644
index 0000000000..2a4d918913
--- /dev/null
+++ b/research/p104-unread-path-resynthesis/verify.py
@@ -0,0 +1,154 @@
+"""Check the exact path rewrite and its complete conditional price.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+All predecessor notices are retained in NOTICE and the source archive.
+"""
+import argparse
+from collections import Counter
+from contextlib import ExitStack
+from copy import deepcopy
+import gzip
+import json
+from pathlib import Path
+import sys
+import tempfile
+
+sys.dont_write_bytecode = True
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+from sources import sources, load, need, authenticate
+from construct import construct
+
+STATUS = 'PASS_P104_UNREAD_PATH_KAPPA_00312476680'
+
+
+def read(path):
+    raw = path.read_bytes()
+    return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw)
+
+
+def declared_copy(origin, target, edits):
+    text = origin.read_text(encoding='utf-8')
+    for old, new in read(edits):
+        need(text.count(old) == 1, 'Unique declared source edit')
+        text = text.replace(old, new)
+    need(text == target.read_text(encoding='utf-8'), 'Only declared source edits')
+
+
+def delta(after, before):
+    value = Counter(after)
+    value.subtract(before)
+    return {str(r): n for r, n in sorted(value.items()) if n}
+
+
+def reject(action):
+    try:
+        action()
+    except ValueError as error:
+        return str(error)
+    raise ValueError('Invalid candidate accepted')
+
+
+def run():
+    with ExitStack() as contexts:
+        parent = contexts.enter_context(sources())
+        cursor = parent
+        for depth in range(7):
+            module = load(cursor/'sources.py', 'unread_path_source_'+str(depth))
+            cursor, root = contexts.enter_context(module.sources())
+        declared_copy(parent/'local.py', HERE/'local.py', HERE/'LOCAL-EDITS.json')
+        declared_copy(parent/'pricing.py', HERE/'pricing.py', HERE/'PRICING-EDITS.json')
+        L = load(HERE/'local.py', 'local')
+        L.ROOT = root
+        source = read(HERE/'inputs/pr5811-WORD.json.gz')
+        plan = read(HERE/'PLAN.json')
+        word, witness = construct(source, plan)
+        baseline, local = L.replay(source), L.replay(word)
+        need(delta(local['paid'], baseline['paid']) == {'1': -1, '4': -1, '5': 1}, 'Exact paid gain')
+        need(local['helpers'] == baseline['helpers'], 'Every productive target is retained')
+        need((local['public_inputs'], local['owned_fields'], local['owned_lifetimes'],
+              local['peak_owned_fields']) == (770, 29, 31, 13), 'Exact storage inventory')
+        need(local['public_inputs']+local['owned_fields'] < 1000, 'All arrays fit the retained slot bound')
+        need(local['real_scalar_allowance']-baseline['real_scalar_allowance'] == 8,
+             'The additional ordinary ADD is charged')
+        need(local['paid_rank_mass'] == baseline['paid_rank_mass'] == 5934, 'Unchanged local rank mass')
+        columns = L.reverse_columns(word)
+        print('PASS all input columns, separate transpose, storage and exact paid delta', flush=True)
+        native = L.native(word)
+        C = load(root/'research/p104-productive-controller/caller.py', 'unread_path_caller')
+        caller = C.construct()
+        need(caller == read(root/'research/p104-productive-controller/CONTROLLER.json'), 'Exact physical caller')
+        physical = C.physical(caller, word)
+        print('PASS native maps, absolute phases, adapters and complete physical caller', flush=True)
+        P = load(HERE/'pricing.py', 'unread_path_price')
+        price = P.run(local, native, caller, physical)
+        E = L.load(root/'research/higher-moment-strictification/verify.py', 'unread_path_source_price')
+        old_p = {int(r): n for r, n in price['paid'].items()}
+        old_p[1] += 18
+        old_p[4] += 18
+        old_p[5] -= 18
+        old_t = {int(r): n for r, n in price['targets'].items()}
+        margin = E.moment(old_t, 1-P.KAPPA)[1]-E.moment(old_p, 1-P.KAPPA)[0]
+        need(margin < 0, 'The old full profile fails at the new claim')
+        print('PASS both rational engines, completion, compiler and all outer costs', flush=True)
+
+        controls = C.controls(caller)
+        at = plan['start']
+        bad = deepcopy(word)
+        bad['program'].pop(at)
+        controls['missing_early_observation'] = reject(lambda: L.replay(bad))
+        bad = deepcopy(word)
+        bad['program'][at+2][-2] = '-1'
+        controls['wrong_late_sign'] = reject(lambda: L.replay(bad))
+        bad = deepcopy(word)
+        bad['program'].pop(at+1)
+        controls['missing_direct_query'] = reject(lambda: L.replay(bad))
+        bad = deepcopy(word)
+        bad['program'].insert(at+7, bad['program'].pop(at))
+        controls['late_use_of_old_value'] = reject(lambda: L.replay(bad))
+        bad = deepcopy(source)
+        bad['program'][at+3][-2] = '2'
+        controls['changed_source_interval'] = reject(lambda: construct(bad, plan))
+        bad = deepcopy(local)
+        bad['paid'][1] -= 1
+        controls['unpaid_query'] = reject(lambda: P.assemble(bad, native, caller, physical))
+        bad = deepcopy(local)
+        bad['helpers'][9] += 1
+        controls['extra_target_credit'] = reject(lambda: P.assemble(bad, native, caller, physical))
+        for pin in read(HERE/'SOURCES.json')['direct_sources']:
+            raw = (HERE/pin['local_path']).read_bytes()
+            controls['damaged_source_'+Path(pin['path']).name] = reject(
+                lambda raw=raw, pin=pin: authenticate(bytes([raw[0]^1])+raw[1:], pin))
+
+        result = dict(status=STATUS, source_commit='33d7760d0a6fea6394aefd014eea68f0af02a92e',
+                      source_local=baseline, local=local, paid_delta={'1': -1, '4': -1, '5': 1},
+                      target_delta={}, separate_columns=columns, native=native,
+                      physical_caller=physical, complete_cost=price,
+                      source_margin_upper_at_new_claim=margin, controls=controls,
+                      limits=['All five inherited framework assumptions remain.',
+                              'This is a small gain and does not meet the donor large-improvement target.',
+                              'The large uniform word and rounded multiplier are not materialized.',
+                              'Author checks do not establish independent acceptance.',
+                              'The selected frontier is unchanged.'])
+        return P.encode(result), witness, word
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--write', action='store_true')
+    args = parser.parse_args()
+    with tempfile.TemporaryDirectory(prefix='p104-unread-path-bytecode-') as cache:
+        sys.pycache_prefix = cache
+        result, witness, word = run()
+    for name, value in (('RESULT.json', result), ('WITNESS.json', witness), ('WORD.json.gz', word)):
+        path = HERE/name
+        if args.write:
+            raw = (json.dumps(value, sort_keys=True, indent=2)+'\n').encode()
+            path.write_bytes(gzip.compress(raw, mtime=0) if name.endswith('.gz') else raw)
+        else:
+            need(read(path) == value, 'Exact retained output: '+name)
+    print(STATUS, flush=True)
+
+
+if __name__ == '__main__':
+    main()