Phase 56 addendum: public refutes UNANCHORED frontier (1877.08, swaps 517 vs 580); fix = value-anchor to plain logbag

Count collapse, not ordering: logbag_rank's sum(p42) is 0.78-0.80x plain
logbag under deployment past-only fits at late origins (both-sides purge
fits hid it - swaps read flat in CV). FrontierRUL now anchors p42 VALUES to
a plain-logbag donor (count/pricing/timing = the measured 580-swap champion
machinery, byte-equivalent) while rank+gbm supply ONLY the order. Verified
at worst-collapse origins s_35/s_45: donor sums exact, frontier order exact,
top-13/25 identical. BATTERYSWAP_FRONTIER_ANCHOR=0 restores the refuted
unanchored form for forensics.

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

EXPERIMENTS.md

@@ -3048,3 +3048,34 @@ instrument); top-12 slot squatters are label-process ghosts that still die at
 real-but-subsumed; label windows d35/d21 count-starve (+72/+105); building-
 balanced +40; thinning +19..+32; past-only pool +19 (future-side purge pairs
 stabilize fits). Candidate CSVs: /tmp/cv_oofcand_*.csv (~180 full-48 files).
+
+### Phase 56 addendum - PUBLIC REFUTES the unanchored frontier (698401a: 1877.08); mechanism found and fixed same-day
+
+| | swaps | late-days | early-days | total |
+|---|---|---|---|---|
+| champion 3c7b883 | 580 | 5819 | 13197 | 1661.45 |
+| frontier 698401a | 517 | 7076 | 8011 | 1877.08 |
+| delta | **-63** | **+1257** | -5186 | +215.63 |
+
+The failure is a COUNT collapse, not (necessarily) an ordering failure: the
+value-preserving blend preserves the PRIMARY's (logbag_rank's) p42 values,
+and under deployment's PAST-ONLY fits that model's calibration collapses as
+the pool grows - measured sum(p42) ratio vs plain logbag: 1.02 (s_5), 1.01
+(s_15), 0.95 (s_25), 0.80 (s_35), 0.78 (s_45). Public scenarios live in the
+late-origin regime -> -11% swaps -> ~+5 extra misses/48. The purge CV could
+not see it: its fits train on BOTH sides of the window, where the two models
+calibrate identically (swaps 9.23 vs 9.21). Fourth public refutation of a
+locally-validated intervention (alpha, cliff, cert, unanchored frontier) -
+but the first with the failing channel measured and separable.
+
+FIX (same commit): FrontierRUL now VALUE-ANCHORS to plain logbag
+(BATTERYSWAP_FRONTIER_ANCHOR=1 default): the donor logbag supplies p42
+values - count/pricing/timing byte-equivalent to the old champion's measured
+580-swap calibration - and the rank+gbm frontier supplies ONLY the order.
+Ordering-only in deployment by construction, not just in CV. Verified at
+s_35/s_45 (worst collapse origins): anchored sum(p42) == plain logbag
+exactly; order == frontier blend exactly (top-13/top-25 sets identical;
+tie-aware rank comparison zero mismatches). What the anchored head tests
+publicly, cleanly for the first time: is the frontier ORDER better on the
+scored fleet? Downside is bounded to ordering (count machinery is the
+measured champion's).

batteryswap_example/submit.py

@@ -107,6 +107,16 @@ MODEL_KIND = 'logbag'
 # Confirmed local optimum by 5 lanes (hyperparams, features, weights, neural
 # rankers, physics blends all subsumed or worse head-to-head).
 FRONTIER = os.environ.get('BATTERYSWAP_FRONTIER', '1') != '0'
+# PUBLIC REFUTATION of the UNANCHORED frontier (698401a: 1877.08 vs 1661.45,
+# swaps 517 vs 580): under deployment's past-only fits, logbag_rank's
+# sum(p42) collapses vs plain logbag as the pool grows (measured ratio 1.02
+# at s_5 -> 0.78 at s_45; the purge CV's both-sides fits hid it - swaps read
+# flat there). The ordering signal was never publicly tested; the count
+# channel drowned it. ANCHOR fixes this by construction: plain logbag is the
+# VALUE DONOR (count/pricing/timing = the measured-580-swap calibration,
+# byte-identical to the old champion's machinery) and the frontier supplies
+# ONLY the rank order. Ordering-only in deployment, not just in CV.
+FRONTIER_ANCHOR = os.environ.get('BATTERYSWAP_FRONTIER_ANCHOR', '1') != '0'
 # Blend weight dial for public A/B: 0.30 = full frontier (purge 1630.3);
 # 0 = plain logbag_rank, no gbm (purge 1746.4 - the clean linear component,
 # fallback if the gbm increment turns out to be purge flattery on public);
@@ -132,6 +142,8 @@ class FrontierRUL:
         t['r_tau'] = t.groupby('origin')['tau_projected'].rank(pct=True)
         self.primary = LogBagFeats(['r_vlast', 'r_tau']).fit(t)
         self.partner = SklearnRUL('gbm').fit(t)
+        # value donor: the old champion's calibration owns the swap count
+        self.donor = SklearnRUL(MODEL_KIND).fit(train) if FRONTIER_ANCHOR else None
         return self
 
     def predict(self, rows):
@@ -141,17 +153,17 @@ class FrontierRUL:
         r['r_vlast'] = r['v_last'].rank(pct=True)
         r['r_tau'] = r['tau_projected'].rank(pct=True)
         pred = self.primary.predict(r)
-        if FRONTIER_W2 <= 0:
-            return pred
-        p2 = self.partner.predict(r)
-        rk = ((1 - FRONTIER_W2) * pred['p42'].rank(pct=True)
-              + FRONTIER_W2 * p2['p42'].rank(pct=True))
-        vals = np.sort(pred['p42'].values)[::-1]
-        pred = pred.copy()
-        pred['p42'] = pd.Series(
+        rk = pred['p42'].rank(pct=True)
+        if FRONTIER_W2 > 0:
+            p2 = self.partner.predict(r)
+            rk = (1 - FRONTIER_W2) * rk + FRONTIER_W2 * p2['p42'].rank(pct=True)
+        base = self.donor.predict(rows) if self.donor is not None else pred
+        vals = np.sort(base['p42'].values)[::-1]
+        out = base.copy()
+        out['p42'] = pd.Series(
             vals, index=rk.sort_values(ascending=False).index
-        ).reindex(pred.index)
-        return pred
+        ).reindex(out.index)
+        return out
 
 
 def _fit_model(train):