Phase 28 public refutation: revert static appetite to 0.8, cliff boost off

Public look 2026-08-20 (6ea03da): 2188.78 vs 1661.45 (3c7b883). First public
exposure of the whole static stack at once; component signature is pure
over-inclusion - battery_swap +68%, early +444, late +13 (zero recall gain).

- ALPHA_STATIC default 1.5 -> 0.8: phase 26's undercount premise is refuted
on the real held-out fleet; phase 20 (the probability scale transfers /
overcounts) was right. The half-fleet holdout manufactures the undercount
(~6 deaths/scenario makes inclusions look cheap; marginal exchange rate
0.46 late-saved per early-spent locally, ~0.03 on public, break-even 1.0)
and is hereby refuted as an appetite adjudicator - count decisions are
public-look-only now. It stays valid for structural questions.
- CLIFF_SCALE default 2.2 -> 1.0: the boost was only ever adjudicated on top
of the refuted 1.5 baseline, and the public look condemns it transitively
(every cliff device was included at 1.5 + boost and late did not move).
- Retained: static-fit machinery (24b, structural), phase-27 penalty wiring
and failure isolation. Ledger addendum in EXPERIMENTS.md phase 28.

Verified: rehearsal on fake held-out splits (static path, no boost lines,
swap counts at 0.8 appetite); all-48 Docker byte-exact 1851.0186805555559.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

EXPERIMENTS.md

@@ -1143,6 +1143,32 @@ target, censored-anchor pricing, exact-cost-model optimization, building
 group moves (phase-7/22 search saturation), isotonic rejection, CDF lag
 (they over-swap early; we under-swap).
 
+**Public outcome (2026-08-20, submission 6ea03da): REFUTED - and it refutes
+phase 26 with it.** 2188.78 vs 1661.45 (3c7b883, still the live phase-23
+rolling config at alpha=0.8). This was the first public exposure of the
+ENTIRE static stack at once (24b static fit + 26 ALPHA_STATIC=1.5 + 27
+wiring + 28 cliff boost). Component signature: battery_swap 3.02 -> 5.08
+(+68% swaps), early 137 -> 582 (+444), ops +70, late 1212 -> 1225 (+13 -
+ZERO recall gain). That is pure over-inclusion: on the real held-out fleet
+the probability scale transfers (phase 20's finding: half-fleet sum(p42)
+15.8 vs 9.1 true, it OVER-counts), and the half-fleet holdout construction
+that phase 26 and phase 28 both relied on manufactures the undercount their
+gains priced in. Late cost on public is saturated by voltage-silent deaths
+(the phases-1/6 result, again). Defaults reverted (ALPHA_STATIC=0.8,
+CLIFF_SCALE=1.0; static-fit machinery and phase-27 hardening retained).
+Standing lesson for every future phase: **the half-fleet holdout is refuted
+as an appetite adjudicator** - it disagreed with phase 20 and public sided
+with phase 20; appetite changes are public-look-only decisions now. WHY it
+mispredicts (parallel session, deployment-faithful sweep same day): the
+half-fleet scenarios carry ~6 deaths against public's much larger fleet, so
+added inclusions look cheaper than they are; the measured marginal exchange
+rate is 0.46 late-saved per early-spent at alpha 1.5->2.0 locally (0.21 at
+2.0->2.5) and ~0.03 on public - all far below the 1.0 break-even. The
+half-fleet holdout remains valid for structural/mechanical questions
+(static-vs-rolling, failure isolation), not for anything count-related. The
+cliff boost's solo effect at alpha=0.8 is unproven (it was only ever
+measured on top of the refuted 1.5 baseline) and stays off by default.
+
 ## Phase 29 - fresh-eyes slate: generative label model, arrival rank/features, planner add/drop, policy control (all rejected; label-noise floor quantified)
 
 Trigger: user-requested outside review ("maybe we went in the wrong direction
@@ -1352,6 +1378,53 @@ devices live LONGER (r = +0.20), opposite the self-discharge story -
 consistent with cold raising internal resistance and pulling the 2.40
 crossing earlier.
 
+## Phase 32 - "is p42 dangerous?" - window-portability bug FIXED, miss-cost ranking rejected
+
+Two user hypotheses about p42, both tested; one found a real catastrophic-tail
+bug, the other closed a channel.
+
+**(a) Window portability.** Worry: public/private could use a window other
+than 42d. The evaluator honours `planning_window_days` per scenario, so this
+is directly measurable: score unchanged plans against 28/56/84d evaluators.
+
+| evaluator window | before fix | after fix |
+|---|---|---|
+| 28d | 728.5 | 728.5 (inert) |
+| 42d | 1086.6 | 1086.6 (byte-identical) |
+| 56d | **23581.9** | **1688.0** |
+| 84d | (same failure mode) | 3283.1 |
+
+The model side degrades gracefully; the danger was in the OUTPUT convention.
+plan_tsroute parks non-included batteries at day 43 and relies on the
+evaluator cutting rows past the window - with W > 42 the evaluator EXECUTES
+all ~200 parked rows as real swaps and charges early penalties on the whole
+fleet. **Fixed** (`repark_for_window`, applied in all three plan paths):
+parked rows move to `max(W, 42)+1` read from the live settings. Inert at
+W <= 42 by construction (all-48 checksum byte-exact). Residual rise at 56/84d
+is legitimate, not a bug: a longer window simply contains deaths a 42d-ahead
+planner never scheduled for.
+
+**(b) Miss-cost inclusion ranking (rejected).** Hypothesis: late_swap is high
+because inclusion ranks by raw p42, which treats a day-5 death (~430 if
+missed) like a day-40 death (~80). Tested `rank_score = p42 x E[late penalty
+if parked]` on the static held-out path (same alpha=1.5 count, same planner,
+only the boundary ORDER changes), 3 fleet splits x 16 origins:
+
+| run | p42 | miss-cost | delta |
+|---|---|---|---|
+| s0 | 925.9 | 894.9 | -31.0 |
+| s0 reversed | 778.6 | 815.1 | +36.4 |
+| s1 | 914.0 | 898.7 | -15.3 |
+
+13W/12L/23T - no unanimity, rejected under the phase-26 standard. The
+mechanism does what it claims where it wins (late 462->439, 524->504) but the
+gains are small and reverse on one split: **p42 and death-day are strongly
+correlated** (a confident p42 usually means already-deep decline, i.e. dying
+soon), so the boundary is already nearly cost-ordered and the differences
+trade on day-quantile noise. Conclusion for the record: the residual
+late_swap is NOT mis-ordering among visible deaths - it is the voltage-silent
+deaths (channel closed, phases 6-13) plus label-lag noise.
+
 ## Test-look ledger
 
 8 looks total (now historical - see protocol change above); look 9 = the

batteryswap_example/submit.py

@@ -52,14 +52,16 @@ MODEL_KIND = 'logbag'
 # late saturates ~1100 regardless - the remaining misses are voltage-silent
 # deaths that no inclusion appetite can catch.
 ALPHA = float(os.environ.get('BATTERYSWAP_ALPHA', '0.8'))
-# Phase 26: on a held-out fleet the static foreign fit's sum(p42) undercounts
-# (holdout: 5.5 vs 8 true deaths), so the static path needs a larger
-# inclusion appetite. Holdout sweep (4 runs, 3 seeds + reversed fleets):
-# 1.3 beats 0.8 in all four; curve flattens from 1.5 (0.8: 1156 -> 1.5: 916).
-# 1.5 takes ~93% of the gain without the plateau's over-inclusion edge.
-# Only the static branch reads this; the rolling/native path keeps ALPHA=0.8
-# where the panel decisively rejected higher appetites (phases 1/6).
-ALPHA_STATIC = float(os.environ.get('BATTERYSWAP_ALPHA_STATIC', '1.5'))
+# Phase 26 adopted ALPHA_STATIC=1.5 from the half-fleet holdout ("the static
+# foreign fit undercounts sum(p42)"). PUBLIC REFUTED IT (2026-08-20,
+# submission 6ea03da: 2188.78 vs 1661.45, battery_swap +68%, early +444,
+# late +13 - pure over-inclusion, zero recall gain): on the real held-out
+# fleet the probability scale transfers, exactly as the phase-20 fleet
+# holdout found (sum(p42) 15.8 vs 9.1 true - if anything it OVER-counts).
+# The half-fleet construction manufactures the undercount; do not trust it
+# for appetite decisions. Late cost is saturated by voltage-silent deaths
+# that no inclusion appetite can catch (phases 1/6). Default back to 0.8.
+ALPHA_STATIC = float(os.environ.get('BATTERYSWAP_ALPHA_STATIC', '0.8'))
 # Break-even top-up (phase 11): additionally include every FRESH battery
 # (imputed EOL beyond the window) whose best-day expected cost beats parking,
 # gated to fire only where a wrong inclusion costs <= EC_PMAX. Empty at
@@ -94,7 +96,13 @@ FLOOR_GATE = int(os.environ.get('BATTERYSWAP_FLOOR_GATE', '20'))
 # (alpha=2.0: -55 but sd 298 and worst +421; alpha=2.5 turns NEGATIVE).
 # The native rolling path rejected it (panel +27): static branch ONLY.
 # CLIFF_SCALE=1.0 disables (boost becomes the identity).
-CLIFF_SCALE = float(os.environ.get('BATTERYSWAP_CLIFF_SCALE', '2.2'))
+# PUBLIC (2026-08-20, 6ea03da at ALPHA_STATIC=1.5 + CLIFF_SCALE=2.2):
+# 2188.78 - the stacked appetite over-included with zero recall gain. The
+# cliff boost was adjudicated ON TOP of the 1.5 baseline whose own premise
+# public refuted, so its holdout gain is unproven at appetite 0.8 on the
+# real fleet. Disabled by default until (if ever) a public look at
+# ALPHA_STATIC=0.8 + CLIFF_SCALE=2.2 isolates its solo effect.
+CLIFF_SCALE = float(os.environ.get('BATTERYSWAP_CLIFF_SCALE', '1.0'))
 CLIFF_FRAC = 0.35
 CLIFF_V = 2.46
 CLIFF_MIN_N = 20
@@ -317,6 +325,7 @@ def adaptive_split_plans(split, split_path, log=print, deadline=None):
         plan = plan_tsroute(pred, None, locs, T, 0.05,
                             travel_costs=scenario['travel_costs'],
                             settings=scenario['settings'])
+        plan = repark_for_window(plan, T, scenario['settings'], log)
         plan['split'] = split
         plan['scenario'] = scenario['name']
         plans.append(plan)
@@ -325,6 +334,30 @@ def adaptive_split_plans(split, split_path, log=print, deadline=None):
     return plans
 
 
+def repark_for_window(plan, T, settings, log=print):
+    """Move parked rows past the ACTUAL window end.
+
+    plan_tsroute (and the pickled planner) park non-included batteries at
+    day 43, relying on the evaluator cutting rows past the window. That
+    convention hard-wires 42 into the OUTPUT: with planning_window_days > 42
+    the evaluator would EXECUTE every parked row as a real swap and charge
+    early penalties on the whole fleet (measured on a 56d evaluator: 23582
+    vs 1087 - a 20x blow-up). Inert at W <= 42, where day 43 is already
+    outside the window (checksum-verified byte-identical).
+    """
+    W = int(settings.planning_window_days)
+    if W <= WINDOW_DAYS:
+        return plan
+    parked_day = (T + pd.Timedelta(days=WINDOW_DAYS + 1)).normalize()
+    mask = plan['day'] == parked_day
+    if not mask.any():
+        return plan
+    log(f'  window={W}d > {WINDOW_DAYS}d: re-parking {int(mask.sum())} rows')
+    plan = plan.copy()
+    plan.loc[mask, 'day'] = (T + pd.Timedelta(days=W + 1)).normalize()
+    return plan.sort_values('day', kind='stable').reset_index(drop=True)
+
+
 def fallback_split_plans(split, split_path, log=print):
     log(f'  FALLBACK to static pickle for split={split}')
     with open(Path(__file__).parent / 'planners' / 'best.pickle', 'rb') as f:
@@ -334,6 +367,8 @@ def fallback_split_plans(split, split_path, log=print):
     for scenario, locs, cut, eol in iterate_scenarios(
             locations, timeseries, eol_times, scenarios):
         plan = planner.plan(cut, locs, scenario['travel_costs'], scenario['settings'])
+        plan = repark_for_window(plan, pd.Timestamp(scenario['start_time']),
+                                 scenario['settings'], log)
         plan['split'] = split
         plan['scenario'] = scenario['name']
         plans.append(plan)
@@ -357,8 +392,11 @@ def last_resort_split_plans(split, split_path, log=print):
         T = pd.Timestamp(s['start_time'])
         e = eol.reindex(devices['device_id'])
         alive = devices['device_id'][e.isna().values | (e > T).values]
+        W = max(int(s['settings']['planning_window_days'])
+                if isinstance(s.get('settings'), dict) else WINDOW_DAYS,
+                WINDOW_DAYS)
         plans.append(pd.DataFrame({
-            'day': (T + pd.Timedelta(days=WINDOW_DAYS + 1)).normalize(),
+            'day': (T + pd.Timedelta(days=W + 1)).normalize(),
             'battery': alive.values,
             'split': split,
             'scenario': s['name'],