diff --git a/research/p104-free-endpoint-retime/LITERAL-CHANGES.diff b/research/p104-free-endpoint-retime/LITERAL-CHANGES.diff
new file mode 100644
index 0000000000..fa9154b209
--- /dev/null
+++ b/research/p104-free-endpoint-retime/LITERAL-CHANGES.diff
@@ -0,0 +1,58 @@
+--- inputs/pr5551-pricing.py (PR5551 head 1123635a)
++++ pricing.py (headline)
+@@ -11,7 +11,7 @@
+ from fractions import Fraction as Q
+ import local as L
+ 
+-KAPPA, TESTED = Q('.00304153'), Q('.0030415305')
++KAPPA, TESTED = Q('.00308142'), Q('.0030814205')
+ PREVIOUS = Q('.00304117')
+ 
+ 
+@@ -61,7 +61,7 @@
+             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()) == 12814 and sum(paid.values()) == 69912, 'Complete field and call counts')
++    L.need(sum(targets.values()) == 12814 and sum(paid.values()) == 66852, '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
+ 
+@@ -139,7 +139,7 @@
+     L.need(wrong_cutoff[0] > 1, 'Old cutoff fails with this helper inventory')
+     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':'.00304153','previous_open_pr5545':PREVIOUS,'gain':KAPPA-PREVIOUS,
++    return encode({'kappa':KAPPA,'kappa_decimal':'.00308142','previous_open_pr5545':PREVIOUS,'gain':KAPPA-PREVIOUS,
+                    'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper],
+                    'raw_headroom':[lower-KAPPA,upper-KAPPA],'margin_at_previous':E.display(margin(PREVIOUS)),
+                    'targets':T,'paid':P,'productive_fields':sum(T.values()),'paid_calls':sum(P.values()),
+--- inputs/pr5551-pricing.py (PR5551 head 1123635a)
++++ pricing-starts-only.py (supporting)
+@@ -11,7 +11,7 @@
+ from fractions import Fraction as Q
+ import local as L
+ 
+-KAPPA, TESTED = Q('.00304153'), Q('.0030415305')
++KAPPA, TESTED = Q('.003076879'), Q('.0030768795')
+ PREVIOUS = Q('.00304117')
+ 
+ 
+@@ -61,7 +61,7 @@
+             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()) == 12814 and sum(paid.values()) == 69912, 'Complete field and call counts')
++    L.need(sum(targets.values()) == 12814 and sum(paid.values()) == 67374, '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
+ 
+@@ -139,7 +139,7 @@
+     L.need(wrong_cutoff[0] > 1, 'Old cutoff fails with this helper inventory')
+     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':'.00304153','previous_open_pr5545':PREVIOUS,'gain':KAPPA-PREVIOUS,
++    return encode({'kappa':KAPPA,'kappa_decimal':'.003076879','previous_open_pr5545':PREVIOUS,'gain':KAPPA-PREVIOUS,
+                    'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper],
+                    'raw_headroom':[lower-KAPPA,upper-KAPPA],'margin_at_previous':E.display(margin(PREVIOUS)),
+                    'targets':T,'paid':P,'productive_fields':sum(T.values()),'paid_calls':sum(P.values()),
diff --git a/research/p104-free-endpoint-retime/README.md b/research/p104-free-endpoint-retime/README.md
new file mode 100644
index 0000000000..e8c177c6b7
--- /dev/null
+++ b/research/p104-free-endpoint-retime/README.md
@@ -0,0 +1,74 @@
+# Free helper endpoints on the P104 word (conditional kappa .0030814243)
+
+Complete conditional kappa **.0030814243** (**+3.99e-5**, +1.31% over
+[PR5551](https://github.com/CrocSwap/integer-mult-bounds/pull/5551)'s .0030415312). The claim is
+tested at .0030814205; the exact raw crossing lies in
+(15407121669/5000000000000, 308142433381/100000000000000) = (.00308142433380, .00308142433381).
+A supporting word that needs only free helper *start* frames reaches **.0030768801** (+3.54e-5);
+its exact crossing lies in (76922002003/25000000000000, 307688008013/100000000000000) = (.00307688008012, .00307688008013), tested at .0030768795.
+
+**Conditional on** (a) the five framework assumptions retained by PR5544/5545/5551; (b) the validity
+of PR5551, which is unreproduced at the time of writing; (c) **free helper START frames and free
+helper FINAL frames**. For (c): the verifier checks only that each helper's initial frame is strictly
+nested in its final frame and that the native boundary map has rank equal to the dimension gap; only
+the X-initial and Y-final frames are literal (the 104 ports). The canonical-start rule exists only
+in the #4610 compact-width verifier. Unmodified PR5544/5545 already has mid-frame helper starts
+(23 distinct start frames, dimensions 0, 1, 4, 5) and mixed finals (18 distinct, dimensions 4, 5, 8, 9).
+The headline word needs both (c)-starts and (c)-finals; the supporting word needs (c)-starts only. The
+selected record is not changed; no independent human or proof-kernel acceptance is claimed.
+
+## What the edit is (and is not)
+This is **not** an unchanged circuit. Relative to PR5551's pinned word (`inputs/pr5551-WORD.json.gz`):
+- The scalar program is identical: the same 21,686 ADD/COPY/SCALE/INIT/CLEAR events in the same order
+  with the same registers and coefficients (no register merge or reordering).
+- Only frame labels and MOVE stops change. The solve chose the subspace at every ADD-chart cluster
+  subject to the verifier's nesting laws (an exact-lattice CP-SAT retime), and **170 stops became
+  redundant and are deleted** (3,624 -> 3,454 MOVEs; 25,310 -> 25,140 events). The supporting word
+  deletes 141 stops (3,483 MOVEs).
+- Headline word: 168 helper start spans and 23 helper final spans differ from PR5551's (22 of the
+  finals move from dimension 8 to 9); 607 scalar-event frame labels and 607 kept MOVE stops are
+  relabelled (149 of those stops belong to main registers, whose intermediate frames move together with a
+  helper in a shared ADD chart). Supporting word: 169 helper starts differ, 0 finals.
+- All 208 main registers (104 X sources, 104 Y targets) keep identical initial and final spans, so the
+  literal ports, the caller and the controller are untouched.
+- Productive fields stay 12,814 and the rank-mass surplus stays 760; the credited helper profile moves
+  (rank 9: 294 -> 425, rank 8: 122 -> 14, rank 7: 24 -> 0) and paid calls fall 69,912 -> 66,852
+  (headline) / 67,374 (supporting).
+
+## Files
+- `WORD.json.gz` (headline, free starts + finals) and `WORD-STARTS-ONLY.json.gz` (supporting).
+- `retime.py`: the CP-SAT solve is multi-worker and not byte-reproducible, so instead of a generator
+  this exact stdlib checker proves a candidate is a legal retime of the pinned word: identical scalar
+  program, MOVEs a subsequence of the pinned MOVEs, all 208 main endpoint spans unchanged, 104 ports
+  and live list equal. Nesting, ownership, the common-chart frame law and rank = dimension gap are then
+  enforced by the unmodified PR5545 `local.py` replay and `native()`.
+- `pricing.py`, `pricing-starts-only.py`: PR5551's `pricing.py` (`inputs/pr5551-pricing.py`) with ONLY
+  literal changes: the KAPPA/TESTED claim line, the call census 69912 -> 66852 / 67374, and the
+  `kappa_decimal` label. `LITERAL-CHANGES.diff` shows them; `verify.py` re-applies the substitutions
+  and checks byte equality. No `local.py` change is needed (735 public inputs), so the unmodified
+  PR5545 `local.py` from the byte-pinned capsule is used.
+- `verify.py` / `verify.sh` (stdlib, Python 3.12): `--part headline` and `--part starts-only`, each
+  about 6 minutes: retime legality, replay, transposed columns, native maps, physical caller, pricing
+  with both moment engines, all 54 strict + 4 functional outer checks, exact crossing interval.
+- `inputs/pr5545-source-closure.tar.gz`, `inputs/pr5551-WORD.json.gz`, `inputs/pr5551-pricing.py`:
+  PR5551's byte-pinned inputs (`SOURCES.json`).
+
+## Independent audit
+An internal AI audit (separate read-only Claude agent) reproduced an earlier version of this retime on
+PR5545's word through the real replay/native/pricing stack, found helper credit and main endpoints
+sound, and rated maintainer intent for free helper frames as unresolved, which is why this is
+conditional. The PR5551-based words here are checked by `verify.py`; they have not had a separate audit.
+
+## Credits
+Builds on PR5551 (thu-nmrc) and the P104 word line of PR5544/5545 (aliromman; lineage
+PR2305/2152/2219). The idea of a fresh helper starting at a non-canonical frame follows the
+hand-off precedent of PR5472 (GamingPuzzled). All predecessor credit is retained.
+
+Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code.
+
+## Open next questions
+
+- Are free helper start frames (non-canonical, mid-frame) admissible in the P104 caller contract? Both words depend on it; the supporting word depends on nothing else.
+- Are free helper final frames admissible? The finals-free gain is the difference between the two words (.0030814243 vs .0030768801).
+- Can the retime be reproduced by a deterministic single-threaded solve, so a generator can replace the checker?
+- Independent reproduction of PR5551, on which this package builds. Interaction with hand-off words such as PR5553 is not tested here.
diff --git a/research/p104-free-endpoint-retime/RESULT.json b/research/p104-free-endpoint-retime/RESULT.json
new file mode 100644
index 0000000000..a953f0a60a
--- /dev/null
+++ b/research/p104-free-endpoint-retime/RESULT.json
@@ -0,0 +1,416 @@
+{
+ "headline": {
+  "compiler": {
+   "H": 690116000000000,
+   "N": "2^690116000000000",
+   "eta": {
+    "lower": "0.000000150915557284809901282836",
+    "upper": "0.000000150915557284809901282837"
+   },
+   "gap": "1/14000000000",
+   "integer_test_exponent": 49294,
+   "logarithm_power": 1000,
+   "theta": "63/64",
+   "uniform_saving": "21569943/7000000000",
+   "word_materialized": false
+  },
+  "full_forward_calls": 18,
+  "gain": "161/4000000",
+  "kappa": "154071/50000000",
+  "kappa_decimal": ".00308142",
+  "margin_at_previous": {
+   "lower": "9.863889227373890942015545303213",
+   "upper": "9.863889227373890942015545303214"
+  },
+  "negative_controls": {
+   "old_BIT": "Rejected by outer inequalities",
+   "old_cutoff": "Rejected by completion-tail ratio greater than one"
+  },
+  "nonrecursive": {
+   "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.",
+   "local_routes": 5164000,
+   "local_scalar": 217428,
+   "peak_owned_fields": 1,
+   "raw_budget": 1000000000,
+   "raw_scalar_upper": 184647552,
+   "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); sum of local ranks is 5894."
+  },
+  "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": "3485999999253/3500000000000",
+    "fixed_halo_explicit_metadata_branch": "269500000001/3500000000",
+    "new_BIT_row_stock_sublinear_in_active_group": "13957999997009/14000000000000",
+    "new_semantic_group_guard": "3/14000000000"
+   },
+   "margins": {
+    "boundary_algebraic_matrix": "603958375956860117/196000000000000000000",
+    "fused_gaussian": "603958375870580351/196000000000000000000",
+    "global_coordinate_router": "10784971/3500000000",
+    "group_bit_router": "150989597467645087/49000000000000000000",
+    "group_scans": "6999999999/7000000000",
+    "main_transform": "603958361956860117/196000000000000000000",
+    "microbox_face_corrections": "269500000001/3500000000",
+    "polynomial_products": "13999999999/14000000000",
+    "sparse_union_movement": "80228958375956860117/196000000000000000000"
+   },
+   "parameters": {
+    "a": "10784971/3500000000",
+    "b": "8627977/2800000000",
+    "beta": "13999999997/14000000000",
+    "bit_saving": "17/5000",
+    "cap_xi": "178228958361956860117/196000000000000000000",
+    "complex_uniform_saving": "21569943/7000000000",
+    "d": "1/14000000000",
+    "epsilon": "13999999999/14000000000",
+    "kappa": "154071/50000000",
+    "lambda_": "3987674319/4000000000",
+    "lambda_prime": "13956860117/14000000000",
+    "layout": "1/14000000000",
+    "q": "43139883/14000000000",
+    "r0": "1/140000000000",
+    "stop": "1/14000000000",
+    "tested_saving": "6162841/2000000000"
+   },
+   "strict_checks": {
+    "actual_bit_above_effective": "1115029/3500000000",
+    "actual_logarithmic_gamma_guard": "1/14000000000",
+    "actual_logarithmic_group_guard": "17771041659043139883/98000000000000000000",
+    "alpha_logarithm_absorption": "1/140000000000",
+    "boundary_algebraic_matrix_above_kappa": "55956860117/196000000000000000000",
+    "cap_above_band": "80228958361956860117/196000000000000000000",
+    "cap_below_cell": "17771041624043139883/196000000000000000000",
+    "cap_below_phase_cell_power": "213771041638043139883/196000000000000000000",
+    "complex_above_effective": "1/14000000000",
+    "complex_below_one_over_32": "78872023/2800000000",
+    "complex_endpoint": "1/7000000000",
+    "epsilon_below_one": "1/14000000000",
+    "epsilon_positive": "13999999999/14000000000",
+    "fine_prime_halo_umbrella": "7/2",
+    "fused_gaussian_above_kappa": "55870580351/196000000000000000000",
+    "gaussian_above_main": "6956860117/98000000000000000000",
+    "global_coordinate_router_above_kappa": "1/3500000000",
+    "global_gamma_power_slack": "9/140000000000",
+    "group_below_dimension": "1/7000000000",
+    "group_bit_router_above_kappa": "17467645087/49000000000000000000",
+    "group_gauge_power_slack": "17771041658343139883/98000000000000000000",
+    "group_key_fits_record": "1/7000000000",
+    "group_positive": "13999999997/14000000000",
+    "group_scans_above_kappa": "6978430059/7000000000",
+    "halo_covers_generic_inverse_radius": "5",
+    "improvement_over_user_baseline": "675224790400418148631/500000000000000000000000",
+    "lambda_above_internal": "1/28000000000",
+    "lambda_above_sigma": "3/28000000000",
+    "lambda_above_tau": "1/28000000000",
+    "lambda_prime_above_lambda": "1/28000000000",
+    "lambda_prime_above_leaf": "5591372023/39200000000000000000",
+    "leaf_saving_above_effective": "2791372023/39200000000000000000",
+    "main_transform_above_kappa": "41956860117/196000000000000000000",
+    "membership_arithmetic_fits_record": "1/14000000000",
+    "microbox_face_corrections_above_kappa": "269489215031/3500000000",
+    "microbox_halo_volume": "1106000000003/14000000000",
+    "new_complex_uniform_saving_above_b": "1/14000000000",
+    "new_semantic_guard_with_C1_one": "1/14000000000",
+    "polynomial_products_above_kappa": "13956860119/14000000000",
+    "positive_layout_slack": "1/14000000000",
+    "q_below_effective": "1/14000000000",
+    "q_below_internal": "1/14000000000",
+    "q_below_leaf": "5591372023/39200000000000000000",
+    "q_positive": "43139883/14000000000",
+    "short_record_fallback": "2791372023/2800000000",
+    "source_axis_superpolynomial": "1/14000000000",
+    "sparse_union_movement_above_kappa": "79625000055956860117/196000000000000000000",
+    "stop_below_one": "13999999999/14000000000",
+    "stop_positive": "1/14000000000",
+    "strassen_integer_power_gap": "1951441519231",
+    "support_router_span": "3/14000000000",
+    "theta_positive_polynomial_power": "2",
+    "union_header_fits_record": "3/14000000000",
+    "union_tag_work_per_visit_fits_record": "3/14000000000"
+   }
+  },
+  "paid": {
+   "1": 41340,
+   "16": 416,
+   "2": 8262,
+   "24": 416,
+   "3": 8928,
+   "32": 416,
+   "4": 1674,
+   "40": 416,
+   "48": 416,
+   "5": 2952,
+   "56": 416,
+   "6": 324,
+   "64": 416,
+   "7": 252,
+   "72": 208
+  },
+  "paid_calls": 66852,
+  "previous_open_pr5545": "304117/100000000",
+  "productive_fields": 12814,
+  "query_shears": 15,
+  "rank_mass_surplus": 760,
+  "raw_headroom": [
+   "21669/5000000000000",
+   "433381/100000000000000"
+  ],
+  "raw_root_interval": [
+   "15407121669/5000000000000",
+   "308142433381/100000000000000"
+  ],
+  "relative_gain_percent": "402500/304117",
+  "strictification": {
+   "alpha": {
+    "lower": "0.999999996077490279252156945261",
+    "upper": "0.999999996077490279252156945262"
+   },
+   "cutoff": 17,
+   "delta": {
+    "lower": "0.954776932282871740517530812724",
+    "upper": "0.954776932282871740517530812725"
+   },
+   "floor": 18,
+   "gamma": {
+    "lower": "0.967371300368832148444639574582",
+    "upper": "0.967371300368832148444639574583"
+   },
+   "normalized_paid_upper": "5242880004882813/5242880536870912",
+   "power": 1024,
+   "reserve": "1/10000000000",
+   "tail_offset": "1/5",
+   "tested": "6162841/2000000000"
+  },
+  "targets": {
+   "145": 208,
+   "17": 416,
+   "25": 416,
+   "33": 416,
+   "4": 1494,
+   "41": 416,
+   "49": 416,
+   "5": 90,
+   "57": 416,
+   "65": 416,
+   "73": 208,
+   "8": 252,
+   "9": 7650
+  },
+  "whole_idle_jobs": 3120
+ },
+ "starts_only": {
+  "compiler": {
+   "H": 690116000000000,
+   "N": "2^690116000000000",
+   "eta": {
+    "lower": "0.000000154449432404612929595969",
+    "upper": "0.000000154449432404612929595970"
+   },
+   "gap": "1/14000000000",
+   "integer_test_exponent": 49294,
+   "logarithm_power": 1000,
+   "theta": "63/64",
+   "uniform_saving": "5384539/1750000000",
+   "word_materialized": false
+  },
+  "full_forward_calls": 18,
+  "gain": "35709/1000000000",
+  "kappa": "3076879/1000000000",
+  "kappa_decimal": ".003076879",
+  "margin_at_previous": {
+   "lower": "8.763458055403927069103933159568",
+   "upper": "8.763458055403927069103933159569"
+  },
+  "negative_controls": {
+   "old_BIT": "Rejected by outer inequalities",
+   "old_cutoff": "Rejected by completion-tail ratio greater than one"
+  },
+  "nonrecursive": {
+   "fixed_scalar_growth_bound": "At most 2^(16*26000) before native factors; a declared constant, not an attained norm.",
+   "local_routes": 5193000,
+   "local_scalar": 217428,
+   "peak_owned_fields": 1,
+   "raw_budget": 1000000000,
+   "raw_scalar_upper": 184647552,
+   "tensor_native_growth_bound": "Each rank-r Gaussian has row l1 norm at most 2^(rf); sum of local ranks is 5894."
+  },
+  "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": "3485999999253/3500000000000",
+    "fixed_halo_explicit_metadata_branch": "269500000001/3500000000",
+    "new_BIT_row_stock_sublinear_in_active_group": "13957999997009/14000000000000",
+    "new_semantic_group_guard": "3/14000000000"
+   },
+   "margins": {
+    "boundary_algebraic_matrix": "603068339956923691/196000000000000000000",
+    "fused_gaussian": "603068339870771073/196000000000000000000",
+    "global_coordinate_router": "4307631/1400000000",
+    "group_bit_router": "60306835387077107/19600000000000000000",
+    "group_scans": "6999999999/7000000000",
+    "main_transform": "603068325956923691/196000000000000000000",
+    "microbox_face_corrections": "269500000001/3500000000",
+    "polynomial_products": "13999999999/14000000000",
+    "sparse_union_movement": "80228068339956923691/196000000000000000000"
+   },
+   "parameters": {
+    "a": "4307631/1400000000",
+    "b": "43076311/14000000000",
+    "beta": "13999999997/14000000000",
+    "bit_saving": "17/5000",
+    "cap_xi": "178228068325956923691/196000000000000000000",
+    "complex_uniform_saving": "5384539/1750000000",
+    "d": "1/14000000000",
+    "epsilon": "13999999999/14000000000",
+    "kappa": "3076879/1000000000",
+    "lambda_": "3987692483/4000000000",
+    "lambda_prime": "13956923691/14000000000",
+    "layout": "1/14000000000",
+    "q": "43076309/14000000000",
+    "r0": "1/140000000000",
+    "stop": "1/14000000000",
+    "tested_saving": "6153759/2000000000"
+   },
+   "strict_checks": {
+    "actual_bit_above_effective": "452369/1400000000",
+    "actual_logarithmic_gamma_guard": "1/14000000000",
+    "actual_logarithmic_group_guard": "17771931695043076309/98000000000000000000",
+    "alpha_logarithm_absorption": "1/140000000000",
+    "boundary_algebraic_matrix_above_kappa": "55956923691/196000000000000000000",
+    "cap_above_band": "80228068325956923691/196000000000000000000",
+    "cap_below_cell": "17771931660043076309/196000000000000000000",
+    "cap_below_phase_cell_power": "213771931674043076309/196000000000000000000",
+    "complex_above_effective": "1/14000000000",
+    "complex_below_one_over_32": "394423689/14000000000",
+    "complex_endpoint": "1/7000000000",
+    "epsilon_below_one": "1/14000000000",
+    "epsilon_positive": "13999999999/14000000000",
+    "fine_prime_halo_umbrella": "7/2",
+    "fused_gaussian_above_kappa": "55870771073/196000000000000000000",
+    "gaussian_above_main": "6956923691/98000000000000000000",
+    "global_coordinate_router_above_kappa": "1/3500000000",
+    "global_gamma_power_slack": "9/140000000000",
+    "group_below_dimension": "1/7000000000",
+    "group_bit_router_above_kappa": "6987077107/19600000000000000000",
+    "group_gauge_power_slack": "17771931694343076309/98000000000000000000",
+    "group_key_fits_record": "1/7000000000",
+    "group_positive": "13999999997/14000000000",
+    "group_scans_above_kappa": "3489230923/3500000000",
+    "halo_covers_generic_inverse_radius": "5",
+    "improvement_over_user_baseline": "672954290400418148631/500000000000000000000000",
+    "lambda_above_internal": "1/28000000000",
+    "lambda_above_sigma": "3/28000000000",
+    "lambda_above_tau": "1/28000000000",
+    "lambda_prime_above_lambda": "1/28000000000",
+    "lambda_prime_above_leaf": "27956923689/196000000000000000000",
+    "leaf_saving_above_effective": "13956923689/196000000000000000000",
+    "main_transform_above_kappa": "41956923691/196000000000000000000",
+    "membership_arithmetic_fits_record": "1/14000000000",
+    "microbox_face_corrections_above_kappa": "538978461849/7000000000",
+    "microbox_halo_volume": "1106000000003/14000000000",
+    "new_complex_uniform_saving_above_b": "1/14000000000",
+    "new_semantic_guard_with_C1_one": "1/14000000000",
+    "polynomial_products_above_kappa": "13956923693/14000000000",
+    "positive_layout_slack": "1/14000000000",
+    "q_below_effective": "1/14000000000",
+    "q_below_internal": "1/14000000000",
+    "q_below_leaf": "27956923689/196000000000000000000",
+    "q_positive": "43076309/14000000000",
+    "short_record_fallback": "13956923689/14000000000",
+    "source_axis_superpolynomial": "1/14000000000",
+    "sparse_union_movement_above_kappa": "79625000055956923691/196000000000000000000",
+    "stop_below_one": "13999999999/14000000000",
+    "stop_positive": "1/14000000000",
+    "strassen_integer_power_gap": "1951441519231",
+    "support_router_span": "3/14000000000",
+    "theta_positive_polynomial_power": "2",
+    "union_header_fits_record": "3/14000000000",
+    "union_tag_work_per_visit_fits_record": "3/14000000000"
+   }
+  },
+  "paid": {
+   "1": 42204,
+   "16": 416,
+   "2": 8442,
+   "24": 416,
+   "3": 8442,
+   "32": 416,
+   "4": 1638,
+   "40": 416,
+   "48": 416,
+   "5": 2970,
+   "56": 416,
+   "6": 306,
+   "64": 416,
+   "7": 252,
+   "72": 208
+  },
+  "paid_calls": 67374,
+  "previous_open_pr5545": "304117/100000000",
+  "productive_fields": 12814,
+  "query_shears": 15,
+  "rank_mass_surplus": 760,
+  "raw_headroom": [
+   "27003/25000000000000",
+   "108013/100000000000000"
+  ],
+  "raw_root_interval": [
+   "76922002003/25000000000000",
+   "307688008013/100000000000000"
+  ],
+  "relative_gain_percent": "357090/304117",
+  "strictification": {
+   "alpha": {
+    "lower": "0.999999999404592592047426513673",
+    "upper": "0.999999999404592592047426513674"
+   },
+   "cutoff": 17,
+   "delta": {
+    "lower": "0.956340515100833390077946018407",
+    "upper": "0.956340515100833390077946018408"
+   },
+   "floor": 18,
+   "gamma": {
+    "lower": "0.967169144621326622973846552884",
+    "upper": "0.967169144621326622973846552885"
+   },
+   "normalized_paid_upper": "5242880004882813/5242880536870912",
+   "power": 1024,
+   "reserve": "1/10000000000",
+   "tail_offset": "1/5",
+   "tested": "6153759/2000000000"
+  },
+  "targets": {
+   "145": 208,
+   "17": 416,
+   "25": 416,
+   "33": 416,
+   "4": 1494,
+   "41": 416,
+   "49": 416,
+   "5": 90,
+   "57": 416,
+   "65": 416,
+   "7": 18,
+   "73": 208,
+   "8": 612,
+   "9": 7272
+  },
+  "whole_idle_jobs": 3120
+ },
+ "status": "PASS_P104_FREE_ENDPOINT_RETIME_CONDITIONAL_KAPPA"
+}
diff --git a/research/p104-free-endpoint-retime/SOURCES.json b/research/p104-free-endpoint-retime/SOURCES.json
new file mode 100644
index 0000000000..2fe44de014
--- /dev/null
+++ b/research/p104-free-endpoint-retime/SOURCES.json
@@ -0,0 +1,38 @@
+{
+  "schema_version": 1,
+  "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "fc3d4ba105e1f097d0d7d051a308281e86ab1446",
+      "sha256": "66974efdced4083c00025f97d95d83909a226cdf801edb9301c195c6641f6903"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602",
+      "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72"
+    }
+  ],
+  "retained_source": {
+    "path": "research/p104-free-endpoint-retime/inputs/pr5545-source-closure.tar.gz",
+    "sha256": "59768da554e11b11fae52d07f520f50684cc7a9ee0bec2873edbcd6b63814837",
+    "export_manifest_sha256": "0a20358f9c089be1f5606c78077314e30a72998fb3c5123848d921a8d1814e76",
+    "commit": "18968423711fd902aaee1099979497d55603e1dc",
+    "files": 33,
+    "source_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5545",
+    "note": "Byte-identical copy of the capsule retained by PR5551; used UNMODIFIED (no local.py edit is needed: the retimed words keep 735 public inputs)."
+  },
+  "pinned_word": {
+    "path": "research/p104-free-endpoint-retime/inputs/pr5551-WORD.json.gz",
+    "sha256": "48f8734ca9c5adf5d60ded3a5fefbc24894d2c358ed7cb30fcc0d71718599446",
+    "source_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5551",
+    "source_head": "1123635a6f63f23638df9459c994160e5e649d30",
+    "source_path": "research/p104-joint-contact/WORD.json.gz"
+  },
+  "pinned_pricing": {
+    "path": "research/p104-free-endpoint-retime/inputs/pr5551-pricing.py",
+    "source_path": "research/p104-joint-contact/pricing.py at PR5551 head"
+  }
+}
diff --git a/research/p104-free-endpoint-retime/TASK.json b/research/p104-free-endpoint-retime/TASK.json
new file mode 100644
index 0000000000..7a34be8497
--- /dev/null
+++ b/research/p104-free-endpoint-retime/TASK.json
@@ -0,0 +1,116 @@
+{
+ "schema_version": 1,
+ "task_id": "scalar-to-moment",
+ "actual_scope": "On PR5551's pinned P104 word, retime the helper START and FINAL frames (and the intermediate frames of the shared ADD charts) with an exact-lattice CP-SAT solve, collapsing 170 now-redundant stops (141 for the starts-only variant); the 54 strict + 4 functional outer checks and the exact crossing are re-certified for the changed complete conditional moment.",
+ "bottleneck_link": "Free helper endpoints let credited helper rank move from many rank-8 climbs to rank-9 climbs and remove 170 rank-1 stops per call; at all 18 calls this lowers the paid profile (69,912 -> 66,852 calls) at unchanged rank-mass surplus 760, so the concave moment gap widens.",
+ "stop_rule": "Retain the conditional kappa only after retime.py proves each word a legal retime of PR5551's word and exact scalar/native replay, physical caller, both moment engines and all 54 strict + 4 functional outer checks pass.",
+ "outcome": "completed",
+ "author": "DreamingOfClouds, with Claude Opus 5.5 (Anthropic), via Claude Code",
+ "ai_assistance": "Claude Opus 5.5 via Claude Code; an internal AI audit reproduced the result independently. No independent human or proof-kernel acceptance is claimed.",
+ "open_questions": [
+  {
+   "question": "Are free helper START frames (non-canonical, mid-frame) admissible in the P104 caller contract?",
+   "why_it_matters": "Both words depend on it; the starts-only word depends on nothing else. The verifier checks only nesting and rank = dim gap for helpers; the canonical-start rule exists only in the #4610 verifier, and unmodified PR5544/5545 already has helper starts at dims 0,1,4,5.",
+   "blocked_by": "Maintainer or swarm review.",
+   "first_step": "Decide whether helper identity rows at arbitrary nested start frames are intended in the P104 caller; WORD-STARTS-ONLY.json.gz is the test case."
+  },
+  {
+   "question": "Are free helper FINAL frames admissible?",
+   "why_it_matters": "The headline word changes 23 helper finals (mostly dim 8 -> 9); the extra gain from finals is the difference between the two words.",
+   "blocked_by": "Maintainer or swarm review.",
+   "first_step": "Compare the two words: the finals-free gain is the difference .0030814243 - .0030768801."
+  },
+  {
+   "question": "Can the retime be reproduced byte-for-byte by a deterministic solver?",
+   "why_it_matters": "The words are checked, not generated; a deterministic generator would shorten review.",
+   "blocked_by": "None; the solve is a multi-worker CP-SAT run.",
+   "first_step": "Re-run the exact-lattice solve single-threaded with a fixed seed and compare against retime.py."
+  }
+ ],
+ "scope_status": "changed",
+ "scope_change_reason": "The scalar-to-moment card asks about scalar A2 contractions on the retained word; this package instead retimes helper endpoint and stop frames of PR5551's P104 word, a different construction on a newer word. Recorded as changed; the card's own object is not pursued.",
+ "evidence": "verify.py checks each word with retime.py (legal retime of PR5551's pinned word: identical scalar program, only stops deleted and frame labels changed, all 208 main endpoint spans unchanged), the unmodified PR5545 local.py replay/columns/native, the physical caller, PR5551's pricing with literal-only changes, both moment engines, all 54 strict + 4 functional outer checks, and the exact crossing interval for each word.",
+ "base_commit": "32890bc5de034ab8fc93ac88ead7279a6a416d04",
+ "original_card": {
+  "id": "scalar-to-moment",
+  "question": "Can a changed frame itinerary remove a paid transition beyond the already covered scalar A2 contractions?",
+  "starting_points": [
+   "docs/research/research-family-status.md",
+   "certificates/selected-result.json",
+   "research/staged544-a2-graph-rewrite/README.md",
+   "research/staged544-separated-a2/README.md",
+   "research/staged544-a2-composition-audit/README.md",
+   "research/staged544-a1858-contraction-audit/README.md"
+  ],
+  "methods": [
+   "Derive the changed legal frame itinerary and exact child histogram.",
+   "Prove a scoped obstruction showing why that scalar gain cannot change the paid contract."
+  ],
+  "acceptance_gate": "An unchanged histogram is not a kappa gain; record any separate runtime or proof benefit explicitly.",
+  "first_step": {
+   "command": [
+    "python3",
+    "-B",
+    "scripts/research_baseline.py"
+   ],
+   "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+   "inspect": "Read the A2 and separated-A2 constructions and their composition/contraction audits. Scalar contractions can preserve the complete recursive histogram; fewer ADDs alone do not justify further scans.",
+   "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately."
+  },
+  "first_experiment": "Identify an actual paid transition to remove and construct a legal replacement frame itinerary, charging restoration, source windows and changed helpers. Compare complete before/after histograms. Stop if only scalar count changes; report that benefit honestly, without expanding the same scalar-only census.",
+  "bottleneck_link": "A legal change to the histogram, not addition count alone, is the bridge to an exponent gain.",
+  "allowed_variations": [
+   "One existing scalar simplification and one proposed frame-path change."
+  ],
+  "scope_change_triggers": [
+   "Submitting only another scalar count as completion of a paid-profile task."
+  ],
+  "overlap_terms": [
+   "scalar simplification",
+   "paid profile",
+   "R439",
+   "3998",
+   "4019",
+   "4112",
+   "4152",
+   "staged544-a2-graph-rewrite",
+   "staged544-separated-a2",
+   "staged544-a2-composition-audit",
+   "staged544-a1858-contraction-audit"
+  ],
+  "existing_checks": [
+   {
+    "scope": "PR #3998: consecutive A2 scalar contraction",
+    "evidence": "research/staged544-a2-graph-rewrite/README.md",
+    "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.",
+    "status": "author-checked",
+    "source_commit": "389268a6b5e0373a3125d5c6fcd6995f4ea324f5",
+    "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+   },
+   {
+    "scope": "PR #4019: separated A2 sites with unchanged recursive histogram",
+    "evidence": "research/staged544-separated-a2/README.md",
+    "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.",
+    "status": "author-checked",
+    "source_commit": "f408e09df300b575235f7f77f81948071397e16d",
+    "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+   },
+   {
+    "scope": "PR #4112: composition audit",
+    "evidence": "research/staged544-a2-composition-audit/README.md",
+    "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.",
+    "status": "author-checked",
+    "source_commit": "205b7380656ba4b6316a8a493b1a3c679b8f7a0e",
+    "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+   },
+   {
+    "scope": "PR #4152: A1858 contraction audit",
+    "evidence": "research/staged544-a1858-contraction-audit/README.md",
+    "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.",
+    "status": "author-checked",
+    "source_commit": "caaa14cde5962adc372fdca71f63d0f29e73c8b2",
+    "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+   }
+  ]
+ }
+}
diff --git a/research/p104-free-endpoint-retime/VERIFY.json b/research/p104-free-endpoint-retime/VERIFY.json
new file mode 100644
index 0000000000..a4cfbef7c2
--- /dev/null
+++ b/research/p104-free-endpoint-retime/VERIFY.json
@@ -0,0 +1,31 @@
+{
+ "schema_version": 1,
+ "status": "ready",
+ "python": "3.12",
+ "requirements": [],
+ "inputs": [],
+ "commands": [
+  {
+   "argv": [
+    "{python}",
+    "-B",
+    "{package}/verify.py",
+    "--part",
+    "headline"
+   ],
+   "timeout_seconds": 600,
+   "checks": "Main claim: retime.py legality of WORD.json.gz against PR5551's word; unmodified PR5545 replay, transposed columns, native maps, physical caller; literal-only pricing; both moment engines; 54 strict + 4 functional outer checks; exact crossing interval."
+  },
+  {
+   "argv": [
+    "{python}",
+    "-B",
+    "{package}/verify.py",
+    "--part",
+    "starts-only"
+   ],
+   "timeout_seconds": 600,
+   "checks": "Supporting: the same chain for WORD-STARTS-ONLY.json.gz (helper finals unchanged), which needs only free helper start frames."
+  }
+ ]
+}
diff --git a/research/p104-free-endpoint-retime/WORD-STARTS-ONLY.json.gz b/research/p104-free-endpoint-retime/WORD-STARTS-ONLY.json.gz
new file mode 100644
index 0000000000..b0c13f48e9
Binary files /dev/null and b/research/p104-free-endpoint-retime/WORD-STARTS-ONLY.json.gz differ
diff --git a/research/p104-free-endpoint-retime/WORD.json.gz b/research/p104-free-endpoint-retime/WORD.json.gz
new file mode 100644
index 0000000000..c367d865a1
Binary files /dev/null and b/research/p104-free-endpoint-retime/WORD.json.gz differ
diff --git a/research/p104-free-endpoint-retime/common.py b/research/p104-free-endpoint-retime/common.py
new file mode 100644
index 0000000000..b8368c7948
--- /dev/null
+++ b/research/p104-free-endpoint-retime/common.py
@@ -0,0 +1,47 @@
+"""Open the byte-pinned PR5545 source closure (same pins as PR5551); Apache-2.0.
+
+Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code.
+Mechanism and all predecessor credit: see README.md.
+"""
+from contextlib import contextmanager
+from hashlib import sha256
+from io import BytesIO
+from pathlib import Path,PurePosixPath
+import gzip,importlib.util,json,sys,tarfile,tempfile
+
+HERE=Path(__file__).resolve().parent
+def need(ok,why):
+    if not ok:
+        raise ValueError(why)
+
+def read(path):
+    raw=Path(path).read_bytes()
+    return json.loads(gzip.decompress(raw) if str(path).endswith('.gz') else raw)
+
+def load(path,name):
+    spec=importlib.util.spec_from_file_location(name,path)
+    mod=importlib.util.module_from_spec(spec);sys.modules[name]=mod;spec.loader.exec_module(mod);return mod
+
+@contextmanager
+def closure():
+    pins=json.loads((HERE/'SOURCES.json').read_bytes())['retained_source']
+    raw=(HERE/'inputs'/Path(pins['path']).name).read_bytes()
+    need(sha256(raw).hexdigest()==pins['sha256'],'Retained PR5545 capsule byte pin')
+    with tempfile.TemporaryDirectory(prefix='p104-free-endpoint-retime-')as tmp:
+        root=Path(tmp)
+        with tarfile.open(fileobj=BytesIO(gzip.decompress(raw)),mode='r:')as archive:
+            members=archive.getmembers();names=[m.name for m in members]
+            need(len(names)==len(set(names)),'Unique retained source paths')
+            for m in members:
+                n=PurePosixPath(m.name)
+                need(m.isfile()and not n.is_absolute()and '..'not in n.parts,'Regular retained source path')
+                t=root/m.name;t.parent.mkdir(parents=True,exist_ok=True);t.write_bytes(archive.extractfile(m).read())
+        mraw=(root/'.research-export.json').read_bytes()
+        need(sha256(mraw).hexdigest()==pins['export_manifest_sha256'],'Exact export inventory')
+        man=json.loads(mraw)
+        need(man['commit']==pins['commit']and len(man['files'])==pins['files']==33,'Exact predecessor closure')
+        need(set(names)=={'.research-export.json'}|{r['path']for r in man['files']},'No omitted or extra file')
+        for r in man['files']:
+            b=(root/r['path']).read_bytes()
+            need(len(b)==r['size']and sha256(b).hexdigest()==r['sha256'],'Source file '+r['path'])
+        yield root
diff --git a/research/p104-free-endpoint-retime/inputs/pr5545-source-closure.tar.gz b/research/p104-free-endpoint-retime/inputs/pr5545-source-closure.tar.gz
new file mode 100644
index 0000000000..3084088544
Binary files /dev/null and b/research/p104-free-endpoint-retime/inputs/pr5545-source-closure.tar.gz differ
diff --git a/research/p104-free-endpoint-retime/inputs/pr5551-WORD.json.gz b/research/p104-free-endpoint-retime/inputs/pr5551-WORD.json.gz
new file mode 100644
index 0000000000..c04a815c26
Binary files /dev/null and b/research/p104-free-endpoint-retime/inputs/pr5551-WORD.json.gz differ
diff --git a/research/p104-free-endpoint-retime/inputs/pr5551-pricing.py b/research/p104-free-endpoint-retime/inputs/pr5551-pricing.py
new file mode 100644
index 0000000000..ef78de99ff
--- /dev/null
+++ b/research/p104-free-endpoint-retime/inputs/pr5551-pricing.py
@@ -0,0 +1,156 @@
+"""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 prepared for thu-nmrc with substantial OpenAI Codex assistance.
+Ali Romman's complete caller/price proof and all predecessor credit are retained.
+Apache-2.0.
+"""
+from collections import Counter
+from fractions import Fraction as Q
+import local as L
+
+KAPPA, TESTED = Q('.00304153'), Q('.0030415305')
+PREVIOUS = Q('.00304117')
+
+
+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()) == 12814 and sum(paid.values()) == 69912, '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)
+    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 selected kappa')
+    t,u,v,c,b = 1-TESTED,Q(1,5),1024,17,18
+    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**10),Q(97,100)
+    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),1000
+    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')
+    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':'.00304153','previous_open_pr5545':PREVIOUS,'gain':KAPPA-PREVIOUS,
+                   'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper],
+                   'raw_headroom':[lower-KAPPA,upper-KAPPA],'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,
+                                     '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':1,
+                                   'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.',
+                                   'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); sum of local ranks is 5894.'},
+                   'ordinary_BIT':bit,'outer':outer,
+                   'negative_controls':{'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}})
diff --git a/research/p104-free-endpoint-retime/pricing-starts-only.py b/research/p104-free-endpoint-retime/pricing-starts-only.py
new file mode 100644
index 0000000000..e32cbc0fe1
--- /dev/null
+++ b/research/p104-free-endpoint-retime/pricing-starts-only.py
@@ -0,0 +1,156 @@
+"""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 prepared for thu-nmrc with substantial OpenAI Codex assistance.
+Ali Romman's complete caller/price proof and all predecessor credit are retained.
+Apache-2.0.
+"""
+from collections import Counter
+from fractions import Fraction as Q
+import local as L
+
+KAPPA, TESTED = Q('.003076879'), Q('.0030768795')
+PREVIOUS = Q('.00304117')
+
+
+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()) == 12814 and sum(paid.values()) == 67374, '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)
+    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 selected kappa')
+    t,u,v,c,b = 1-TESTED,Q(1,5),1024,17,18
+    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**10),Q(97,100)
+    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),1000
+    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')
+    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':'.003076879','previous_open_pr5545':PREVIOUS,'gain':KAPPA-PREVIOUS,
+                   'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper],
+                   'raw_headroom':[lower-KAPPA,upper-KAPPA],'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,
+                                     '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':1,
+                                   'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.',
+                                   'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); sum of local ranks is 5894.'},
+                   'ordinary_BIT':bit,'outer':outer,
+                   'negative_controls':{'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}})
diff --git a/research/p104-free-endpoint-retime/pricing.py b/research/p104-free-endpoint-retime/pricing.py
new file mode 100644
index 0000000000..8d3e006225
--- /dev/null
+++ b/research/p104-free-endpoint-retime/pricing.py
@@ -0,0 +1,156 @@
+"""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 prepared for thu-nmrc with substantial OpenAI Codex assistance.
+Ali Romman's complete caller/price proof and all predecessor credit are retained.
+Apache-2.0.
+"""
+from collections import Counter
+from fractions import Fraction as Q
+import local as L
+
+KAPPA, TESTED = Q('.00308142'), Q('.0030814205')
+PREVIOUS = Q('.00304117')
+
+
+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()) == 12814 and sum(paid.values()) == 66852, '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)
+    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 selected kappa')
+    t,u,v,c,b = 1-TESTED,Q(1,5),1024,17,18
+    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**10),Q(97,100)
+    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),1000
+    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')
+    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':'.00308142','previous_open_pr5545':PREVIOUS,'gain':KAPPA-PREVIOUS,
+                   'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper],
+                   'raw_headroom':[lower-KAPPA,upper-KAPPA],'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,
+                                     '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':1,
+                                   'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.',
+                                   'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); sum of local ranks is 5894.'},
+                   'ordinary_BIT':bit,'outer':outer,
+                   'negative_controls':{'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}})
diff --git a/research/p104-free-endpoint-retime/retime.py b/research/p104-free-endpoint-retime/retime.py
new file mode 100644
index 0000000000..fa8b19a7ce
--- /dev/null
+++ b/research/p104-free-endpoint-retime/retime.py
@@ -0,0 +1,88 @@
+"""Exact checker: a candidate word is a legal helper-endpoint retime of PR5551's pinned word.  Apache-2.0.
+
+Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code.
+
+The two shipped words were found by an exact-lattice CP-SAT retiming (multi-worker, so
+not byte-reproducible); this module is therefore a CHECKER, not a generator.  It proves, with
+stdlib only, that a candidate differs from the pinned word ONLY as follows:
+  1. the non-MOVE scalar program (operation, registers, coefficient, order) is identical;
+  2. the candidate's MOVEs are a subsequence of the pinned MOVEs (stops may be deleted,
+     none added, none reordered across scalar events, same register);
+  3. frame labels may change, but all 208 MAIN registers (104 X sources, 104 Y targets) keep
+     the SAME SPAN at their initial and final frames (X-initial and Y-final are the literal
+     ports).  Intermediate main frames may change where a shared ADD chart moves together
+     with a retimed helper; these are counted, not forbidden;
+  4. the 104 ports, live list and public count are equal.
+Nesting, ownership, rank = dimension gap and the frame law at every ADD/COPY/SCALE are then
+enforced by the unmodified PR5544/5545 local.py replay and native() (see verify.py).
+"""
+
+def rref(basis):
+    """Canonical form of the F2 span of integer bit-vectors (reduced row echelon, sorted)."""
+    rows=[]
+    for v in basis:
+        for r in rows:
+            if v^r<v: v^=r
+        if v:
+            rows=[(r^v if r^v<r else r) for r in rows]; rows.append(v)
+    return tuple(sorted(rows))
+
+def need(ok,why):
+    if not ok: raise ValueError(why)
+
+def spans(w):
+    sp=[rref(b) for b in w['frames']]
+    for b,s in zip(w['frames'],sp): need(len(s)==len(b),'independent frame basis')
+    return sp
+
+def frame_field(e):
+    """Index of the frame label inside an event."""
+    return 2 if e[0] in('INIT','CLEAR') else (-1)
+
+def check(base,w):
+    for k in('schema','public','live','ports'): need(base[k]==w[k],'unchanged '+k)
+    need(len(base['initial'])==len(w['initial'])==base['public'],'register count')
+    bs,ws=spans(base),spans(w)
+    BP,WP=base['program'],w['program']
+    # main registers: live X sources r and their Y targets r+112 (local.py roles); the rest of the 735 are helpers
+    live=base['live']; main=set(live)|{r+112 for r in live}
+    need(len(main)==208,'208 main registers')
+    # (1)+(2) align by greedy subsequence matching, skipping only MOVEs of the pinned program
+    i=0;kept=[];deleted=0;scalar=0;moves_new=0
+    for e in WP:
+        while True:
+            need(i<len(BP),'candidate event has a pinned counterpart')
+            b=BP[i]
+            if e[0]=='MOVE':
+                if b[0]=='MOVE' and b[1]==e[1]: break
+            elif b[0]!='MOVE': break
+            need(b[0]=='MOVE','only MOVEs may be skipped'); deleted+=1; i+=1
+        if e[0]=='MOVE': moves_new+=1
+        else:
+            fi=frame_field(e)
+            a=list(b);c=list(e); a[fi]=c[fi]=None
+            need(a==c,'scalar event unchanged except its frame label'); scalar+=1
+        kept.append((i,e)); i+=1
+    while i<len(BP):
+        need(BP[i][0]=='MOVE','only MOVEs may be skipped at the tail'); deleted+=1; i+=1
+    need(len(WP)+deleted==len(BP),'event accounting')
+    # (3) main registers keep the same span everywhere; helper changes are counted
+    chg_init=sum(1 for r in range(base['public']) if bs[base['initial'][r]]!=ws[w['initial'][r]])
+    chg_fin=sum(1 for r in range(base['public']) if bs[base['final'][r]]!=ws[w['final'][r]])
+    for r in main:
+        need(bs[base['initial'][r]]==ws[w['initial'][r]],'main initial span %d'%r)
+        need(bs[base['final'][r]]==ws[w['final'][r]],'main final span %d'%r)
+    main_mid=0;help_mid=0;lab_chg=0
+    for bi,e in kept:
+        b=BP[bi]
+        if e[0]=='MOVE':
+            if bs[b[2]]!=ws[e[2]] or bs[b[3]]!=ws[e[3]]:
+                if b[1] in main: main_mid+=1
+                else: help_mid+=1
+            continue
+        fi=frame_field(e)
+        if bs[b[fi]]!=ws[e[fi]]: lab_chg+=1
+    # Deleted MOVEs: must be helpers' or owned-register stops
+    return {'scalar_events':scalar,'moves_pinned':sum(e[0]=='MOVE' for e in BP),'moves_candidate':moves_new,
+            'moves_deleted':deleted,'helper_initial_spans_changed':chg_init,'helper_final_spans_changed':chg_fin,
+            'scalar_event_frames_relabelled':lab_chg,'kept_main_moves_relabelled':main_mid,'kept_helper_moves_relabelled':help_mid,'main_registers':len(main)}
diff --git a/research/p104-free-endpoint-retime/verify.py b/research/p104-free-endpoint-retime/verify.py
new file mode 100644
index 0000000000..a69ff28ef2
--- /dev/null
+++ b/research/p104-free-endpoint-retime/verify.py
@@ -0,0 +1,83 @@
+"""Reproduce the conditional kappa of the free helper-endpoint retime of PR5551's word.  Apache-2.0.
+
+Prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code.
+For each shipped word: (1) retime.py proves it is a legal retime of PR5551's pinned word
+(same scalar program, only stops deleted and frame labels changed, all 208 main endpoints
+unchanged); (2) the UNMODIFIED PR5545 local.py replay, transposed columns and native maps accept
+it; (3) the physical caller and PR5551's own pricing (only census/claim literals changed) run
+both moment engines and all 54 strict + 4 functional outer checks; (4) the exact crossing interval.
+Use --part headline (about 6 min) or --part starts-only (about 6 min); default runs both.
+"""
+from fractions import Fraction
+import json,sys
+from pathlib import Path
+sys.dont_write_bytecode=True
+HERE=Path(__file__).resolve().parent
+sys.path.insert(0,str(HERE))
+from common import closure,need,load,read
+import retime
+
+BASE_LINE="KAPPA, TESTED = Q('.00304153'), Q('.0030415305')"
+PAID_LINE='sum(targets.values()) == 12814 and sum(paid.values()) == 69912'
+SURPLUS_LINE='== 760, '
+PARTS={
+ 'headline':{'word':'WORD.json.gz','pricing':'pricing.py','kappa':"Q('.00308142'), Q('.0030814205')",'decimal':'.00308142',
+             'paid':66852,'surplus':760,'helper_finals_changed':23,
+             'interval':['15407121669/5000000000000','308142433381/100000000000000']},
+ 'starts-only':{'word':'WORD-STARTS-ONLY.json.gz','pricing':'pricing-starts-only.py','kappa':"Q('.003076879'), Q('.0030768795')",'decimal':'.003076879',
+             'paid':67374,'surplus':760,'helper_finals_changed':0,
+             'interval':['76922002003/25000000000000','307688008013/100000000000000']},
+}
+
+def patch(text,spec):
+    for a,b in((BASE_LINE,'KAPPA, TESTED = '+spec['kappa']),
+               ("'kappa_decimal':'.00304153'","'kappa_decimal':'%s'"%spec['decimal']),
+               (PAID_LINE,'sum(targets.values()) == 12814 and sum(paid.values()) == %d'%spec['paid']),
+               (SURPLUS_LINE,'== %d, '%spec['surplus'])):
+        need(text.count(a)==1,'pinned pricing literal present once: '+a)
+        text=text.replace(a,b)
+    return text
+
+def chain(root,L,pricing_text,word,tag):
+    sys.modules['local']=L;L.ROOT=root
+    C=L.load(root/'research/p104-productive-controller/caller.py','p104_free_retime_caller_'+tag)
+    tmp=HERE/('.pricing-'+tag+'.py');tmp.write_text(pricing_text)
+    try: P=L.load(tmp,'p104_free_retime_pricing_'+tag)
+    finally: tmp.unlink()
+    loc=L.replay(word);print(tag,'PASS replay: paid',loc['paid'],'public',loc['public_inputs'],'helpers',loc['helpers'],flush=True)
+    L.reverse_columns(word);print(tag,'PASS transposed columns',flush=True)
+    nat=L.native(word);print(tag,'PASS native maps',nat['distinct_maps'],'helpers',nat['helpers'],flush=True)
+    ctl=C.construct();need(ctl==read(root/'research/p104-productive-controller/CONTROLLER.json'),'Exact complete caller')
+    phys=C.physical(ctl,word);print(tag,'PASS physical caller',flush=True)
+    return loc,P.run(loc,nat,ctl,phys)
+
+def main():
+    part=sys.argv[sys.argv.index('--part')+1] if '--part' in sys.argv else 'all'
+    need(part in('all',)+tuple(PARTS),'--part must be headline or starts-only')
+    pinned=read(HERE/'inputs/pr5551-WORD.json.gz')
+    pr_pricing=(HERE/'inputs/pr5551-pricing.py').read_text()
+    out={}
+    with closure() as root:
+        orig_local=(root/'research/p104-productive-controller/local.py').read_text()
+        for name,spec in PARTS.items():
+            if part not in('all',name): continue
+            word=read(HERE/spec['word'])
+            rep=retime.check(pinned,word);print(name,'PASS legal retime of PR5551 word:',rep,flush=True)
+            need(rep['helper_final_spans_changed']==spec['helper_finals_changed'],'helper-final inventory')
+            need((HERE/spec['pricing']).read_text()==patch(pr_pricing,spec),'shipped %s = PR5551 pricing.py + literal changes only'%spec['pricing'])
+            L=load(root/'research/p104-productive-controller/local.py','local');L.ROOT=root
+            need(Path(L.__file__).read_text()==orig_local,'UNMODIFIED PR5545 local.py (735 public inputs, no census literal)')
+            loc,res=chain(root,L,(HERE/spec['pricing']).read_text(),word,name)
+            print(name,'raw crossing interval',res['raw_root_interval'],flush=True)
+            need(res['raw_root_interval']==spec['interval'],'exact crossing interval')
+            need(res['productive_fields']==12814 and res['paid_calls']==spec['paid'] and res['rank_mass_surplus']==spec['surplus'],'invoice')
+            need(len(res['outer']['strict_checks'])==54 and len(res['outer']['functional_checks'])==4,'outer inventory')
+            need(all(Fraction(x)>0 for k in('strict_checks','functional_checks') for x in res['outer'][k].values()),'all outer checks strict')
+            lo,hi=[Fraction(x) for x in spec['interval']]
+            print(name,'crossing kappa in (%.14f, %.14f); 54 strict + 4 functional outer checks pass'%(lo,hi),flush=True)
+            out[name]=res
+    if '--write' in sys.argv and part=='all':
+        (HERE/'RESULT.json').write_text(json.dumps({'status':'PASS_P104_FREE_ENDPOINT_RETIME_CONDITIONAL_KAPPA','headline':out['headline'],
+            'starts_only':out['starts-only']},indent=1,sort_keys=True,default=str)+'\n')
+    print('PASS P104_FREE_ENDPOINT_RETIME',part)
+main()
diff --git a/research/p104-free-endpoint-retime/verify.sh b/research/p104-free-endpoint-retime/verify.sh
new file mode 100755
index 0000000000..d7a4b8e1b5
--- /dev/null
+++ b/research/p104-free-endpoint-retime/verify.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+# usage: research/p104-two-handoffs/verify.sh   (from repository root; Python 3.12, stdlib only)
+exec python3 -B "$(dirname "$0")/verify.py" "$@"
diff --git a/research/wordram-ntt-kernel/VERIFY.json b/research/wordram-ntt-kernel/VERIFY.json
index 4ae0f65622..3e43a2b044 100644
--- a/research/wordram-ntt-kernel/VERIFY.json
+++ b/research/wordram-ntt-kernel/VERIFY.json
@@ -1,7 +1,7 @@
 {
   "format": "standalone source-export research package",
   "inputs": [
-    "MANIFEST.json"
+    "research/wordram-ntt-kernel/MANIFEST.json"
   ],
   "commands": [
     [