Phase 18: limit-aware constructive initializer rejected; limit tail is a correct trade

EXPERIMENTS.md

@@ -565,6 +565,27 @@ break-even top-up, censoring-aware pricing, building day-splitting - already
 serve, and whose panel deltas systematically understate their deployment
 value. Champion unchanged: panel 1679.2, all-48 Docker 2146.9.
 
+## Phase 18 - limit-aware constructive initializer (rejected; the limit tail is a correct trade)
+
+Last item of the phase-17 plan: greedy urgency-ordered construction (each
+group placed on the day minimizing exact partial timing+mobility cost) as an
+additional best-of-starts candidate in optimize_days, targeting the
+overtime/limit bucket (~172/origin, spikes 500-850 at s_21/23/33-38).
+
+Panel: **1692.3 vs 1679.2** (+13.1), champion selected 88.5% random / 75%
+blocked. Three findings close the direction: (1) 28/34 byte-ties - the
+argmin-start climb already finds these optima; (2) the limit spikes are
+UNTOUCHED (s_21 781, s_23 832 identical) - with exact limit pricing in the
+objective, the optimizer genuinely prefers paying penalties because deaths
+cluster in time and spreading costs more in timing than it saves in limits;
+(3) where the constructive start did win the search objective (s_34/s_35),
+realized cost got WORSE (+215/+226) - at the margin, deeper search harvests
+model-curve error rather than real savings. The knob
+(optimize_days.constructive) stays available, default off.
+
+This completes the phase-17 plan: all five directions adjudicated and
+rejected. Champion unchanged: panel 1679.2, all-48 Docker 2146.9.
+
 ## Test-look ledger
 
 8 looks total (now historical - see protocol change above); look 9 = the

batteryswap_example/models_cv.py

@@ -1306,11 +1306,32 @@ def optimize_days(groups, curves, locations, travel_hours, settings, start_time,
         cand, s = climb(start)
         if s < best_score:
             best, best_score = cand, s
+
+    if optimize_days.constructive:
+        # limit-aware constructive start (phase 18): the argmin start piles
+        # urgent groups into the same days/weeks and the +-10d shift moves may
+        # not escape the resulting overtime/limit basin. Greedily place groups
+        # in urgency order, each on the day minimizing the EXACT partial cost
+        # (timing + real mobility incl. limit penalties), then climb from it.
+        cons = {}
+        for g in sorted(groups, key=base.get):
+            best_d, best_s = None, np.inf
+            for dcand in range(0, WINDOW_DAYS + 1):
+                trial = dict(cons, **{g: dcand})
+                s = (sum(curves.at[b, trial[gg]] for gg in trial for b in groups[gg])
+                     + mobility({gg: trial[gg] for gg in trial}))
+                if s < best_s:
+                    best_d, best_s = dcand, s
+            cons[g] = best_d
+        cand, s = climb(cons)
+        if s < best_score:
+            best, best_score = cand, s
     return best
 
 
 optimize_days.restarts = 2
 optimize_days.iters = 60
+optimize_days.constructive = False
 
 
 def plan_ecroute(pred, included, locations, start_time, day_q,
@@ -1680,6 +1701,7 @@ def walk_forward(table, scenario_ctx, origins, configs):
             EMERGENCY_DAY = cfg.get('emergency_day', WINDOW_DAYS + 3)
             optimize_days.restarts = int(cfg.get('restarts', 2))
             optimize_days.iters = int(cfg.get('iters', 60))
+            optimize_days.constructive = bool(cfg.get('constructive', False))
             included = pred.index[pred['p42'] >= cfg['p_star']]
             kwargs = {}
             if cfg['planner'] in ('ecroute', 'tsroute', 'tspig', 'tspig2', 'tscut'):