all48oof: static fit protocol is the default (user-shaped) - one fit per fold on the other buildings' FULL closed history, deployment's exact shape; 40s runtime; new reference panel 1893.4 / ALL-48 1913.3; 'cv all48oof wf' keeps the walk-forward variant

batteryswap_example/cv.py

@@ -610,7 +610,7 @@ def ablation_report(df, ns, label, ref='base'):
 
 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):
+                  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
@@ -637,6 +637,16 @@ 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))
@@ -653,12 +663,31 @@ 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 tr['dies42'].sum() < 3:
+        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']))
@@ -670,6 +699,14 @@ def run_all48_oof(n_folds=5, seed=0, origins=range(48),
         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)
             if k == 'tau':
                 # fit-free pseudo-model: the physics timer as a rank source
                 # (only meaningful inside a value-preserving blend)
@@ -835,11 +872,14 @@ def main():
     elif proto == 'screen':
         screen()
     elif proto == 'all48oof':
-        # THE SCORE (user directive 2026-08-22): oof arm only by default.
-        # `cv all48oof self` additionally runs the self arm - the validity
-        # check (must reproduce panel 1679.2) and the flattery-term readout.
+        # 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',)
-        df = run_all48_oof(arms=arms)
+        fitp = 'walkforward' if variant == 'wf' else 'static'
+        df = run_all48_oof(arms=arms, fit=fitp)
         df.to_csv('/tmp/cv_all48oof.csv', index=False)
         oof_report(df)
     elif proto == 'oofcand':