Phase 44: leaderboard inversion - appetite closed on numbers, tail transfer is the defect, no local instrument sees it

EXPERIMENTS.md

@@ -2226,3 +2226,90 @@ Every axis now has a measurement against it: appetite (public), features
 demonstrably extractable by someone. We cannot account for them from any
 mechanism measurable here, and the only path this sweep demonstrated is the
 one in (a), which we are not taking.
+
+## Phase 44 - why our late_swap is the field's highest (full leaderboard inversion)
+
+The public board exposes all 14 teams' components. Inverting each team's
+`late_swap` through the emergency-queue cost model (each miss = one dedicated
+day at `(24 + k) * 10`, solved for k self-consistently) gives, per scenario:
+
+| team | swaps | misses | caught | precision |
+|---|---|---|---|---|
+| J2W | 14.9 | 2.45 | 7.65 | 0.51 |
+| YassY | 17.4 | 2.37 | 7.73 | 0.44 |
+| CarlAlbert | 15.5 | 2.80 | 7.30 | 0.47 |
+| sackriti | 14.5 | 3.21 | 6.89 | 0.48 |
+| **us** | **12.1** | **4.69** | **5.41** | **0.45** |
+| kalsach | 28.2 | 2.14 | 7.96 | 0.28 |
+
+Deaths solve to ~10.1/scenario (local all-48 is 9.5 - good agreement).
+
+**Our per-swap precision, 0.45, is mid-pack in a field of 0.28-0.51.** The
+ranking is not broadly worse. We simply buy the fewest swaps in the
+competition - 580, against 695 for the next-lowest and 1355 for the highest -
+so we catch 5.41 where everyone else catches 7.3-8.0, and each of the ~2 extra
+misses costs ~285.
+
+### Appetite is genuinely closed - now with numbers, not an argument
+
+From phase 28's own measurement: +8.2 swaps/scenario moved `early_swap` +444,
+so a **marginal false swap costs 54**. Our ops (309 at 4.69 misses) against
+J2W's (252 at 2.45) prices the emergency day at **25 per miss**, so a miss
+costs 260 + 25 = **285**. Break-even is therefore **15.9%**, and our local
+precision in ranks 13-20 is `(0.705-0.564)*9.5/8` = **16.7%**. The marginal
+pick sits exactly on break-even. Raising alpha cannot pay.
+
+The cliff-contamination escape is also closed: **cliff rows die at 39.4%, 17x
+the base rate**, at 12.0 rows/scenario. They are good picks, so phase 28's
+"zero extra catches" was not an artifact of the boost's reordering.
+
+### The real defect, and why no local instrument can see it
+
+Our ranks 13-20 are 16.7% precise locally and **~0% on public** (phase 28: 395
+extra swaps bought `late_swap +13`). J2W's 13th-15th picks run at **80%**. The
+head transfers to a foreign fleet; the tail is noise.
+
+Where the misses live (native, 454 deaths):
+
+| rank band | n | frac stale > 7d | median n_30 |
+|---|---|---|---|
+| 1-12 (head) | 256 | 0.04 | 30 |
+| 13-30 (tail) | 104 | 0.03 | 30 |
+| 31+ | 94 | **0.30** | 30 |
+| fleet baseline | - | 0.16 | - |
+
+Rank 31+ is the closed silent-death channel (staleness at 2x the base rate).
+The tail is **fully-observed devices** - 3% stale, 30 readings in 30 days -
+that we simply order below rank 12 and J2W orders above it.
+
+Two things were tested against it and both failed:
+
+- **Fleet calibration shift.** The half-fleet gate splits ONE fleet, so it has
+  no calibration offset by construction. Injected one (+/-0.03, +/-0.06 V on
+  the target fleet only, with tau moved along the curve at 572 d/V). Recall
+  moved by at most 0.005 at every N. The reason is elementary and closes the
+  hypothesis: **a uniform offset shifts every device's linear predictor
+  equally and cannot reorder a linear model at all.** It also explains why
+  `vrel` does nothing - it protects against the one perturbation that was
+  already harmless.
+- **Regularisation.** Effective n is ~80 death-batteries, not 66503 rows, so
+  `logbag`'s `C=1.0` is tuned for a sample ~800x too large. Swept C over 100x:
+
+  | | C=1.0 | C=0.3 | C=0.1 | C=0.03 | C=0.01 |
+  |---|---|---|---|---|---|
+  | gate, tail gain 13-30 | 0.154 | 0.155 | 0.157 | 0.158 | 0.153 |
+  | native, tail gain 13-30 | 0.229 | 0.231 | **0.247** | 0.244 | 0.240 |
+  | native rec@12 | **0.564** | 0.562 | 0.551 | 0.557 | 0.555 |
+
+  Flat on the gate. Natively it trades head for tail (C=0.3: +5 at N=16 and +6
+  at N=20, both 5W/0L, but -1 at N=12). At our operating N of ~12 it is
+  negative. Rejected.
+
+**The blocker is instrumental.** The gate reports a perfectly healthy tail -
+rec@12 0.766, tail gain 0.154 - while public reports ~0% marginal precision
+there. No local protocol reproduces the defect, so no local protocol can
+validate a fix for it. That is the honest reason this stops here rather than
+a claim that nothing is left: J2W demonstrably finds 2.2 deaths per scenario,
+in well-observed data, that our ordering puts below the cut.
+
+Standing champion remains **3c7b883 at 1661.45**.

batteryswap_example/cv.py

@@ -352,9 +352,52 @@ def _order_stats(p42, deaths, ns):
     return out
 
 
+# Voltage-LEVEL features. A fleet whose sensors sit at a different calibration
+# offset shifts all of these together; every other feature in FEATURES is a
+# difference, a rate, a count or a self-relative fraction (below_frac is scored
+# against the device's OWN baseline) and is therefore offset-invariant. vrel
+# and vmin7_rank are invariant BY CONSTRUCTION - that is what they are for.
+LEVEL_FEATURES = ('v_last', 'v_min_30', 'v_min_7', 'v_corr_last', 'thresh_dist')
+
+
+def apply_fleet_shift(rows, delta, dtau_dv=None):
+    """Simulate a differently-calibrated target fleet.
+
+    The half-fleet gate splits ONE fleet, so both halves share sensor
+    calibration, battery batches and the maintenance era - it has no
+    fleet-level offset by construction and therefore CANNOT test transfer
+    under one. This injects the offset a real held-out fleet may carry.
+
+    vrel and vmin7_rank are recomputed from the shifted values and come out
+    numerically identical; that is the whole point of the comparison.
+    """
+    r = rows.copy()
+    for c in LEVEL_FEATURES:
+        if c in r.columns:
+            r[c] = r[c] + delta
+    if dtau_dv and 'tau_projected' in r.columns:
+        # tau is days-to-threshold read off the temp-corrected curve, so an
+        # offset moves it along the local slope of that curve
+        r['tau_projected'] = r['tau_projected'] + delta * dtau_dv
+    if 'vrel' in r.columns:
+        r['vrel'] = r['v_last'] - r['v_last'].median()
+    if 'vmin7_rank' in r.columns:
+        r['vmin7_rank'] = r['v_min_7'].rank(pct=True)
+    return r
+
+
+def estimate_dtau_dv(t):
+    """Empirical days-of-tau per volt, from the fleet's own corrected curve."""
+    d = t[['tau_projected', 'v_corr_last']].dropna()
+    d = d[d['tau_projected'].abs() < 400]
+    if len(d) < 100:
+        return 0.0
+    return float(np.polyfit(d['v_corr_last'], d['tau_projected'], 1)[0])
+
+
 def ablate(variants=ABLATION, protocol='all48', origins=range(48),
            ns=(8, 12, 16, 20, 30), seeds=(0, 1, 2, 3, 4),
-           dataset_path=Path('dataset')):
+           dataset_path=Path('dataset'), shift=0.0, shift_tau=True):
     """Phase-39's standing directive, made runnable.
 
     A feature ablation scored on COST cannot answer whether a feature helped:
@@ -393,6 +436,10 @@ def ablate(variants=ABLATION, protocol='all48', origins=range(48),
     else:
         locations, timeseries, eol_times, scenarios = mc.load_dataset(
             dataset_path / 'train')
+        dtau_dv = estimate_dtau_dv(t)
+        if shift:
+            print(f'TARGET-fleet shift {shift:+.3f} V, dtau/dv {dtau_dv:.0f} d/V',
+                  file=sys.stderr)
         dev_b = locations.drop_duplicates('battery').set_index('battery')['building']
         t['bldg'] = t['device_id'].map(dev_b)
         closed = t['origin'] <= t['origin'].max() - pd.Timedelta(days=WINDOW_DAYS)
@@ -416,6 +463,9 @@ def ablate(variants=ABLATION, protocol='all48', origins=range(48),
                                      & (e <= T + pd.Timedelta(days=WINDOW_DAYS))])
                 if not deaths:
                     continue
+                if shift:
+                    rows = apply_fleet_shift(
+                        rows, shift, dtau_dv if shift_tau else None)
                 for v in variants:
                     mc.FEATURES = list(VARIANTS[v](t))
                     p = models[v].predict(rows)['p42']