cv: temporal purge is the ONLY protocol (user spec) - all48oof fits per scenario on ALL buildings' pairs whose 42d label windows lie fully before/after the scenario window (no building holdout, full-fleet plans); all48/static/screen/lobo/ablate and the lobo/wf/self variants REMOVED (git history keeps them; exp_x29/x30 need the old cv.py); SCORE 1877.3 -> 1972.0 (harsher: warmup 3560.3 vs 2875.3 loses the calendar-local window; panel 1839.6 vs 1857.7)

batteryswap_example/cv.py

@@ -1,52 +1,50 @@
-"""Repo-resident CV protocols (ported from the blind research loop, 2026-08-21).
-
-This replaces the ad-hoc `/tmp/all48*.py` scripts that every prior phase had to
-re-derive, and folds in the three measurement disciplines the blind loop paid
-real leaderboard points to learn.
-
-**1. Report ranking precision at the operating N, not AUC.**
-   A model can hold AUC 0.947 and recall 0.000 on the subgroup that drives the
-   late cost (the voltage-silent deaths: median rank 60 of ~450). Mean cost
-   hides whether a change reordered the list or just cut it deeper. Every
-   protocol here prints rec12/rec20, the operating-point precision, and the
-   median rank of missed deaths beside the cost. Implemented in
-   `models_cv.rank_stats`, so `dev`/`panel`/`test` get it too.
-
-**2. Group by BUILDING > battery > scenario.**
-   Each battery contributes one near-duplicate row per closed origin (~3600
-   rows from ~460 batteries), so holding out a SCENARIO leaves the same
-   batteries in train and test and tree models score their own memorised
-   signatures. Measured in the blind loop: leave-scenario-out put HGB ahead of
-   linear (AUC .9907 vs .9843); leave-battery-out REVERSED it (.9769 vs .9845)
-   and the cost harness agreed with the clean split. The effective sample size
-   is ~460, not ~3600. And battery grouping is still not the deployment split:
-   the scored public/private fleets hold FOREIGN BUILDINGS (organizer design;
-   also how `static` splits), and siblings in one building share install batch
-   and thermal environment, so a battery fold keeps a held-out device's
-   building-mates in train. `screen` runs all three groupings side by side;
-   selection follows the BUILDING column (2026-08-22 protocol change).
-
-**3. The deployment gate: would this fire in the static branch?**
-   The scored splits are fleets the model has never seen; on them `submit.py`
-   fits ONE model on the foreign train pool and never refits - no per-origin
-   refit, no accumulating own history, no cold start (the pool always holds 82
-   deaths, so every `train_deaths < 20` gate is permanently shut). The walk-
-   forward harness does the opposite. A mechanism can be worth tens of points
-   at `all48` and exactly zero where it is scored; that has already happened
-   once (a validated -49.8 warm-up mechanism, structurally unreachable in
-   deployment). `static` runs the deployment protocol locally on a foreign
-   half-fleet so the gate is measurable instead of argued.
-
-   Validity boundary, learned twice the hard way: the half-fleet construction
-   manufactures a sum(p42) undercount that does NOT exist on the real held-out
-   fleet (phase 20 refuted a foreign floor with it; phase 26 adopted
-   ALPHA_STATIC=1.5 from it and public went 1661 -> 2189). Use `static` for
-   ORDERING questions only. Never read an appetite/count decision off it.
+"""THE CV (user directive 2026-08-22): the temporal-purge cost harness.
+
+ONE protocol lives here, deliberately. For each of the 48 scenarios, fit ONE
+model on ALL buildings' training pairs whose 42d label windows lie entirely
+before or after the scenario's own window, predict every device in the
+scenario, plan the FULL fleet, evaluate the cost. THE SCORE is the mean total
+cost per scenario over all 48.
+
+Design notes, paid for in prior phases:
+
+* The purge is on the LABEL window, not just the origin: a pair originating
+  the day before the scenario start carries the scenario's own deaths in its
+  label, so a bare origin-not-in-window cut would leak the events being
+  scored. Non-overlap is `origin + W <= T or origin >= T + W`.
+
+* PLANNING stays full-fleet: the count rule (N ~ 0.8 * sum p42) scales with
+  fleet size, so holding devices out of the plan manufactures a count bias
+  (phase 26).
+
+* Report ranking precision at the operating N beside the cost (rec12/rec20/
+  recall/miss_rank, via `models_cv.rank_stats`): a model can hold AUC 0.947
+  and recall 0.000 on the subgroup that drives the late cost; mean cost hides
+  whether a change reordered the list or just cut it deeper.
+
+* Known optimism channels, accepted by user decision 2026-08-22 with the
+  numbers in view: devices are one-shot events, so same-device pairs from
+  after the scenario can reveal a device's fate through the purge, and
+  after-the-scenario same-fleet data does not exist for the deployed static
+  model. Reference points the day the protocol landed (champion logbag/base):
+  temporal purge 1972.0 vs exact leave-one-building-out 1877.3 vs
+  fit-on-everything 1661.7 - overall the purge read HARSHER than LOBO
+  (losing the calendar-local +/-42d window costs more than building-holdout
+  does; warmup 3560.3 vs 2875.3), slightly softer on the panel block
+  (1839.6 vs 1857.7, recall 0.468 vs 0.461, sched 8.9 vs 9.2).
+
+Superseded protocols (all48 walk-forward self-fit, static half-fleet gate,
+screen fold comparison, LOBO/walk-forward all48oof variants, cv lobo,
+fixed-N ablation) were REMOVED 2026-08-22 per the same directive - one
+instrument, so nothing else can be read by accident. They live in git
+history (last full version: commit 227c214 and its successors that day).
+exp_x29/exp_x30 referenced the removed ablation helpers and need that
+older cv.py to run.
 
 Usage
-    venv/bin/python -m batteryswap_example.cv all48  [variant]
-    venv/bin/python -m batteryswap_example.cv static [variant]
-    venv/bin/python -m batteryswap_example.cv screen
+    venv/bin/python -m batteryswap_example.cv all48oof       # THE SCORE
+    venv/bin/python -m batteryswap_example.cv oofcand <label>
+    venv/bin/python -m batteryswap_example.cv oofreport
 """
 import sys
 import time
@@ -79,7 +77,7 @@ BLOCKS = (('warmup  s_0-7', lambda o: o <= 7),
 
 
 def load_table(dataset_path=Path('dataset')):
-    """The one table build. Every protocol starts here so a variant can never
+    """The one table build. Every run starts here so a variant can never
     silently differ from the champion by a feature-prep line."""
     t = mc.load_features(dataset_path)
     t['v_proj'] = t['v_last'] + t['slope_lastk'] * t['staleness']
@@ -129,222 +127,7 @@ def scorecard(df, label):
 
 
 # --------------------------------------------------------------------------
-# protocol 1: full-fleet walk-forward, s_0..s_47
-# --------------------------------------------------------------------------
-
-def run_all48(variant='base', origins=range(48), dataset_path=Path('dataset')):
-    t = load_table(dataset_path)
-    mc.FEATURES = list(VARIANTS[variant](t))
-    ctx = mc.load_context(dataset_path)
-    df = mc.walk_forward(t, ctx, origins, [dict(CHAMPION)])
-    df['variant'] = variant
-    return df
-
-
-# --------------------------------------------------------------------------
-# protocol 2: the deployment gate - one static fit on a foreign fleet
-# --------------------------------------------------------------------------
-
-def fleet_halves(locations, seed=0):
-    """Split the 24 buildings into two disjoint fleets.
-
-    Split by BUILDING, not by device: rooms and buildings share install
-    batches and thermal environment, so a device-level split leaves the
-    target fleet's own siblings in the training pool and the fit is no longer
-    foreign in the way deployment's is.
-    """
-    b = np.sort(locations['building'].unique())
-    rng = np.random.RandomState(seed)
-    perm = rng.permutation(len(b))
-    a = set(b[perm[:len(b) // 2]])
-    return a, set(b[perm[len(b) // 2:]])
-
-
-def run_static(variant='base', seed=0, origins=range(48),
-               dataset_path=Path('dataset')):
-    """Deployment protocol: fit once on fleet A's fully-closed pairs, then plan
-    every one of fleet B's origins with that single model. No refits, no
-    accumulating own history, no cold-start gate - exactly submit.py's
-    held-out branch."""
-    t = load_table(dataset_path)
-    mc.FEATURES = list(VARIANTS[variant](t))
-    locations, timeseries, eol_times, scenarios = mc.load_dataset(
-        dataset_path / 'train')
-    fleet_a, fleet_b = fleet_halves(locations, seed)
-    dev_bldg = locations.drop_duplicates('battery').set_index('battery')['building']
-    t['bldg'] = t['device_id'].map(dev_bldg)
-
-    # the foreign pool: every fleet-A pair whose 42d window has closed by the
-    # end of the data. Deployment's pool is likewise fully adjudicated at
-    # build time and independent of the target origin.
-    closed = t['origin'] <= t['origin'].max() - pd.Timedelta(days=WINDOW_DAYS)
-    foreign = t[closed & t['bldg'].isin(fleet_a)]
-    model = mc.SklearnRUL(CHAMPION['model']).fit(foreign)
-    uniq = int(foreign.loc[foreign['dies42'] == 1, 'device_id'].nunique())
-    print(f'static foreign fit: {len(foreign)} pairs, {uniq} unique deaths, '
-          f'{len(fleet_a)} buildings | target fleet {len(fleet_b)} buildings',
-          file=sys.stderr)
-
-    p = mc.plan_tsroute
-    p.alpha, p.p_be, p.floor_day, p.p_conf = CHAMPION['p_star'], 0.0, 0, 0.5
-    p.ec_margin, p.ec_pmax = CHAMPION['ec_margin'], CHAMPION['ec_pmax']
-    p.split_days = CHAMPION['split_days']
-    # the cold-start floor is permanently shut in deployment (82 foreign
-    # deaths >= gate 20). Leaving it live here would measure a mechanism the
-    # scored path can never reach.
-    p.floor_scale, p.recent_deaths = 0.0, 0.0
-
-    recs = []
-    for idx, (scenario, locs, cut, eol) in enumerate(mc.iterate_scenarios(
-            locations, timeseries, eol_times, scenarios)):
-        if idx not in origins:
-            continue
-        T = pd.Timestamp(scenario['start_time'])
-        locs_b = locs[locs['building'].isin(fleet_b)]
-        rows = (t[t['origin_idx'] == idx].set_index('device_id')
-                .reindex(locs_b['battery']).dropna(subset=['v_last']))
-        if rows.empty:
-            continue
-        locs_b = locs_b[locs_b['battery'].isin(rows.index)]
-        # the evaluator prices unobserved EOLs off `locations`, so the eol
-        # series has to be cut to the target fleet too
-        eol_b = eol.reindex(locs_b['battery'])
-        pred = model.predict(rows)
-        plan = mc.plan_tsroute(pred, None, locs_b, T, CHAMPION['day_q'],
-                               travel_costs=scenario['travel_costs'],
-                               settings=scenario['settings'])
-        _, _, overall = evaluate_plan(plan, locs_b, scenario['travel_costs'],
-                                      scenario['settings'], eol_times=eol_b,
-                                      start_time=T, verbose=0)
-        rs = mc.rank_stats(pred, plan, eol_b, T)
-        recs.append(dict(overall, **rs, origin=idx, variant=variant, seed=seed))
-        print(f"s_{idx}: total {overall['total_cost']:7.1f} "
-              f"late {overall['late_swap']:6.1f} deaths {rs.get('n_deaths', 0):2d} "
-              f"caught {rs.get('caught', 0):2d}/{rs.get('n_sched', 0):2d} "
-              f"rec12 {rs.get('rec12', float('nan')):.2f}", flush=True,
-              file=sys.stderr)
-    return pd.DataFrame(recs)
-
-
-# --------------------------------------------------------------------------
-# protocol 3: offline model screen, grouped by building > battery
-# --------------------------------------------------------------------------
-
-def building_folds(closed, dev_bldg, n_folds=5, seed=0):
-    """Assign whole BUILDINGS to folds, balancing observed deaths.
-
-    Deaths are lumpy across the 24 buildings (top building holds 15/82, nine
-    hold exactly one), so a random building assignment routinely starves a
-    fold of positives. Greedy balance instead: buildings in descending
-    unique-death order, each to the death-lightest fold so far (ties broken
-    by device load, then by the seed's shuffle).
-    """
-    per_dev = (closed[['device_id', 'dies42']]
-               .assign(bldg=closed['device_id'].map(dev_bldg).values)
-               .groupby('device_id').agg(bldg=('bldg', 'first'),
-                                         died=('dies42', 'max')))
-    per_b = per_dev.groupby('bldg').agg(devices=('died', 'size'),
-                                        deaths=('died', 'sum'))
-    order = (per_b.sample(frac=1, random_state=np.random.RandomState(seed))
-             .sort_values(['deaths', 'devices'], ascending=False, kind='stable'))
-    deaths_in, devs_in = np.zeros(n_folds), np.zeros(n_folds)
-    fold_of = {}
-    for b, row in order.iterrows():
-        f = int(np.lexsort((devs_in, deaths_in))[0])
-        fold_of[b] = f
-        deaths_in[f] += row['deaths']
-        devs_in[f] += row['devices']
-    return pd.Series(fold_of, name='fold')
-
-
-def screen(kinds=('logistic', 'logbag', 'rf', 'gbm'), n_folds=5, seed=0,
-           dataset_path=Path('dataset')):
-    """Leave-BUILDING-out vs leave-BATTERY-out vs leave-SCENARIO-out on the
-    same pairs and the same models. The gaps between columns are contamination;
-    trust the BUILDING column - the scored public/private fleets hold foreign
-    buildings, and building-mates share install batch and thermal environment,
-    so battery folds still leak sibling identity. Headline is recall at the
-    operating N, AUC secondary."""
-    from sklearn.metrics import roc_auc_score
-
-    t = load_table(dataset_path)
-    mc.FEATURES = list(BASE_FEATURES)
-    closed = t[t['origin'] <= t['origin'].max() - pd.Timedelta(days=WINDOW_DAYS)]
-    devs = np.sort(closed['device_id'].unique())
-    rng = np.random.RandomState(seed)
-    dev_fold = pd.Series(rng.permutation(len(devs)) % n_folds, index=devs)
-    org = np.sort(closed['origin_idx'].unique())
-    org_fold = pd.Series(np.arange(len(org)) % n_folds, index=org)
-    dev_bldg = (pd.read_csv(dataset_path / 'train' / 'devices.csv')
-                .drop_duplicates('device_id')
-                .set_index('device_id')['building_id'])
-    bldg_fold = building_folds(closed, dev_bldg, n_folds, seed)
-
-    n_dev_pos = closed.loc[closed['dies42'] == 1, 'device_id'].nunique()
-    print(f'pairs {len(closed)}  batteries {len(devs)}  origins {len(org)}  '
-          f'buildings {bldg_fold.size}  '
-          f'positives {int(closed["dies42"].sum())} rows / {n_dev_pos} batteries')
-    print('effective n is the BATTERY count, not the row count - regularisation '
-          'tuned against rows is ~8x too weak here.\n')
-
-    schemes = {'building': closed['device_id'].map(dev_bldg).map(bldg_fold),
-               'battery': closed['device_id'].map(dev_fold),
-               'scenario': closed['origin_idx'].map(org_fold)}
-    out = {}
-    for scheme, fold in schemes.items():
-        for kind in kinds:
-            aucs, r12, r20 = [], [], []
-            for f in range(n_folds):
-                tr, te = closed[fold != f], closed[fold == f]
-                if te['dies42'].sum() < 3:
-                    continue
-                m = mc.SklearnRUL(kind).fit(tr)
-                p = m.predict(te)['p42']
-                aucs.append(roc_auc_score(te['dies42'], p))
-                # recall at the operating depth, per origin, scaled to the
-                # held-out fleet's size (12/461 of the fleet)
-                for oi, g in te.groupby('origin_idx'):
-                    y = g['dies42'].values
-                    if y.sum() == 0:
-                        continue
-                    n = max(1, int(round(12 * len(g) / 461)))
-                    order = np.argsort(-p.loc[g.index].values)
-                    r12.append(y[order[:n]].sum() / y.sum())
-                    r20.append(y[order[:max(1, int(round(20 * len(g) / 461)))]].sum()
-                               / y.sum())
-            out[(scheme, kind)] = (np.mean(aucs), np.mean(r12), np.mean(r20))
-
-    # LEVELS ARE NOT COMPARABLE ACROSS COLUMNS. A battery fold holds ~1/5 of
-    # the fleet at every origin (recall at depth 12/461 means top-2 of ~92);
-    # a scenario fold holds the whole fleet at 1/5 of the origins (top-11 of
-    # ~430). Same depth fraction, very different discreteness. What IS
-    # comparable is each model's margin over the linear reference WITHIN a
-    # column - that margin is the thing a model-selection decision reads.
-    ref = kinds[0]
-    print(f"{'model':10s} " + ' '.join(f'{s + " " + m:>16s}' for s in schemes
-                                       for m in ('AUC', 'rec12')))
-    for kind in kinds:
-        cells = []
-        for s in schemes:
-            a, r, _ = out[(s, kind)]
-            cells += [f'{a:16.4f}', f'{r:16.3f}']
-        print(f'{kind:10s} ' + ' '.join(cells))
-    print(f'\nmargin over {ref} (the decision-relevant quantity):')
-    for kind in kinds[1:]:
-        cells = []
-        for s in schemes:
-            a, r, _ = out[(s, kind)]
-            a0, r0, _ = out[(s, ref)]
-            cells += [f'{a - a0:+16.4f}', f'{r - r0:+16.3f}']
-        print(f'{kind:10s} ' + ' '.join(cells))
-    print('\nA model whose margin shrinks or reverses as the grouping goes '
-          'scenario -> battery -> building was reading memorised identity at '
-          'that level (battery signatures, then building/batch siblings). '
-          'Selection follows the BUILDING column; it is the only one shaped '
-          'like the scored splits, which hold foreign buildings.')
-    return out
-
-
+# feature variants (candidate re-tests run them through the one harness)
 # --------------------------------------------------------------------------
 
 def _base(t):
@@ -411,11 +194,9 @@ def _ranks(t):
 
 
 def _vrel_bldg(t):
-    # The untested arm of the vrel family: BUILDING-relative voltage. The
-    # phase-44 refutation covers only a fleet-UNIFORM offset (cannot reorder
-    # a linear model); a per-building offset does reorder across buildings,
-    # which is exactly what the building-OOF fit can no longer absorb.
-    # Deployment-legal: computed from the target fleet's own telemetry.
+    # BUILDING-relative voltage: a per-building offset reorders across
+    # buildings. Deployment-legal: computed from the target fleet's own
+    # telemetry.
     if 'vrel_bldg' not in t.columns:
         dev_b = (pd.read_csv(Path('dataset') / 'train' / 'devices.csv')
                  .drop_duplicates('device_id')
@@ -431,202 +212,22 @@ VARIANTS = {'base': _base, 'zone': _zone, 'vcorr': _vcorr, 'vrel': _vrel,
             'v_last_only': _v_last_only, 'blind4': _blind4, 'blind3': _blind3,
             'ranks': _ranks, 'vrel_bldg': _vrel_bldg}
 
-ABLATION = ('base', 'vrel_only', 'vmin7_only', 'vrel', 'v_last_only')
-
-
-# --------------------------------------------------------------------------
-# protocol 4: fixed-N ablation - ORDERING, with the count held out of it
-# --------------------------------------------------------------------------
-
-def _order_stats(p42, deaths, ns):
-    order = p42.sort_values(ascending=False)
-    ranks = {b: r for r, b in enumerate(order.index, start=1)}
-    dr = sorted(ranks[b] for b in deaths if b in ranks)
-    out = {'n_deaths': len(dr), 'mean_rank': float(np.mean(dr))}
-    # COUNTS, not ratios: pooling caught/deaths across origins is the only
-    # correct denominator (a 1-death origin must not outvote a 12-death one)
-    for n in ns:
-        out[f'c{n}'] = sum(1 for r in dr if r <= n)
-    tail = [r for r in dr if r > max(ns)]
-    out['miss_rank'] = float(np.median(tail)) if tail else np.nan
-    return out
-
-
-# Voltage-LEVEL features. A fleet whose sensors sit at a different calibration
-# offset shifts all of these together; every other feature in FEATURES is a
-# difference, a rate, a count or a self-relative fraction (below_frac is scored
-# against the device's OWN baseline) and is therefore offset-invariant. vrel
-# and vmin7_rank are invariant BY CONSTRUCTION - that is what they are for.
-LEVEL_FEATURES = ('v_last', 'v_min_30', 'v_min_7', 'v_corr_last', 'thresh_dist')
-
-
-def apply_fleet_shift(rows, delta, dtau_dv=None):
-    """Simulate a differently-calibrated target fleet.
-
-    The half-fleet gate splits ONE fleet, so both halves share sensor
-    calibration, battery batches and the maintenance era - it has no
-    fleet-level offset by construction and therefore CANNOT test transfer
-    under one. This injects the offset a real held-out fleet may carry.
-
-    vrel and vmin7_rank are recomputed from the shifted values and come out
-    numerically identical; that is the whole point of the comparison.
-    """
-    r = rows.copy()
-    for c in LEVEL_FEATURES:
-        if c in r.columns:
-            r[c] = r[c] + delta
-    if dtau_dv and 'tau_projected' in r.columns:
-        # tau is days-to-threshold read off the temp-corrected curve, so an
-        # offset moves it along the local slope of that curve
-        r['tau_projected'] = r['tau_projected'] + delta * dtau_dv
-    if 'vrel' in r.columns:
-        r['vrel'] = r['v_last'] - r['v_last'].median()
-    if 'vmin7_rank' in r.columns:
-        r['vmin7_rank'] = r['v_min_7'].rank(pct=True)
-    return r
-
-
-def estimate_dtau_dv(t):
-    """Empirical days-of-tau per volt, from the fleet's own corrected curve."""
-    d = t[['tau_projected', 'v_corr_last']].dropna()
-    d = d[d['tau_projected'].abs() < 400]
-    if len(d) < 100:
-        return 0.0
-    return float(np.polyfit(d['v_corr_last'], d['tau_projected'], 1)[0])
-
-
-def ablate(variants=ABLATION, protocol='all48', origins=range(48),
-           ns=(8, 12, 16, 20, 30), seeds=(0, 1, 2, 3, 4),
-           dataset_path=Path('dataset'), shift=0.0, shift_tau=True):
-    """Phase-39's standing directive, made runnable.
-
-    A feature ablation scored on COST cannot answer whether a feature helped:
-    under the topsum rule the feature moves p42, p42 moves sum(p42), and
-    sum(p42) moves N - so depth and order change together and the cost delta
-    is their sum. That is precisely how the blind lineage concluded a
-    4-feature set beat its own champion. This protocol holds N FIXED and
-    varies only the score, so the only thing being measured is the ordering.
-
-    No planner and no evaluator are involved: recall at fixed N and the rank
-    distribution of missed deaths are functions of the score alone.
-    """
-    t = load_table(dataset_path)
-    recs = []
-    if protocol == 'all48':
-        ctx = mc.load_context(dataset_path)
-        for idx in origins:
-            c = ctx[idx]
-            T = c['start_time']
-            tr = mc.training_pairs(t, T)
-            if tr['dies42'].sum() < 3:
-                continue
-            rows = (t[t['origin_idx'] == idx].set_index('device_id')
-                    .reindex(c['locs']['battery']).dropna(subset=['v_last']))
-            eol = c['eol'].reindex(rows.index)
-            deaths = set(eol.index[(eol > T)
-                                   & (eol <= T + pd.Timedelta(days=WINDOW_DAYS))])
-            if not deaths:
-                continue
-            for v in variants:
-                mc.FEATURES = list(VARIANTS[v](t))
-                p = mc.SklearnRUL(CHAMPION['model']).fit(tr).predict(rows)['p42']
-                recs.append(dict(_order_stats(p, deaths, ns),
-                                 origin=idx, variant=v, seed=0))
-            print(f's_{idx}: {len(deaths)} deaths', flush=True, file=sys.stderr)
-    else:
-        locations, timeseries, eol_times, scenarios = mc.load_dataset(
-            dataset_path / 'train')
-        dtau_dv = estimate_dtau_dv(t)
-        if shift:
-            print(f'TARGET-fleet shift {shift:+.3f} V, dtau/dv {dtau_dv:.0f} d/V',
-                  file=sys.stderr)
-        dev_b = locations.drop_duplicates('battery').set_index('battery')['building']
-        t['bldg'] = t['device_id'].map(dev_b)
-        closed = t['origin'] <= t['origin'].max() - pd.Timedelta(days=WINDOW_DAYS)
-        allsc = list(mc.iterate_scenarios(locations, timeseries, eol_times,
-                                          scenarios))
-        for seed in seeds:
-            fleet_a, fleet_b = fleet_halves(locations, seed)
-            foreign = t[closed & t['bldg'].isin(fleet_a)]
-            models = {}
-            for v in variants:
-                mc.FEATURES = list(VARIANTS[v](t))
-                models[v] = mc.SklearnRUL(CHAMPION['model']).fit(foreign)
-            for idx in origins:
-                scenario, locs, cut, eol = allsc[idx]
-                T = pd.Timestamp(scenario['start_time'])
-                locs_b = locs[locs['building'].isin(fleet_b)]
-                rows = (t[t['origin_idx'] == idx].set_index('device_id')
-                        .reindex(locs_b['battery']).dropna(subset=['v_last']))
-                e = eol.reindex(rows.index)
-                deaths = set(e.index[(e > T)
-                                     & (e <= T + pd.Timedelta(days=WINDOW_DAYS))])
-                if not deaths:
-                    continue
-                if shift:
-                    rows = apply_fleet_shift(
-                        rows, shift, dtau_dv if shift_tau else None)
-                for v in variants:
-                    mc.FEATURES = list(VARIANTS[v](t))
-                    p = models[v].predict(rows)['p42']
-                    recs.append(dict(_order_stats(p, deaths, ns),
-                                     origin=idx, variant=v, seed=seed))
-            print(f'seed {seed} done', flush=True, file=sys.stderr)
-    return pd.DataFrame(recs), ns
-
-
-def ablation_report(df, ns, label, ref='base'):
-    print(f'\n=== {label} ===')
-    g = df.groupby('variant')
-    deaths = g['n_deaths'].sum()
-    print(f"{'variant':13s} {'deaths':>6s} " +
-          ' '.join(f'rec@{n:<3d}' for n in ns) +
-          f" {'mean_rk':>7s} {'miss_rk':>7s}")
-    for v in df['variant'].unique():
-        d = df[df['variant'] == v]
-        cells = ' '.join(f'{d[f"c{n}"].sum() / deaths[v]:6.3f}' for n in ns)
-        print(f'{v:13s} {int(deaths[v]):6d} {cells} '
-              f'{d["mean_rank"].mean():7.1f} {d["miss_rank"].median():7.1f}')
-
-    # paired against the reference, per (seed, origin): the only comparison
-    # that survives the origin-to-origin variance in how many deaths there are
-    b = df[df['variant'] == ref].set_index(['seed', 'origin'])
-    print(f'\npaired vs {ref} (per origin, deaths caught at fixed N):')
-    for v in df['variant'].unique():
-        if v == ref:
-            continue
-        o = df[df['variant'] == v].set_index(['seed', 'origin'])
-        cells = []
-        for n in ns:
-            d = (o[f'c{n}'] - b[f'c{n}']).dropna()
-            w, l = int((d > 0).sum()), int((d < 0).sum())
-            cells.append(f'{d.sum():+4.0f} ({w}W/{l}L)')
-        print(f'  {v:13s} ' + '  '.join(cells))
-
 
 # --------------------------------------------------------------------------
-# protocol 5: all48 twin with building-OOF predictions (phase 52 follow-up)
+# THE protocol: full-fleet cost with scenario-clean (temporal-purge) fits
 # --------------------------------------------------------------------------
 
-def run_all48_oof(n_folds=5, seed=0, origins=range(48),
-                  dataset_path=Path('dataset'), kind=None, variant='base',
-                  arms=('self', 'oof'), blend=None, fit='static'):
-    """The walk-forward cost harness with BUILDING-CLEAN predictions.
-
-    all48 itself is temporal, not fold-based, and its PLANNING must stay
-    full-fleet: the count rule scales with fleet size, so holding buildings
-    out of the plan would manufacture the same count bias the static gate
-    carries (phase 26). What CAN be building-grouped is the prediction: here
-    device d's p42 at every origin comes from a model fitted on training
-    pairs from every building EXCEPT d's (OOF stitching), then the FULL
-    fleet is planned exactly as usual. Deployment analogy: the scored fleets
-    are foreign buildings, so this measures the walk-forward cost when the
-    model can never read its own building's identity.
+def run_all48_oof(origins=range(48), dataset_path=Path('dataset'), kind=None,
+                  variant='base', blend=None):
+    """The cost harness with SCENARIO-CLEAN predictions (temporal holdout).
 
-    Both arms (oof and self-fit) run through THIS function's machinery with
-    the cold-start floor off, so the paired per-origin delta isolates the
-    self-fleet fit effect. Levels may differ slightly from canonical all48
-    (floor off, no warm-start state); read the DELTA, not the level.
+    For each scenario, ONE model is fitted on ALL buildings' training pairs
+    whose 42d label windows lie entirely before or after the scenario's own
+    window (origin + W <= T or origin >= T + W), then the FULL fleet is
+    planned and scored exactly as deployment plans it. Buildings are never
+    held out - every device's own history at other times is in train. Early
+    scenarios train mostly on the future side, near-end scenarios mostly on
+    the past side. Cold-start floor off (no warm-start state to gate on).
 
     Candidate re-tests (phase 52 addendum sweep): `kind` swaps the model
     family, `variant` swaps the feature set (VARIANTS key), `blend`=(kind2,
@@ -637,32 +238,12 @@ def run_all48_oof(n_folds=5, seed=0, origins=range(48),
     a post-hoc blend whose beliefs disagree with the count machinery fails
     for that reason alone).
     """
-    # fit='static' (default; user-shaped 2026-08-22): each fold's model is
-    # fitted ONCE on the OTHER buildings' FULL closed history and scores all
-    # 48 origins - exactly deployment's shape (the shipped static model is
-    # one fit on the train fleet's full history through data end, applied at
-    # public origins that are mostly in its past; the competition itself
-    # hands the model future-of-origin FOREIGN-building knowledge, so
-    # respecting a temporal cutoff for other buildings is stricter than the
-    # thing being estimated and it starves warm-up in a way deployment never
-    # does). Calendar co-movement across buildings is therefore IN scope by
-    # design. fit='walkforward' keeps the old per-origin refits.
     kind = kind or CHAMPION['model']
     t = load_table(dataset_path)
     mc.FEATURES = list(VARIANTS[variant](t))
     ctx = mc.load_context(dataset_path)
-    dev_bldg = (pd.read_csv(dataset_path / 'train' / 'devices.csv')
-                .drop_duplicates('device_id')
-                .set_index('device_id')['building_id'])
-    closed = t[t['origin'] <= t['origin'].max() - pd.Timedelta(days=WINDOW_DAYS)]
-    if fit == 'static':
-        # EXACT leave-one-building-out predictions (user spec 2026-08-22):
-        # every device's model excludes precisely its own building - 24
-        # models on 23 buildings each, not 5 fold models on ~19. Folds are
-        # only a cost-saving for the per-origin walkforward variant.
-        bldg_fold = pd.Series({b: b for b in dev_bldg.unique()})
-    else:
-        bldg_fold = building_folds(closed, dev_bldg, n_folds, seed)
+    W = pd.Timedelta(days=WINDOW_DAYS)
+    closed = t[t['origin'] <= t['origin'].max() - W]
 
     p = mc.plan_tsroute
     p.alpha, p.p_be, p.floor_day, p.p_conf = CHAMPION['p_star'], 0.0, 0, 0.5
@@ -670,50 +251,18 @@ def run_all48_oof(n_folds=5, seed=0, origins=range(48),
     p.split_days = CHAMPION['split_days']
     p.floor_scale, p.recent_deaths = 0.0, 0.0
 
-    static_models = {}
-    if fit == 'static':
-        # one fit per fold on the full closed foreign history (+ one all-
-        # buildings fit for the self arm) - the deployment-shaped protocol
-        hazard = kind in ('aft', 'dthaz', 'dthaz_aux', 'logbag_open',
-                          'blend_dh', 'blend_dhaux')
-        pool = (mc.censored_pairs(t, t['origin'].max()) if hazard
-                else t[t['origin'] <= t['origin'].max()
-                       - pd.Timedelta(days=WINDOW_DAYS)])
-        pool_fold = pool['device_id'].map(dev_bldg).map(bldg_fold)
-        make = ((lambda: mc.MODELS[kind]()) if kind in mc.MODELS
-                else (lambda: mc.SklearnRUL(kind)))
-        for f in sorted(bldg_fold.dropna().unique()):
-            static_models[f] = make().fit(pool[(pool_fold != f).values])
-        if 'self' in arms:
-            static_models['SELF'] = make().fit(pool)
-        print(f'static foreign fits: {len(static_models)} on '
-              f'{len(pool)} closed pairs', flush=True, file=sys.stderr)
-
     recs = []
     for idx in origins:
         c = ctx[idx]
         T = c['start_time']
-        tr = mc.training_pairs(t, T)
-        if fit != 'static' and tr['dies42'].sum() < 3:
-            continue
         rows = (t[t['origin_idx'] == idx].set_index('device_id')
                 .reindex(c['locs']['battery']).dropna(subset=['v_last']))
         if rows.empty:
             continue
         locs = c['locs'][c['locs']['battery'].isin(rows.index)]
         eol = c['eol'].reindex(rows.index)
-        tr_fold = tr['device_id'].map(dev_bldg).map(bldg_fold)
-        row_fold = rows.index.to_series().map(dev_bldg).map(bldg_fold)
 
-        def _pred(k, arm):
-            if fit == 'static' and k == kind:
-                if arm == 'self':
-                    return static_models['SELF'].predict(rows)
-                parts = []
-                for f in sorted(row_fold.dropna().unique()):
-                    parts.append(static_models[f].predict(
-                        rows[(row_fold == f).values]))
-                return pd.concat(parts).reindex(rows.index)
+        def _pred(k):
             if k == 'tau':
                 # fit-free pseudo-model: the physics timer as a rank source
                 # (only meaningful inside a value-preserving blend)
@@ -722,156 +271,43 @@ def run_all48_oof(n_folds=5, seed=0, origins=range(48),
                     index=rows.index)
             hazard = k in ('aft', 'dthaz', 'dthaz_aux', 'logbag_open',
                            'blend_dh', 'blend_dhaux')
-            trk = mc.censored_pairs(t, T) if hazard else tr
-            fold_k = (trk['device_id'].map(dev_bldg).map(bldg_fold)
-                      if hazard else tr_fold)
+            # ONE fit on ALL buildings, training-pair label windows disjoint
+            # from the scenario's (T, T+W] window (the purge is approximate
+            # for hazard kinds, whose censored observations can span it)
+            pool = (mc.censored_pairs(t, t['origin'].max()) if hazard
+                    else closed)
+            pool = pool[(pool['origin'] + W <= T) | (pool['origin'] >= T + W)]
             make = ((lambda: mc.MODELS[k]()) if k in mc.MODELS
                     else (lambda: mc.SklearnRUL(k)))
-            if arm == 'self':
-                return make().fit(trk).predict(rows)
-            parts = []
-            for f in sorted(row_fold.dropna().unique()):
-                m = make().fit(trk[fold_k != f])
-                parts.append(m.predict(rows[(row_fold == f).values]))
-            return pd.concat(parts).reindex(rows.index)
-
-        for arm in arms:
-            pred = _pred(kind, arm)
-            if blend is not None:
-                k2, w2 = blend
-                r = ((1 - w2) * pred['p42'].rank(pct=True)
-                     + w2 * _pred(k2, arm)['p42'].rank(pct=True))
-                vals = np.sort(pred['p42'].values)[::-1]
-                pred = pred.copy()
-                pred['p42'] = pd.Series(
-                    vals, index=r.sort_values(ascending=False).index
-                ).reindex(pred.index)
-            plan = mc.plan_tsroute(pred, None, locs, T, CHAMPION['day_q'],
-                                   travel_costs=c['travel_costs'],
-                                   settings=c['settings'])
-            _, _, overall = evaluate_plan(plan, locs, c['travel_costs'],
-                                          c['settings'], eol_times=eol,
-                                          start_time=T, verbose=0)
-            rs = mc.rank_stats(pred, plan, eol, T)
-            recs.append(dict(overall, **rs, origin=idx, arm=arm, seed=seed))
-        if len(arms) == 2:
-            a, b = recs[-2], recs[-1]
-            print(f"s_{idx}: self {a['total_cost']:7.1f}  oof {b['total_cost']:7.1f} "
-                  f"delta {b['total_cost'] - a['total_cost']:+7.1f}",
-                  flush=True, file=sys.stderr)
-        else:
-            print(f"s_{idx}: {arms[0]} {recs[-1]['total_cost']:7.1f}",
-                  flush=True, file=sys.stderr)
-    return pd.DataFrame(recs)
-
-
-def run_lobo(origins=range(48), dataset_path=Path('dataset'), kind=None,
-             variant='base'):
-    """Leave-One-Building-Out CV (user-specified 2026-08-22): for each
-    scenario, for each building, train on ALL OTHER buildings' full closed
-    history (static, one fit per building - 24 fits total, reused across
-    scenarios) and plan/score THAT building alone in that scenario.
-
-    CV-first doctrine: this evaluates the current model as-is, including
-    where its count rule (N = 0.8 * sum p42) breaks at building scale -
-    those breaks are the model-adaptation to-do list, not instrument noise.
-    Per-building planning removes cross-building travel/limit coupling, so
-    this instrument governs prediction+inclusion (late/early, ~85% of cost);
-    routing questions keep the full-fleet harness as the secondary check.
-    """
-    kind = kind or CHAMPION['model']
-    t = load_table(dataset_path)
-    mc.FEATURES = list(VARIANTS[variant](t))
-    ctx = mc.load_context(dataset_path)
-    dev_bldg = (pd.read_csv(dataset_path / 'train' / 'devices.csv')
-                .drop_duplicates('device_id')
-                .set_index('device_id')['building_id'])
-    pool = t[t['origin'] <= t['origin'].max() - pd.Timedelta(days=WINDOW_DAYS)]
-    pool_b = pool['device_id'].map(dev_bldg)
-    make = ((lambda: mc.MODELS[kind]()) if kind in mc.MODELS
-            else (lambda: mc.SklearnRUL(kind)))
-    fits = {}
-    for b in sorted(dev_bldg.unique()):
-        fits[b] = make().fit(pool[(pool_b != b).values])
-    print(f'lobo: {len(fits)} leave-one-building-out static fits on '
-          f'{len(pool)} closed pairs', file=sys.stderr, flush=True)
-
-    p = mc.plan_tsroute
-    p.alpha, p.p_be, p.floor_day, p.p_conf = CHAMPION['p_star'], 0.0, 0, 0.5
-    p.ec_margin, p.ec_pmax = CHAMPION['ec_margin'], CHAMPION['ec_pmax']
-    p.split_days = CHAMPION['split_days']
-    p.floor_scale, p.recent_deaths = 0.0, 0.0
-
-    recs = []
-    for idx in origins:
-        c = ctx[idx]
-        T = c['start_time']
-        rows_all = (t[t['origin_idx'] == idx].set_index('device_id')
-                    .reindex(c['locs']['battery']).dropna(subset=['v_last']))
-        for b, locs_b in c['locs'].groupby(c['locs']['battery'].map(dev_bldg)):
-            rows = rows_all.reindex(locs_b['battery']).dropna(subset=['v_last'])
-            if rows.empty:
-                continue
-            locs_b = locs_b[locs_b['battery'].isin(rows.index)]
-            eol_b = c['eol'].reindex(rows.index)
-            pred = fits[b].predict(rows)
-            plan = mc.plan_tsroute(pred, None, locs_b, T, CHAMPION['day_q'],
-                                   travel_costs=c['travel_costs'],
-                                   settings=c['settings'])
-            _, _, ov = evaluate_plan(plan, locs_b, c['travel_costs'],
-                                     c['settings'], eol_times=eol_b,
-                                     start_time=T, verbose=0)
-            WE = T + pd.Timedelta(days=WINDOW_DAYS)
-            deaths = set(eol_b.index[(eol_b > T) & (eol_b <= WE)])
-            sched = set(plan.loc[plan['day'] <= WE, 'battery'])
-            recs.append(dict(origin=idx, building=b, n_dev=len(rows),
-                             total=ov['total_cost'], late=ov['late_swap'],
-                             early=ov['early_swap'],
-                             n_deaths=len(deaths), caught=len(sched & deaths),
-                             n_sched=len(sched)))
-        d = pd.DataFrame([r for r in recs if r['origin'] == idx])
-        if not d.empty:
-            starved = int(((d['n_sched'] == 0) & (d['n_deaths'] > 0)).sum())
-            print(f"s_{idx}: mean/bldg {d['total'].mean():7.1f}  "
-                  f"sum {d['total'].sum():8.1f}  "
-                  f"deaths {int(d['n_deaths'].sum()):2d} caught "
-                  f"{int(d['caught'].sum()):2d}  zero-swap-with-death bldgs "
-                  f"{starved}", flush=True, file=sys.stderr)
+            return make().fit(pool).predict(rows)
+
+        pred = _pred(kind)
+        if blend is not None:
+            k2, w2 = blend
+            r = ((1 - w2) * pred['p42'].rank(pct=True)
+                 + w2 * _pred(k2)['p42'].rank(pct=True))
+            vals = np.sort(pred['p42'].values)[::-1]
+            pred = pred.copy()
+            pred['p42'] = pd.Series(
+                vals, index=r.sort_values(ascending=False).index
+            ).reindex(pred.index)
+        plan = mc.plan_tsroute(pred, None, locs, T, CHAMPION['day_q'],
+                               travel_costs=c['travel_costs'],
+                               settings=c['settings'])
+        _, _, overall = evaluate_plan(plan, locs, c['travel_costs'],
+                                      c['settings'], eol_times=eol,
+                                      start_time=T, verbose=0)
+        rs = mc.rank_stats(pred, plan, eol, T)
+        recs.append(dict(overall, **rs, origin=idx, arm='oof'))
+        print(f"s_{idx}: oof {recs[-1]['total_cost']:7.1f}",
+              flush=True, file=sys.stderr)
     return pd.DataFrame(recs)
 
 
-def lobo_report(df):
-    per = df.groupby('origin').agg(mean_bldg=('total', 'mean'),
-                                   sum_=('total', 'sum'),
-                                   deaths=('n_deaths', 'sum'),
-                                   caught=('caught', 'sum'),
-                                   sched=('n_sched', 'sum'))
-    print('\n=== lobo / leave-one-building-out, per scenario ===')
-    print(f"{'scen':>5s} {'mean/bldg':>9s} {'sum':>9s} {'deaths':>6s} "
-          f"{'caught':>6s} {'sched':>5s}")
-    for i, r in per.iterrows():
-        print(f"s_{i:<3d} {r['mean_bldg']:9.1f} {r['sum_']:9.1f} "
-              f"{int(r['deaths']):6d} {int(r['caught']):6d} {int(r['sched']):5d}")
-    for name, sel in BLOCKS:
-        m = per.index.to_series().apply(sel)
-        d = per[m.values]
-        if d.empty:
-            continue
-        dfb = df[df['origin'].isin(d.index)]
-        starved = int(((dfb['n_sched'] == 0) & (dfb['n_deaths'] > 0)).sum())
-        print(f"{name:16s} mean/bldg {d['mean_bldg'].mean():7.1f}  "
-              f"sum/scen {d['sum_'].mean():8.1f}  recall "
-              f"{d['caught'].sum() / max(d['deaths'].sum(), 1):.3f}  "
-              f"zero-swap-death building-scenarios {starved}")
-    print('\nHEADLINE = mean/bldg on the panel. zero-swap-with-death = the '
-          'count-granularity break the model adaptation must fix.')
-
+# --------------------------------------------------------------------------
+# candidate sweep on the one harness
+# --------------------------------------------------------------------------
 
-# The re-test grid for the phase 52 addendum sweep: every prediction-side
-# candidate the campaign rejected on a self-fit or scenario-grouped surface,
-# re-asked on the building-OOF cost harness. Planner/appetite candidates are
-# deliberately absent - that axis is closed and this harness would not
-# change its answer.
 OOF_CANDIDATES = {
     'logistic': dict(kind='logistic'),
     'rf': dict(kind='rf'),
@@ -908,7 +344,7 @@ def oof_candidate_report(base_csv='/tmp/cv_all48oof.csv',
     import glob
     base = pd.read_csv(base_csv)
     b = base[base['arm'] == 'oof'].set_index('origin')
-    print('paired vs champion oof arm (logbag/base, floor off, fold seed 0).')
+    print('paired vs champion (logbag/base, temporal purge, floor off).')
     print('sched/rec12 shown because a cost delta can be appetite in '
           'disguise (phase 39/51): trust a win only if sched is ~flat.\n')
     hdr = (f"{'candidate':14s} {'ALL48':>7s} {'delta':>7s} {'W/L':>7s} "
@@ -933,90 +369,37 @@ def oof_candidate_report(base_csv='/tmp/cv_all48oof.csv',
 
 
 def oof_report(df):
-    arms = [a for a in ('oof', 'self') if (df['arm'] == a).any()]
-    for arm in arms:
-        label = 'building-clean' if arm == 'oof' else 'validity-check arm'
-        scorecard(df[df['arm'] == arm], f'all48oof / arm={arm} / {label} / floor off')
-    if 'oof' in arms:
-        # THE SCORE (user, 2026-08-22): one number - the mean cost per
-        # scenario over all 48, full-fleet plans, building-clean predictions.
-        # Blocks above are diagnostics.
-        o = df[df['arm'] == 'oof']
-        print(f"\nSCORE (building-split CV, single value): "
-              f"{o['total_cost'].mean():.1f}")
-    if 'self' not in arms:
-        return
-    # the paired flattery term - only shown when the self arm was requested
-    s = df[df['arm'] == 'self'].set_index('origin')['total_cost']
-    o = df[df['arm'] == 'oof'].set_index('origin')['total_cost']
-    d = (o - s).dropna()
-    for name, sel in BLOCKS:
-        dd = d[sel(pd.Series(d.index, index=d.index))]
-        if dd.empty:
-            continue
-        w, l = int((dd < 0).sum()), int((dd > 0).sum())
-        print(f'{name:16s} oof-minus-self {dd.mean():+7.1f}/origin '
-              f'(sum {dd.sum():+8.1f}, oof-better {w}W / self-better {l}L)')
-    print('\nPositive delta = self-fleet fitting was flattering the '
-          'walk-forward by that much; the scored fleets are foreign '
-          'buildings, so the oof arm is the transfer-shaped cost estimate.')
+    scorecard(df, 'all48oof / scenario-clean (temporal purge) / floor off')
+    # THE SCORE (user, 2026-08-22): one number - the mean cost per scenario
+    # over all 48, full-fleet plans, scenario-clean predictions. Blocks
+    # above are diagnostics.
+    print(f"\nSCORE (scenario-clean temporal purge, mean cost/scenario): "
+          f"{df['total_cost'].mean():.1f}")
 
 
 def main():
-    proto = sys.argv[1] if len(sys.argv) > 1 else 'all48'
-    variant = sys.argv[2] if len(sys.argv) > 2 else 'base'
+    proto = sys.argv[1] if len(sys.argv) > 1 else 'all48oof'
     t0 = time.time()
-    if proto == 'all48':
-        df = run_all48(variant)
-        df.to_csv(f'/tmp/cv_all48_{variant}.csv', index=False)
-        scorecard(df, f'all48 / {variant} / full-fleet walk-forward')
-    elif proto == 'static':
-        # one building split is one draw; a variant comparison needs several.
-        # 11s a seed, so there is no excuse for reading a single one.
-        seeds = range(int(sys.argv[3]) if len(sys.argv) > 3 else 5)
-        df = pd.concat([run_static(variant, seed=s) for s in seeds],
-                       ignore_index=True)
-        df.to_csv(f'/tmp/cv_static_{variant}.csv', index=False)
-        for s in seeds:
-            scorecard(df[df['seed'] == s], f'static / {variant} / seed {s}')
-        scorecard(df, f'static / {variant} / DEPLOYMENT GATE, {len(seeds)} '
-                      f'building splits pooled')
-        print('Levels are NOT comparable to all48 (half the fleet, half the '
-              'deaths, and the count rule scales with the fleet). Read this '
-              'protocol only as variant-vs-variant, ORDERING only - never for '
-              'an appetite/count decision (see module docstring).')
-    elif proto == 'screen':
-        screen()
-    elif proto == 'all48oof':
-        # THE SCORE (user directives 2026-08-22): oof arm, STATIC fit
-        # protocol (one fit per fold on the other buildings' full closed
-        # history - deployment's shape). `cv all48oof self` adds the self
-        # arm (flattery readout); `cv all48oof wf` uses the old per-origin
-        # walk-forward refits (whose self arm reproduces panel 1679.2).
-        arms = ('self', 'oof') if variant == 'self' else ('oof',)
-        fitp = 'walkforward' if variant == 'wf' else 'static'
-        df = run_all48_oof(arms=arms, fit=fitp)
+    if proto == 'all48oof':
+        # THE SCORE (user directive 2026-08-22 v2): per scenario, one fit on
+        # ALL buildings' pairs purged of the scenario's 42d window; no
+        # building holdout; full-fleet plan; mean cost over the 48.
+        df = run_all48_oof()
         df.to_csv('/tmp/cv_all48oof.csv', index=False)
         oof_report(df)
     elif proto == 'oofcand':
         label = sys.argv[2]
-        df = run_all48_oof(arms=('oof',), **OOF_CANDIDATES[label])
+        df = run_all48_oof(**OOF_CANDIDATES[label])
         df['cand'] = label
         df.to_csv(f'/tmp/cv_oofcand_{label}.csv', index=False)
-        scorecard(df, f'all48oof / cand={label} / oof arm / floor off')
-    elif proto == 'lobo':
-        df = run_lobo()
-        df.to_csv('/tmp/cv_lobo.csv', index=False)
-        lobo_report(df)
+        scorecard(df, f'all48oof / cand={label} / temporal purge / floor off')
     elif proto == 'oofreport':
         oof_candidate_report()
-    elif proto == 'ablate':
-        which = sys.argv[2] if len(sys.argv) > 2 else 'all48'
-        df, ns = ablate(protocol=which)
-        df.to_csv(f'/tmp/cv_ablate_{which}.csv', index=False)
-        ablation_report(df, ns, f'fixed-N ablation / {which}')
     else:
-        raise SystemExit(f'unknown protocol {proto}')
+        raise SystemExit(
+            f'unknown protocol {proto!r} - the temporal-purge harness is the '
+            f'only CV (user directive 2026-08-22). all48/static/screen/lobo/'
+            f'ablate were removed; recover from git history if ever needed.')
     print(f'\n[{time.time() - t0:.0f}s]')