Phase 57: CV replaced with building-GroupKFold (user directive) - test group planned as standalone fleet, stratified on failures + travel centrality

Simulates the held-out deployment path (static foreign fit) the private
split's unseen fleets take. Purge harness retired (three deployment blind
spots, phase 56); recoverable at f5f3fda.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

EXPERIMENTS.md

@@ -3110,3 +3110,22 @@ candidate survives count-matched adjudication. Instruments going forward:
 deployment-mirror walk-forward (past-only fits) as the public predictor;
 building-GroupKFold with test-group-planned-as-fleet (user proposal,
 2026-08-22) as the held-out/private-fleet predictor.
+
+## Phase 57 - CV replaced (user directive v3): building-GroupKFold, test group planned as a standalone fleet
+
+The temporal purge is RETIRED as THE SCORE (its three deployment blind spots
+are the phase-56 record). New sole harness in cv.py: buildings -> 5 folds,
+stratified deterministically on failure count (snake assignment; fold deaths
+22/18/14/15/13 over 5/5/5/5/4 buildings) and travel centrality as the
+location proxy. Per fold: ONE fit on the TRAIN buildings' closed pairs (full
+history - deployment-legal for foreign fleets), then for each of the 48
+scenario times the TEST buildings are planned as a COMPLETE standalone fleet
+and costed. SCORE = mean over folds of fold-mean cost. This is a measured
+simulation of submit.py's held-out (static foreign fit) path - the path the
+private split's unseen fleets will take - with no per-building attribution
+problem (the fleet IS the test group) and no partial-fleet count bias
+(phase 26). Fits never see the test buildings; nothing sees the future of a
+label it trains on beyond what deployment itself would know.
+CLI: `cv bgkf` / `cv cand <label>` / `cv report`. Purge harness recoverable
+at f5f3fda; walk-forward family at 2000281. Candidate rule strengthened by
+phase 56: wins must hold at ~flat swaps PER CELL, not just at the mean.

batteryswap_example/cv.py

@@ -1,52 +1,46 @@
-"""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).
-
-* Diagnostics are PLAN-DERIVED only (cost blocks + in-window swap count).
-  The pred-shape ranking metrics (rec12/rec20/recall/prec/miss_rank) were
-  removed 2026-08-22 (user): they assumed the method emits a per-device p42
-  ranking, which not every method will. The harness scores anything that
-  yields a plan; `models_cv.rank_stats` remains for ad-hoc ordering
-  diagnostics on methods that do rank.
-
-* 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.
+"""THE CV (user directive 2026-08-22 v3): building-GroupKFold cost harness.
+
+ONE protocol lives here, deliberately. Buildings are assigned to K folds,
+stratified on battery-failure count and location (travel centrality). For
+each fold: fit ONE model on ALL closed training pairs of the TRAIN buildings
+(their full history - deployment-legal for foreign fleets, whose labels were
+all known when the submission was built), then for each of the 48 scenario
+times plan the TEST buildings as a STANDALONE fleet and evaluate its cost.
+THE SCORE is the mean over folds of the fold's mean scenario cost.
+
+Why this protocol (2026-08-22, the day the temporal purge fell):
+
+* It simulates the HELD-OUT deployment path: the competition's private split
+  contains fleets not in the packaged train table (submit.py's static
+  foreign-fit branch exists for exactly this). Train-on-some-buildings /
+  plan-the-others-as-a-fleet is that path, measured.
+
+* The test group is planned as a COMPLETE fleet, so there is no per-building
+  cost-attribution problem (the old LOBO objection) and no partial-fleet
+  count bias (phase 26): the count rule operates on the test fleet's own
+  sum(p42), exactly as deployment does on a held-out fleet.
+
+* The retired temporal purge was refuted as a deployment predictor three
+  ways in one day (phase 56): count-coupled changes (purge loved alpha 1.5,
+  public +527), label-process exploits (cert-first re-derived at its exact
+  pre-refutation signature), and era-hazard calibration leak through
+  future-side fits (the frontier: purge -341.7 -> public +215.6; the gain
+  was a hidden per-scenario appetite dial, corr(count delta, cost gain)
+  0.76). The common thread: its fits saw the future. This harness's fits
+  never see the test buildings at all.
+
+* Diagnostics are PLAN-DERIVED only (cost blocks + in-window swap count), so
+  ANY method that yields a plan can be scored. Candidates must win at ~flat
+  swaps; count-coupled wins are untrustworthy (public evidence, 4x).
+
+Superseded protocols live in git: the temporal-purge harness (sole validator
+2026-08-22, retired same day) at f5f3fda; the earlier walk-forward/static/
+screen/LOBO family at 2000281.
 
 Usage
-    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
+    venv/bin/python -m batteryswap_example.cv bgkf          # THE SCORE
+    venv/bin/python -m batteryswap_example.cv cand <label>
+    venv/bin/python -m batteryswap_example.cv report
 """
 import sys
 import time
@@ -64,22 +58,18 @@ WINDOW_DAYS = int(mc.WINDOW_DAYS)
 # already-mutated mc.FEATURES (a second seed used to append twice)
 BASE_FEATURES = list(mc.FEATURES)
 
-# The deployed champion, in the repo instead of in a /tmp script.
-# Mirrors submit.py's rolling branch: logbag / tsroute alpha 0.8 + break-even
-# top-up (ec_margin 0.8, ec_pmax 25) + 7d building split + censor-aware
-# pricing + the gated cold-start floor (k=2.5, gate 20).
-# Phase 56 (2026-08-22): champion = logbag_rank + gbm value-preserving rank
-# blend at w=0.30 (THE SCORE 1630.3, was 1972.0 for plain logbag). Deployed
-# as FrontierRUL in submit.py (bit-exact fidelity test in Phase 56).
-CHAMPION = dict(model='logbag_rank', blend=('gbm', 0.30),
-                planner='tsroute', p_star=0.8, day_q=0.05,
-                ec_margin=0.8, ec_pmax=25.0, split_days=7,
-                floor=2.5, floor_gate=20, floor_zone=1)
+# The deployed champion (submit.py default after phase 56 reverted the
+# frontier): plain logbag / tsroute alpha 0.8 + break-even top-up, censor-
+# aware pricing. Frontier dials exist in submit.py for explicit A/B only.
+CHAMPION = dict(model='logbag', planner='tsroute', p_star=0.8, day_q=0.05,
+                ec_margin=0.8, ec_pmax=25.0, split_days=7)
+
+N_FOLDS = 5
 
 BLOCKS = (('warmup  s_0-7', lambda o: o <= 7),
           ('panel   s_8-41', lambda o: (o >= 8) & (o <= 41)),
           ('nearend s_42-47', lambda o: o >= 42),
-          ('ALL-48', lambda o: o >= 0))
+          ('ALL', lambda o: o >= 0))
 
 
 def load_table(dataset_path=Path('dataset')):
@@ -90,9 +80,6 @@ def load_table(dataset_path=Path('dataset')):
     # within-origin fleet ranks: leak-free (data <= origin only)
     t['r_vlast'] = t.groupby('origin_idx')['v_last'].rank(pct=True)
     t['r_tau'] = t.groupby('origin_idx')['tau_projected'].rank(pct=True)
-    # aux usage-dynamics and Wiener-FHT columns (same merges the old
-    # harness __main__ did): cached parquets, data <= origin only; inert
-    # unless a variant/model asks for the columns
     try:
         from batteryswap_example.aux_features import load as load_aux
         aux = load_aux(dataset_path)
@@ -111,21 +98,29 @@ def load_table(dataset_path=Path('dataset')):
     return t
 
 
-def scorecard(df, label):
-    """Three-regime cost scorecard. Plan-derived columns only, so it works
-    on ANY method: the swap count comes from the plan, never from the
-    prediction's shape."""
-    print(f'\n=== {label} ===')
-    hdr = (f"{'block':16s} {'n':>3s} {'total':>8s} {'late':>7s} "
-           f"{'early':>6s} {'swaps':>5s}")
-    print(hdr)
-    for name, sel in BLOCKS:
-        d = df[sel(df['origin'])]
-        if d.empty:
-            continue
-        print(f"{name:16s} {len(d):3d} {d['total_cost'].mean():8.1f} "
-              f"{d['late_swap'].mean():7.1f} {d['early_swap'].mean():6.1f} "
-              f"{d['n_swaps'].mean():5.1f}")
+def build_folds(t, ctx, dataset_path=Path('dataset'), k=N_FOLDS):
+    """Deterministic stratified building->fold assignment.
+
+    Stratified on (1) battery-failure count - unique dying devices per
+    building - and (2) location, proxied by travel centrality (mean hours to
+    every other building). Buildings are sorted by (deaths desc, centrality,
+    id) and snake-assigned to k folds, which balances the lumpy death counts
+    (a test fold with ~0 deaths measures nothing) while spreading central
+    and remote buildings across folds. No randomness: reruns are identical.
+    """
+    dev_b = (pd.read_csv(dataset_path / 'train' / 'devices.csv')
+             .drop_duplicates('device_id').set_index('device_id')['building_id'])
+    b = t['device_id'].map(dev_b)
+    deaths = (t.loc[t['dies42'] == 1].groupby(b[t['dies42'] == 1])['device_id']
+              .nunique())
+    tc = ctx[0]['travel_costs']
+    central = tc[tc['from'] != tc['to']].groupby('from')['hours'].mean()
+    rows = pd.DataFrame({'deaths': deaths, 'central': central}).fillna(0)
+    rows = rows.sort_values(['deaths', 'central'],
+                            ascending=[False, True]).reset_index()
+    order = list(range(k)) + list(range(k - 1, -1, -1))     # snake
+    rows['fold'] = [order[i % (2 * k)] for i in range(len(rows))]
+    return rows.set_index('index')['fold'], dev_b
 
 
 # --------------------------------------------------------------------------
@@ -136,120 +131,42 @@ def _base(t):
     return BASE_FEATURES
 
 
-def _zone(t):
-    dbz = t['days_below_245']
-    t['z_days'] = dbz.fillna(-1.0)
-    t['z_in'] = (dbz >= 0).astype(float)
-    t['z_rate'] = np.where(dbz >= 0, (2.45 - t['v_corr_last']) / np.clip(dbz, 1, None), 0.0)
-    return BASE_FEATURES + ['z_days', 'z_in', 'z_rate']
-
-
-def _vcorr(t):
-    return BASE_FEATURES + ['v_corr_last', 'thresh_dist']
+def _ranks_add(t):
+    # phase-56 rank features. NOTE: under this harness the prediction-time
+    # rank is over the TEST fleet only (a few buildings), which is also what
+    # a held-out deployment would compute.
+    return BASE_FEATURES + ['r_vlast', 'r_tau']
 
 
 def _vrel(t):
-    # phase-38 fleet-relative features: a held-out fleet's absolute voltage
-    # scale is not the train fleet's, but its within-fleet ordering is
-    return BASE_FEATURES + [c for c in ('vrel', 'vmin7_rank')
-                            if c in t.columns]
-
-
-def _vrel_only(t):
-    return BASE_FEATURES + ['vrel']
-
-
-def _vmin7_only(t):
-    return BASE_FEATURES + ['vmin7_rank']
-
-
-def _v_last_only(t):
-    # the phase-39 claim under test: two blind sessions found RAW CURRENT
-    # VOLTAGE alone beating their champion's ranker at the operating N
-    # (.721 vs .668, .703 vs .672). If that reproduces here, our feature set
-    # is over-pruned; if it does not, that lineage's ablation was an artifact
-    # of its threshold rule and nothing from it should be ported.
-    return ['v_last']
-
-
-def _blind4(t):
-    # The blind-repo champion's EXACT feature set as a REPLACEMENT ranker
-    # (9a969a6a7dfe: last_voltage/vmin7/n_obs/vrel -> our columns). Phase 47:
-    # real head-ordering gain at fixed N (static N=8 +27 [+7,+47]) but the
-    # planner converts it to ZERO extra catches (290 vs 291 count-matched)
-    # and +79/origin cost via cruder day placement. REJECTED. blind3 shows
-    # vrel is not load-bearing - the effect is the small set itself.
-    return ['v_last', 'v_min_7', 'n_30', 'vrel']
-
-
-def _blind3(t):
-    return ['v_last', 'v_min_7', 'n_30']
-
+    return BASE_FEATURES + [c for c in ('vrel', 'vmin7_rank') if c in t.columns]
 
-def _ranks(t):
-    # phase-8 logbag_rank, STRICT form: the within-origin rank transforms
-    # REPLACE the two level features (the registry's logbag_rank ADDS them).
-    # Ranks are the cross-fleet transfer device; the original lost the old
-    # scenario CV by less than that harness's label-luck floor.
-    f = [c for c in BASE_FEATURES if c not in ('v_last', 'tau_projected')]
-    return f + ['r_vlast', 'r_tau']
 
-
-def _vrel_bldg(t):
-    # 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')
-                 .set_index('device_id')['building_id'])
-        b = t['device_id'].map(dev_b)
-        t['vrel_bldg'] = (t['v_last'] - t.groupby([t['origin_idx'], b])
-                          ['v_last'].transform('median'))
-    return BASE_FEATURES + ['vrel_bldg']
-
-
-VARIANTS = {'base': _base, 'zone': _zone, 'vcorr': _vcorr, 'vrel': _vrel,
-            'vrel_only': _vrel_only, 'vmin7_only': _vmin7_only,
-            'v_last_only': _v_last_only, 'blind4': _blind4, 'blind3': _blind3,
-            'ranks': _ranks, 'vrel_bldg': _vrel_bldg}
+VARIANTS = {'base': _base, 'ranks_add': _ranks_add, 'vrel': _vrel}
 
 
 # --------------------------------------------------------------------------
-# THE protocol: full-fleet cost with scenario-clean (temporal-purge) fits
+# THE protocol: building-GroupKFold, test group planned as a standalone fleet
 # --------------------------------------------------------------------------
 
-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).
-
-    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,
-    w2) rank-averages a second family in at weight w2 and then maps the
-    blended ORDER back onto the primary family's own p42 values - value-
-    preserving, so the count/pricing machinery sees the identical p42
-    distribution and only WHO holds each rank changes (the phase-51 lesson:
-    a post-hoc blend whose beliefs disagree with the count machinery fails
-    for that reason alone).
+def run_bgkf(dataset_path=Path('dataset'), kind=None, variant='base',
+             blend=None, n_folds=N_FOLDS, origins=range(48)):
+    """THE SCORE. For each fold: one fit on the TRAIN buildings' closed pairs
+    (full history), then per scenario time plan the TEST buildings as a
+    standalone fleet and evaluate. Floor off (harness minimalism; the
+    deployed floor is a submit.py concern). Candidate hooks: `kind` swaps the
+    model family (mc.MODELS key or SklearnRUL spec), `variant` the feature
+    set, `blend`=(kind2, w2) a value-preserving rank blend (order changes,
+    the primary's p42 values and hence the count machinery do not).
     """
-    if kind is None and blend is None:
-        # the champion arm carries its own blend; an explicit candidate kind
-        # replaces the model config outright (no implicit blend inheritance)
-        blend = CHAMPION.get('blend')
     kind = kind or CHAMPION['model']
     t = load_table(dataset_path)
     mc.FEATURES = list(VARIANTS[variant](t))
     ctx = mc.load_context(dataset_path)
     W = pd.Timedelta(days=WINDOW_DAYS)
     closed = t[t['origin'] <= t['origin'].max() - W]
+    folds, dev_b = build_folds(t, ctx, dataset_path, k=n_folds)
+    t_bldg = t['device_id'].map(dev_b)
 
     p = mc.plan_tsroute
     p.alpha, p.p_be, p.floor_day, p.p_conf = CHAMPION['p_star'], 0.0, 0, 0.5
@@ -257,156 +174,148 @@ def run_all48_oof(origins=range(48), dataset_path=Path('dataset'), kind=None,
     p.split_days = CHAMPION['split_days']
     p.floor_scale, p.recent_deaths = 0.0, 0.0
 
+    def _fit(k_, train):
+        hazard = k_ in ('aft', 'dthaz', 'dthaz_aux', 'logbag_open',
+                        'blend_dh', 'blend_dhaux')
+        if hazard:
+            pool = mc.censored_pairs(t, t['origin'].max())
+            keep = set(train['device_id'])
+            train = pool[pool['device_id'].isin(keep)]
+        make = ((lambda: mc.MODELS[k_]()) if k_ in mc.MODELS
+                else (lambda: mc.SklearnRUL(k_)))
+        return make().fit(train)
+
     recs = []
-    for idx in origins:
-        c = ctx[idx]
-        T = c['start_time']
-        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)
-
-        def _pred(k):
-            if k == 'tau':
-                # fit-free pseudo-model: the physics timer as a rank source
-                # (only meaningful inside a value-preserving blend)
-                return pd.DataFrame(
-                    {'p42': -rows['tau_projected'].astype(float).fillna(np.inf)},
-                    index=rows.index)
-            hazard = k in ('aft', 'dthaz', 'dthaz_aux', 'logbag_open',
-                           'blend_dh', 'blend_dhaux')
-            # 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)))
-            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)
-        in_win = plan.loc[plan['day'] <= T + W, 'battery']
-        recs.append(dict(overall, n_swaps=int(in_win.nunique()),
-                         origin=idx, arm='oof'))
-        print(f"s_{idx}: oof {recs[-1]['total_cost']:7.1f}",
-              flush=True, file=sys.stderr)
+    for f in range(n_folds):
+        test_b = set(folds.index[folds == f])
+        train = closed[~t_bldg.loc[closed.index].isin(test_b)]
+        model = _fit(kind, train)
+        partner = _fit(blend[0], train) if blend is not None else None
+        for idx in origins:
+            c = ctx[idx]
+            T = c['start_time']
+            fleet = c['locs'][c['locs']['building'].isin(test_b)]
+            rows = (t[t['origin_idx'] == idx].set_index('device_id')
+                    .reindex(fleet['battery']).dropna(subset=['v_last']))
+            if rows.empty:
+                continue
+            locs = fleet[fleet['battery'].isin(rows.index)]
+            eol = c['eol'].reindex(rows.index)
+            pred = model.predict(rows)
+            if partner is not None:
+                w2 = blend[1]
+                r = ((1 - w2) * pred['p42'].rank(pct=True)
+                     + w2 * partner.predict(rows)['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)
+            in_win = plan.loc[plan['day'] <= T + W, 'battery']
+            recs.append(dict(overall, n_swaps=int(in_win.nunique()),
+                             origin=idx, fold=f, arm='bgkf'))
+            print(f"f{f} s_{idx}: {recs[-1]['total_cost']:7.1f}",
+                  flush=True, file=sys.stderr)
     return pd.DataFrame(recs)
 
 
+def report(df):
+    """Fold table + scenario-block scorecard + THE SCORE (single value)."""
+    print('\n=== building-GroupKFold / test group planned as a fleet / '
+          'floor off ===')
+    print(f"{'fold':>4s} {'n':>3s} {'total':>8s} {'late':>7s} {'early':>6s} "
+          f"{'swaps':>5s}")
+    for f, d in df.groupby('fold'):
+        print(f"{f:4d} {len(d):3d} {d['total_cost'].mean():8.1f} "
+              f"{d['late_swap'].mean():7.1f} {d['early_swap'].mean():6.1f} "
+              f"{d['n_swaps'].mean():5.1f}")
+    print(f"\n{'block':16s} {'n':>3s} {'total':>8s} {'late':>7s} "
+          f"{'early':>6s} {'swaps':>5s}")
+    for name, sel in BLOCKS:
+        d = df[sel(df['origin'])]
+        if d.empty:
+            continue
+        print(f"{name:16s} {len(d):3d} {d['total_cost'].mean():8.1f} "
+              f"{d['late_swap'].mean():7.1f} {d['early_swap'].mean():6.1f} "
+              f"{d['n_swaps'].mean():5.1f}")
+    score = df.groupby('fold')['total_cost'].mean().mean()
+    print(f"\nSCORE (building-GroupKFold, mean over folds of fold-mean "
+          f"cost): {score:.1f}")
+
+
 # --------------------------------------------------------------------------
 # candidate sweep on the one harness
 # --------------------------------------------------------------------------
 
-OOF_CANDIDATES = {
+CANDIDATES = {
     'logistic': dict(kind='logistic'),
     'rf': dict(kind='rf'),
     'gbm': dict(kind='gbm'),
-    'zone': dict(variant='zone'),
-    'vcorr': dict(variant='vcorr'),
+    'dthaz': dict(kind='dthaz'),
+    'logbag_rank': dict(kind='logbag_rank'),
+    'ranks_add': dict(variant='ranks_add'),
     'vrel': dict(variant='vrel'),
-    'vrel_only': dict(variant='vrel_only'),
-    'vmin7_only': dict(variant='vmin7_only'),
-    'v_last_only': dict(variant='v_last_only'),
-    'blind4': dict(variant='blind4'),
-    'blind3': dict(variant='blind3'),
     'rankavg25rf': dict(blend=('rf', 0.25)),
     'rankavg25gbm': dict(blend=('gbm', 0.25)),
-    # wave 2 - the A-list from the phase-52-addendum re-adjudication:
-    # candidates whose rejection came from a self-fit surface while a
-    # building-split instrument disagreed or was never consulted
-    'logbagC03': dict(kind='logbag_c03'),
-    'logbagC01': dict(kind='logbag_c01'),
-    'logbag_rank': dict(kind='logbag_rank'),
-    'ranks': dict(variant='ranks'),
-    'vrel_bldg': dict(variant='vrel_bldg'),
-    'logbag_aux': dict(kind='logbag_aux'),
-    'aux_ucb05': dict(kind='aux_ucb05'),
-    'aux_ucb10': dict(kind='aux_ucb10'),
-    'dthaz': dict(kind='dthaz'),
-    'rankavg25tau': dict(blend=('tau', 0.25)),
-    'rankavg25fht': dict(blend=('wiener', 0.25)),
+    'frontier': dict(kind='logbag_rank', blend=('gbm', 0.30)),
 }
 
 
-def oof_candidate_report(base_csv='/tmp/cv_all48oof.csv',
-                         pattern='/tmp/cv_oofcand_*.csv'):
+def candidate_report(base_csv='/tmp/cv_bgkf.csv',
+                     pattern='/tmp/cv_bgkfcand_*.csv'):
     import glob
     base = pd.read_csv(base_csv)
-    b = base[base['arm'] == 'oof'].set_index('origin')
-    print('paired vs champion (logbag/base, temporal purge, floor off).')
+    b = base.set_index(['fold', 'origin'])
+    print('paired vs champion (logbag/base, building-GroupKFold, floor off).')
     print('swaps (plan-derived) shown because a cost delta can be appetite '
-          'in disguise (phase 39/51): trust a win only if swaps is ~flat.\n')
-    hdr = (f"{'candidate':14s} {'ALL48':>7s} {'delta':>7s} {'W/L':>7s} "
-           f"{'panel':>7s} {'pdelta':>7s} {'pW/L':>7s} {'swaps':>5s}")
-    print(hdr)
-    print(f"{'base(oof)':14s} {b['total_cost'].mean():7.1f} {'-':>7s} {'-':>7s} "
-          f"{b.loc[(b.index >= 8) & (b.index <= 41), 'total_cost'].mean():7.1f} "
-          f"{'-':>7s} {'-':>7s} {b['n_swaps'].mean():5.1f}")
+          'in disguise: trust a win only if swaps is ~flat, and check the '
+          'PER-CELL count swing, not just the mean (phase 56 lesson).\n')
+    print(f"{'candidate':14s} {'SCORE':>7s} {'delta':>7s} {'SE':>6s} "
+          f"{'W/L':>7s} {'swaps':>5s}")
+    bs = b.groupby('fold')['total_cost'].mean().mean()
+    print(f"{'base':14s} {bs:7.1f} {'-':>7s} {'-':>6s} {'-':>7s} "
+          f"{b['n_swaps'].mean():5.1f}")
     out = []
     for fn in sorted(glob.glob(pattern)):
-        d = pd.read_csv(fn).set_index('origin')
+        d = pd.read_csv(fn).set_index(['fold', 'origin'])
         label = d['cand'].iloc[0]
         delta = (d['total_cost'] - b['total_cost']).dropna()
-        pan = delta[(delta.index >= 8) & (delta.index <= 41)]
-        out.append((delta.mean(), label, d, delta, pan))
-    for _, label, d, delta, pan in sorted(out):
-        print(f"{label:14s} {d['total_cost'].mean():7.1f} {delta.mean():+7.1f} "
+        score = d.groupby('fold')['total_cost'].mean().mean()
+        out.append((delta.mean(), label, score, delta, d))
+    for _, label, score, delta, d in sorted(out):
+        se = delta.std() / np.sqrt(len(delta))
+        print(f"{label:14s} {score:7.1f} {delta.mean():+7.1f} {se:6.1f} "
               f"{int((delta < 0).sum()):3d}W/{int((delta > 0).sum()):2d}L "
-              f"{d.loc[(d.index >= 8) & (d.index <= 41), 'total_cost'].mean():7.1f} "
-              f"{pan.mean():+7.1f} {int((pan < 0).sum()):3d}W/{int((pan > 0).sum()):2d}L "
               f"{d['n_swaps'].mean():5.1f}")
 
 
-def oof_report(df):
-    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 'all48oof'
+    proto = sys.argv[1] if len(sys.argv) > 1 else 'bgkf'
     t0 = time.time()
-    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':
+    if proto == 'bgkf':
+        df = run_bgkf()
+        df.to_csv('/tmp/cv_bgkf.csv', index=False)
+        report(df)
+    elif proto == 'cand':
         label = sys.argv[2]
-        df = run_all48_oof(**OOF_CANDIDATES[label])
+        df = run_bgkf(**CANDIDATES[label])
         df['cand'] = label
-        df.to_csv(f'/tmp/cv_oofcand_{label}.csv', index=False)
-        scorecard(df, f'all48oof / cand={label} / temporal purge / floor off')
-    elif proto == 'oofreport':
-        oof_candidate_report()
+        df.to_csv(f'/tmp/cv_bgkfcand_{label}.csv', index=False)
+        report(df)
+    elif proto == 'report':
+        candidate_report()
     else:
         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.')
+            f'unknown protocol {proto!r} - the building-GroupKFold harness '
+            f'is the only CV (user directive 2026-08-22 v3). The temporal '
+            f'purge lives in git at f5f3fda; the older walk-forward family '
+            f'at 2000281.')
     print(f'\n[{time.time() - t0:.0f}s]')