CV: SCORE = summed folds per scenario (all-building out-of-fold total, familiar full-fleet magnitude); champion baseline 1760.2

EXPERIMENTS.md

@@ -3181,3 +3181,12 @@ is what protects against it, not the harness.
 THE CV going forward: v5 building-GroupKFold (deployment-faithful held-out
 simulation, one instrument for public AND private - both are ~2x held-out
 fleets), used for ordering/model questions under the quarantine rules.
+
+Phase 58 addendum (user): SCORE aggregation switched to the familiar
+full-fleet magnitude - per scenario the 5 fold costs are SUMMED (every
+building is out-of-fold exactly once per scenario -> the sum is the
+all-24-building out-of-fold cost), SCORE = mean of the 48 totals.
+**Champion baseline: SCORE = 1760.2** (warmup 2616.1 / panel 1773.4 /
+nearend 544.0; swaps 9.5/scenario). Identical information to the fold-mean
+form (352.0 x 5), same paired decisions; stale pre-v5 candidate CSVs purged
+from /tmp (only the phase-58 faithful runs remain valid).

batteryswap_example/cv.py

@@ -10,7 +10,11 @@ TEST buildings are planned as a STANDALONE fleet with the DEPLOYMENT-EXACT
 planner state (submit.py's static-path knobs, including the cold-start
 floor gate, which is structurally inert here because every fold trains on
 60+ unique deaths vs the gate's 20) and costed by the real evaluator.
-THE SCORE is the mean over folds of the fold's mean scenario cost.
+THE SCORE: per scenario, the fold costs are SUMMED - every building sits
+in exactly one test fold, so the sum is the out-of-fold cost of ALL 24
+buildings for that scenario - and THE SCORE is the mean of those 48
+all-building totals. Same information as the fold-mean average (x5), but in
+the familiar full-fleet-per-scenario magnitude.
 
 Fidelity pass (v5): this harness is the closest possible local twin of the
 held-out deployment path - both public and private splits are ~2x unseen
@@ -256,27 +260,30 @@ def run_bgkf(dataset_path=Path('dataset'), kind=None, variant='base',
 
 
 def report(df):
-    """Fold table + scenario-block scorecard + THE SCORE (single value)."""
-    print('\n=== building-GroupKFold / test group planned as a fleet / '
-          'floor off ===')
+    """Fold table + all-building scenario scorecard + THE SCORE."""
+    print('\n=== building-GroupKFold / test groups planned as fleets / '
+          'folds summed per scenario ===')
     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}")
+    # per-scenario all-building totals: sum across folds (each building is
+    # out-of-fold exactly once per scenario)
+    g = df.groupby('origin')[['total_cost', 'late_swap', 'early_swap',
+                              'n_swaps']].sum()
     print(f"\n{'block':16s} {'n':>3s} {'total':>8s} {'late':>7s} "
-          f"{'early':>6s} {'swaps':>5s}")
+          f"{'early':>6s} {'swaps':>5s}   (all buildings, per scenario)")
     for name, sel in BLOCKS:
-        d = df[sel(df['origin'])]
+        d = g[sel(g.index)]
         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}")
+    print(f"\nSCORE (all-building out-of-fold cost, mean over the 48 "
+          f"scenarios): {g['total_cost'].mean():.1f}")
 
 
 # --------------------------------------------------------------------------
@@ -301,26 +308,27 @@ def candidate_report(base_csv='/tmp/cv_bgkf.csv',
                      pattern='/tmp/cv_bgkfcand_*.csv'):
     import glob
     base = pd.read_csv(base_csv)
-    b = base.set_index(['fold', 'origin'])
-    print('paired vs champion (logbag/base, building-GroupKFold, floor off).')
+    b = base.groupby('origin')[['total_cost', 'n_swaps']].sum()
+    print('paired vs champion (logbag/base, building-GroupKFold; folds '
+          'summed per scenario -> 48 paired all-building totals).')
     print('swaps (plan-derived) shown because a cost delta can be appetite '
           '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')
+          'PER-SCENARIO 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}")
+    print(f"{'base':14s} {b['total_cost'].mean():7.1f} {'-':>7s} {'-':>6s} "
+          f"{'-':>7s} {b['n_swaps'].mean():5.1f}")
     out = []
     for fn in sorted(glob.glob(pattern)):
-        d = pd.read_csv(fn).set_index(['fold', 'origin'])
-        label = d['cand'].iloc[0]
+        d = (pd.read_csv(fn).groupby('origin')
+             [['total_cost', 'n_swaps']].sum())
+        label = pd.read_csv(fn)['cand'].iloc[0]
         delta = (d['total_cost'] - b['total_cost']).dropna()
-        score = d.groupby('fold')['total_cost'].mean().mean()
-        out.append((delta.mean(), label, score, delta, d))
-    for _, label, score, delta, d in sorted(out):
+        out.append((delta.mean(), label, d, delta))
+    for _, label, d, delta in sorted(out):
         se = delta.std() / np.sqrt(len(delta))
-        print(f"{label:14s} {score:7.1f} {delta.mean():+7.1f} {se:6.1f} "
+        print(f"{label:14s} {d['total_cost'].mean():7.1f} "
+              f"{delta.mean():+7.1f} {se:6.1f} "
               f"{int((delta < 0).sum()):3d}W/{int((delta > 0).sum()):2d}L "
               f"{d['n_swaps'].mean():5.1f}")