Phase 14: building day-splitting (sd7) + censoring-aware pricing adopted

Panel 1679.2 vs 1702.0, sd7 selected in 100% of random and blocked
splits; censoring-aware curves -32 on TRUNC=30 counterfactual, inert on
covered windows. Hazard-WHEN and park_mobility rejected. All-48 Docker
metric 2146.9 (was 2175.4).

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

EXPERIMENTS.md

@@ -461,6 +461,27 @@ is the signature of an internal cell failure, not an external stressor:
 nothing in temperature, telemetry health, or spatial context flags it before
 the plunge starts.
 
+## Phase 14 - planner structure audit (ADOPTED: building day-splitting + censoring-aware pricing)
+
+With WHO-prediction mined out (phases 6-13) and ops already beating the
+leader's, the audit targeted WHEN precision and pricing fidelity. Four
+candidates, all CV-adjudicated:
+
+| candidate | verdict | evidence |
+|---|---|---|
+| **split_days=7**: sub-group buildings by best-day bucket so the day search may split a building across days (merge moves can rejoin at zero travel cost - same-day groups share the mobility simulation) | **ADOPTED** | panel **1679.2 vs 1702.0**, selected in **100% of random AND 100% of blocked** half-splits; sd14 also wins (1694.4) but sd7 dominates |
+| **censoring-aware cost curves**: death mass beyond the split's data end cannot be charged late/emergency (never in shipped eol_times) - price it via the end_time+30 imputation branch and drop it from park | **ADOPTED** | byte-inert on all covered windows (panel identical to the decimal); counterfactual TRUNC=30 (last 12 window days unobservable): **1302.2 vs 1334.4** (-32), 11/16 wins - early drops 572->480 as the planner stops paying bookkeeping on unscoreable deaths |
+| hazard-based WHEN (logbag WHO + DiscreteHazard conditional bucket-CDF day quantiles) | rejected | panel 1728.4 (+26); s_8's -26 did not generalize - the 4-knot GBR quantiles are the better day estimator |
+| park_mobility (emergency also pays travel/overtime) | rejected | +0.8 to +2.9 on the counterfactual - noise; emergency-cost underestimation was not the binding error |
+
+One-visit-day-per-building had been implicit in plan_tsroute since phase 5
+(`offs = bldg.map(day_of)`): a building holding both a dies-day-5 and a
+dies-day-40 inclusion was forced onto one compromise day, paying both sides.
+
+New champion: **logbag / tsroute alpha=0.8 + break-even top-up (m0.8/pm25,
+fresh-only) + split_days=7 + censoring-aware two-sided cost curves**.
+Panel 1679.2 (from 1715.8 pre-phase-11).
+
 ## Test-look ledger
 
 8 looks total (now historical - see protocol change above); look 9 = the

batteryswap_example/models_cv.py

@@ -779,6 +779,28 @@ class CohortGate:
         return out
 
 
+class LogbagDH:
+    """
+    Champion WHO (logbag p42, identical training pairs) + hazard WHEN: day
+    quantiles from DiscreteHazard's conditional bucket CDF instead of the
+    4-knot GBR quantile models. Isolates the value of a better death-day
+    estimator without touching inclusion.
+    """
+
+    def fit(self, train):
+        self.who = SklearnRUL('logbag').fit(train)
+        aug = train.copy()
+        aug['duration'] = train['days_to_eol'].fillna(10000.0).clip(lower=0.5)
+        aug['event'] = train['dies42'].astype(int)
+        self.when = DiscreteHazard().fit(aug)
+        return self
+
+    def predict(self, rows):
+        out = self.when.predict(rows)          # day_q from hazard CDF
+        out['p42'] = self.who.predict(rows)['p42'].values
+        return out
+
+
 MODELS = {
     'rank-v': RankVoltage,
     'logistic': lambda: SklearnRUL('logistic'),
@@ -832,6 +854,7 @@ MODELS = {
     'logbag_fht2': lambda: LogBagFeats(['fht_days']),
     'cg_all': lambda: CohortGate('all'),
     'cg_silent': lambda: CohortGate('silent'),
+    'logbag_dh': LogbagDH,
 }
 
 
@@ -915,6 +938,8 @@ def _batch_days(offs, locations, start_time, max_groups_per_day=2):
 
 EARLY, LATE = 0.5, 10.0
 EMERGENCY_DAY = WINDOW_DAYS + 3  # emergencies run just after the plan ends
+CENSOR_AWARE = True     # price unobservable (post-data-end) deaths via imputation
+PARK_MOBILITY = 0.0     # extra cost per expected emergency (travel/overtime)
 
 
 def plan_expcost(pred, included, locations, start_time, day_q):
@@ -1004,15 +1029,30 @@ def cost_curves(pred, locations, start_time, blend=0.0):
     e_far = ((end.reindex(pred.index) - start_time).dt.total_seconds() / 86400
              + 30.0).values
 
+    # censoring-aware: deaths after the split's data end are never in the
+    # shipped eol_times, so the evaluator cannot charge late/emergency for
+    # them - it prices those devices via the end_time+30 imputation instead
+    # (i.e. our survivor branch). Move unobservable death mass to the
+    # survivor branch and drop it from the parking (emergency) estimate.
+    # Inert whenever data extends >= 42d past the origin (all train panel
+    # origins); bites on near-data-end scenarios (runtime splits, s_42-47).
+    if CENSOR_AWARE:
+        D = (end.max() - start_time).total_seconds() / 86400
+        pmf = pmf * (t <= D)[None, :]
+    obs_frac = pmf.sum(axis=1)
+
     delta = grid[None, :, None] - t[None, None, :]        # 1 x 43 x 42
     pen = np.where(delta >= 0, LATE * delta, EARLY * (-delta))
     curves = p42[:, None] * (pmf[:, None, :] * pen).sum(axis=2)
     surv_delta = e_far[:, None] - grid[None, :]
-    curves += (1 - p42)[:, None] * np.where(surv_delta >= 0,
-                                            EARLY * surv_delta,
-                                            LATE * -surv_delta)
-
-    park = p42 * (pmf * (LATE * (EMERGENCY_DAY - t))[None, :]).sum(axis=1)
+    curves += (1 - p42 * obs_frac)[:, None] * np.where(surv_delta >= 0,
+                                                       EARLY * surv_delta,
+                                                       LATE * -surv_delta)
+
+    # an emergency also pays its own travel/overtime, not just late-days;
+    # PARK_MOBILITY adds that per expected observable emergency
+    park = (p42 * (pmf * (LATE * (EMERGENCY_DAY - t))[None, :]).sum(axis=1)
+            + PARK_MOBILITY * p42 * obs_frac)
     return curves, park
 
 
@@ -1232,19 +1272,29 @@ def plan_tsroute(pred, included, locations, start_time, day_q,
     curves = pd.DataFrame(curves, index=pred.index).loc[chosen]
     bldg = locations.set_index('battery')['building'].reindex(chosen)
     room = locations.set_index('battery')['room']
+    key = bldg
+    if plan_tsroute.split_days > 0:
+        # one visit day per building forces urgent and insurance swaps in the
+        # same building onto a compromise day; sub-group by best-day bucket so
+        # the optimizer MAY split a building across days (merge moves can
+        # always rejoin them at zero travel cost - same-day groups share the
+        # mobility simulation)
+        bucket = curves.values.argmin(axis=1) // int(plan_tsroute.split_days)
+        key = bldg.astype(str) + '~' + pd.Series(bucket, index=curves.index).astype(str)
     groups = {g: sorted(m.index, key=lambda b: room.get(b, ''))
-              for g, m in curves.groupby(bldg)}
+              for g, m in curves.groupby(key)}
     travel_hours = travel_costs.set_index(['from', 'to'])['hours'].unstack()
 
     day_of = optimize_days(groups, curves, locations, travel_hours,
                            settings, start_time)
 
-    offs = bldg.map(day_of).astype(float)
+    offs = key.map(day_of).astype(float)
     days = start_time + pd.to_timedelta(offs.values, unit='D')
     return assemble(pd.Series(days, index=offs.index), locations, start_time)
 
 
 plan_tsroute.alpha = 0.8
+plan_tsroute.split_days = 0
 plan_tsroute.p_be = 0.0
 plan_tsroute.floor_day = 0
 plan_tsroute.p_conf = 0.5
@@ -1486,6 +1536,9 @@ def walk_forward(table, scenario_ctx, origins, configs):
                 PLANNERS['tsroute'].p_conf = cfg.get('p_conf', 0.5)
                 PLANNERS['tsroute'].ec_margin = cfg.get('ec_margin', 0.0)
                 PLANNERS['tsroute'].ec_pmax = cfg.get('ec_pmax', 25.0)
+                PLANNERS['tsroute'].split_days = cfg.get('split_days', 0)
+            global PARK_MOBILITY
+            PARK_MOBILITY = cfg.get('park_mobility', 0.0)
             global EMERGENCY_DAY
             EMERGENCY_DAY = cfg.get('emergency_day', WINDOW_DAYS + 3)
             optimize_days.restarts = int(cfg.get('restarts', 2))
@@ -1526,7 +1579,8 @@ def summarize(df, label):
                   df['p_star'].astype(str) + '/q' + df['day_q'].astype(str))
     for key, tag in [('blend', 'b'), ('p_be', 'be'), ('floor_day', 'f'), ('p_conf', 'c'),
                      ('alpha2', 'a2'), ('emergency_day', 'e'), ('restarts', 'r'),
-                     ('iters', 'i'), ('ec_margin', 'ec'), ('ec_pmax', 'pm')]:
+                     ('iters', 'i'), ('ec_margin', 'ec'), ('ec_pmax', 'pm'),
+                     ('split_days', 'sd'), ('park_mobility', 'pk')]:
         if key in df.columns and df[key].nunique(dropna=False) > 1:
             df['name'] += '/' + tag + df[key].fillna(0).astype(str)
     mean = df.groupby('name')['total_cost'].agg(['mean', 'std']).sort_values('mean')
@@ -1557,7 +1611,8 @@ def selection_stability(df, n_random=2000, n_blocks=6, seed=0):
     # distinguish configs that differ only in planner knobs (same tags as summarize)
     for key, tag in [('blend', 'b'), ('p_be', 'be'), ('floor_day', 'f'), ('p_conf', 'c'),
                      ('alpha2', 'a2'), ('emergency_day', 'e'), ('restarts', 'r'),
-                     ('iters', 'i'), ('ec_margin', 'ec'), ('ec_pmax', 'pm')]:
+                     ('iters', 'i'), ('ec_margin', 'ec'), ('ec_pmax', 'pm'),
+                     ('split_days', 'sd'), ('park_mobility', 'pk')]:
         if key in df.columns and df[key].nunique(dropna=False) > 1:
             df['name'] += '/' + tag + df[key].fillna(0).astype(str)
     pv = df.pivot_table(index='origin', columns='name', values='total_cost')

batteryswap_example/planner.py

@@ -103,6 +103,7 @@ class ECRoutePlanner(Planner):
         plan_tsroute.alpha = 0.8
         plan_tsroute.ec_margin = 0.8   # phase-11 break-even top-up
         plan_tsroute.ec_pmax = 25.0
+        plan_tsroute.split_days = 7    # phase-14 building day-splitting
         return plan_tsroute(pred, None, locations, origin, 0.05,
                             travel_costs=travel_costs, settings=settings)
 

batteryswap_example/submit.py

@@ -51,6 +51,10 @@ ALPHA = float(os.environ.get('BATTERYSWAP_ALPHA', '0.8'))
 # in 63% of random half-splits, never beaten in a decided blocked split.
 EC_MARGIN = float(os.environ.get('BATTERYSWAP_EC_MARGIN', '0.8'))
 EC_PMAX = float(os.environ.get('BATTERYSWAP_EC_PMAX', '25'))
+# Phase 14: let the day search split a building across days by best-day
+# bucket (7d) instead of forcing one visit day per building. Panel 1679.2 vs
+# 1702.0, selected in 100% of random AND blocked half-splits.
+SPLIT_DAYS = int(os.environ.get('BATTERYSWAP_SPLIT_DAYS', '7'))
 
 
 def build_split_table(locations, timeseries, eol_times, scen_starts, log=print):
@@ -128,6 +132,7 @@ def adaptive_split_plans(split, split_path, log=print, deadline=None):
         plan_tsroute.alpha = ALPHA
         plan_tsroute.ec_margin = EC_MARGIN
         plan_tsroute.ec_pmax = EC_PMAX
+        plan_tsroute.split_days = SPLIT_DAYS
         plan = plan_tsroute(pred, None, locs, T, 0.05,
                             travel_costs=scenario['travel_costs'],
                             settings=scenario['settings'])