Phase 52 addendum: building split extended to the cost harness - new cv all48oof protocol (building-OOF p42, full-fleet planning, paired self arm); panel 1679.2 -> 1813.6 (+134.4/origin, 8W/26L), self-building fit flatters all48 by ~+134/origin; prices harness optimism, no selection change

EXPERIMENTS.md

@@ -2688,6 +2688,38 @@ Standing rule upgrade (supersedes the blind-loop "group by battery" rule):
 grouping is necessary but not sufficient; it still leaks the environment/
 install-batch channel that phase 10/13 closed on the feature side.
 
+### Phase 52 addendum - the building split extended to the COST harness (`all48oof`)
+
+Directive (user, 2026-08-22): "building split not only for the AUC but for
+the scenario split as well." New protocol `cv all48oof`: the walk-forward
+cost harness with BUILDING-CLEAN predictions - each device's p42 at every
+origin comes from a champion-config logbag fitted on pairs from every
+building except its own (5 greedy death-balanced folds, OOF-stitched), then
+the FULL fleet is planned as usual (planning must stay full-fleet: the count
+rule scales with fleet size - the phase-26 static-gate lesson). Paired
+`self` arm through identical machinery, cold-start floor OFF in both, so
+the per-origin delta isolates the self-building fit effect. Read the DELTA,
+not the level. Validity check: the self arm reproduces the canonical panel
+1679.2 and near-end 604.8 exactly (floor only fires in warm-up).
+
+| block | self | oof | delta/origin | oof-better W / self-better L |
+|---|---|---|---|---|
+| warmup s_0-7 | 4256.1 | 4180.0 | -76.1 | 6W / 2L |
+| panel s_8-41 | **1679.2** | **1813.6** | **+134.4** | 8W / 26L |
+| nearend s_42-47 | 604.8 | 757.3 | +152.5 | 1W / 5L |
+| ALL-48 | 1974.4 | 2075.9 | +101.6 | 15W / 33L |
+
+Ranking moves with the cost: panel rec12 0.572 -> 0.538, recall 0.571 ->
+0.542, ALL-48 rec12 0.597 -> 0.560. Warm-up's negative delta is noise
+(floor off, 3-20 train deaths). Reading: **self-building fitting flatters
+the walk-forward by ~+134/origin on the panel**; the transfer-shaped cost
+estimate for the champion on foreign buildings is the oof column. This is
+the cost-denominated size of the contamination the phase-52 screen showed
+as AUC margins - it prices the OPTIMISM of the harness, not a defect of the
+champion (both arms use the same model family; there is no building-free
+challenger that closes the gap, per the phase-52 screen). No selection
+change. Results /tmp/cv_all48oof.csv, seed 0.
+
 ## Phase 50 - the forecast axis: fleet-learned conditional dynamics (construction and screens)
 
 Directive (user, 2026-08-22): innovate on the FORECAST part; reinforced with

batteryswap_example/cv.py

@@ -560,6 +560,101 @@ def ablation_report(df, ns, label, ref='base'):
         print(f'  {v:13s} ' + '  '.join(cells))
 
 
+# --------------------------------------------------------------------------
+# protocol 5: all48 twin with building-OOF predictions (phase 52 follow-up)
+# --------------------------------------------------------------------------
+
+def run_all48_oof(n_folds=5, seed=0, origins=range(48),
+                  dataset_path=Path('dataset')):
+    """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.
+
+    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.
+    """
+    t = load_table(dataset_path)
+    mc.FEATURES = list(BASE_FEATURES)
+    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)]
+    bldg_fold = building_folds(closed, dev_bldg, n_folds, seed)
+
+    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']
+        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']))
+        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)
+        for arm in ('self', 'oof'):
+            if arm == 'self':
+                pred = mc.SklearnRUL(CHAMPION['model']).fit(tr).predict(rows)
+            else:
+                parts = []
+                for f in sorted(row_fold.dropna().unique()):
+                    m = mc.SklearnRUL(CHAMPION['model']).fit(tr[tr_fold != f])
+                    parts.append(m.predict(rows[(row_fold == f).values]))
+                pred = pd.concat(parts).reindex(rows.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))
+        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)
+    return pd.DataFrame(recs)
+
+
+def oof_report(df):
+    for arm in ('self', 'oof'):
+        scorecard(df[df['arm'] == arm], f'all48oof / arm={arm} / floor off')
+    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.')
+
+
 def main():
     proto = sys.argv[1] if len(sys.argv) > 1 else 'all48'
     variant = sys.argv[2] if len(sys.argv) > 2 else 'base'
@@ -585,6 +680,10 @@ def main():
               'an appetite/count decision (see module docstring).')
     elif proto == 'screen':
         screen()
+    elif proto == 'all48oof':
+        df = run_all48_oof()
+        df.to_csv('/tmp/cv_all48oof.csv', index=False)
+        oof_report(df)
     elif proto == 'ablate':
         which = sys.argv[2] if len(sys.argv) > 2 else 'all48'
         df, ns = ablate(protocol=which)