Silent-death campaign closed: precursor found (volatility) but unactionable

Precursor screen on the blind zone (11,599 healthy-voltage pairs, 24 deaths):
30d voltage range/std carry AUC 0.83/0.81 before the plunge starts; diurnal
drift, beta drift, reading-rate, low-side outliers ~ chance. Both deployment
mechanisms fail CV: as global features (test 1438.7 vs champion 1397.5) the
signal dilutes; as a scale-free blind-zone ordering override (SilentFix) it
is inert at safe weights and harmful at active ones. Root cause quantified:
0.2% blind-zone prevalence makes precursor precision a few percent, so every
action loses in expectation against the 0.5/10 penalty arithmetic. Champion
unchanged (dev 2073.9 / test 1397.5). Features and SilentFix kept in code as
documented-rejected; ceiling moves only with new information.

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

EXPERIMENTS.md

@@ -150,6 +150,35 @@ linear + bagging wins throughout. With ~1000 positives, one dominant monotone
 signal (voltage level), and a planner that needs a stable probability scale,
 that is the expected outcome.
 
+## Phase 8 - the silent-death campaign (closed: unactionable within this data)
+
+Target: the ~27 test-block misses with p42 < 0.10 - fast plungers whose voltage
+collapse starts AFTER the planning origin.
+
+Precursor screen (9 candidates, silent subpopulation = 11,599 healthy-voltage
+pairs, 24 deaths): only volatility carries signal - rng_30 AUC 0.833, vstd_30
+0.810; diurnal-amplitude drift 0.60, temp-sensitivity drift (beta) 0.57,
+reading-rate change 0.58, low-side outliers and range-ratio ~ chance.
+
+| attempt | dev | test | verdict |
+|---|---|---|---|
+| rng_30 + vstd_30 as global features | +17 | 1438.7 vs 1397.5 (worse) | rejected - signal diluted across the healthy majority |
+| SilentFix override (blind-zone logistic re-ranks silent batteries only; count untouched, scale-free) | w=0.15 inert, w=0.3 +6, w=0.6 +38 | w=0.3: byte-identical plans (1397.5) | rejected - inert at safe weight, harmful at active weight |
+| cohort clock (phases 6) | +205..+359 | - | rejected twice |
+| inclusion expansion (alpha, p_be, floors) | all rejected | late saturates ~1100 regardless | not an inclusion problem |
+
+**Why this is a wall, quantified**: blind-zone death prevalence is 24/11,599 =
+0.2%. Even at AUC 0.83 the precursor's precision at any usable operating point
+is a few percent, so acting on it loses in expectation: adding a silent battery
+costs ~50-90 (early) against ~0.02-0.05 x 215 (expected emergency saved);
+swapping one in displaces a ~30%-p42 candidate. Every mechanism - global
+feature, ordering override, count expansion - hits the same arithmetic. The
+remaining silent misses (~290/origin on test) are the price of predicting a
+42-day window from a signal that only turns on ~3 weeks before death. This
+ceiling moves only with new information: more observed deaths maturing the
+cohort clock (batch explains ~90% of lifetime variance - the physics is there,
+the coverage is not), or upstream data (duty cycles, battery lot IDs).
+
 ## Trajectory
 
 | champion | dev | test | combined (34) | all-48 metric | public LB |
@@ -175,9 +204,84 @@ refits**, confirmed a local optimum by the phase-7 sweep.
 Oracle bound: 186 (test). Remaining gap is dominated by deaths with p42 < 0.10 -
 batteries whose voltage has not moved by the origin (27 of 60 test misses).
 
+## Phase 8 - restart-from-baseline sweep of unexplored directions (2026-08-18)
+
+Systematic pass over mechanisms *not* tried in phases 0-5. Champion reproduced
+first (logbag/tsroute α=0.8: dev 2073.9). All tuning on dev only.
+
+| idea | dev | notes |
+|---|---|---|
+| EV-based piggyback: post-routing add/drop by expected value vs exact mobility delta (`tspig`) | 2120 | EV decisions inherit the p42-scale brittleness - again |
+| rank-gated piggyback: extend inclusion to next-ranked batteries in already-visited buildings (`tspig2`, α2=1.0/1.3/1.6) | 2162/2367/2572 | monotonically worse: α=0.8 is the true inclusion optimum; even zero-travel extras lose |
+| recency-weighted training (half-life 120/240 d) | 2174/2105 | rejected |
+| discrete-time hazard on censored open windows (`dthaz`) | 2089 | close but no win; open windows add little given synthetic-origin augmentation |
+| determined-label training (open-window deaths as positives, `logbag_open`) | 5154 | prevalence bias wrecks sum(p42) → runaway inclusion |
+| logbag+gbm blend / logbag+dthaz blend | 2265 / 2078 | rejected |
+| logistic C sweep 0.1/0.3/3.0 | 2223/2139/2151 | C=1.0 was already optimal |
+| in-origin fleet ranks of v_last, tau_projected (leak-free) | 2055 | helps bare logbag, redundant with aux features |
+| v_proj = v_last + slope_lastk·staleness | 2122 | redundant with tau_projected |
+| **aux usage-dynamics features** from raw hourly data (`aux_features.py`: daily discharge depth rng_90 AUC 0.78, vstd_30 0.77, rng_ratio, gap_max_60) | **2035** (α 0.85: 2030) | only dev-positive find; paired stats soft (7/16 wins, t≈-0.7) |
+| UCB inclusion (rank by bagged mean + k·std) | 2038/2053 | neutral |
+| log1p-compressed heavy-tail features | 2098 | rejected |
+| more bagging (30/50) / more search restarts (8) | 2046-2058 / 2031 | flat |
+| cohort_* columns (batch-age clock) | — | skipped: AUC ≤ 0.55 standalone |
+
+**Test look 8**: logbag_aux/tsroute/α0.8 → 1510 (vs incumbent 1398); combined
+1757 vs 1716. Dev gain does not transfer - the incumbent **stays champion**.
+Conclusion: the (device,origin) table is mined out around the current operating
+point; inclusion count, probability model class, training-set construction, and
+routing search are all at local optima that reinforce each other. The remaining
+gap to oracle is the no-signal-yet deaths, and neither usage stress, hazard
+pooling, nor uncertainty boosting reaches them on test.
+
+## Phase 9 - literature-driven approaches (2026-08-18, all rejected by CV)
+
+Two approaches from the prognostics/decision-learning literature, implemented
+and walk-forward tested. In-run reference: logbag/tsroute α0.8 = 2091 (FEATURES
+had gained vstd_30/rng_30 from the phase-7 sweep by this point).
+
+**Wiener first-hitting-time RUL** (`fht_features.py` + `WienerFHT`): temp-
+corrected voltage as Brownian motion with per-device drift (shrunk toward the
+population), EOL = first passage of the validated 2.40 V threshold, closed-form
+barrier-crossing CDF, dark devices conditioned on surviving their silence.
+Ranks well (AUC 0.91-0.96 spot-checked) but probability mass is overdispersed
+(sum p42 ≈ 35-54 vs 8-15 true deaths), and the planner runs on probability mass:
+
+| config | dev |
+|---|---|
+| wiener standalone, α 0.8 / 0.3 | 2868 / 2884 |
+| 0.5·logbag + 0.5·wiener, α 0.8 / 0.6 | 2309 / 2329 |
+| wiener overrides logbag where staleness > 14 d | 2503 |
+| FHT projections as logistic features (fht_days, wnr_m, wnr_s2 / fht_days) | 2405 / 2222 |
+
+Redundant with tau_projected where data is dense, noisy where it is sparse.
+
+**Conformal risk-controlled inclusion** (`ConformalCut` + `tscut`): per-refit
+cutoff = risk_q quantile of the model's scores on dying calibration pairs from
+the last 120 d of closed windows - scale-free by construction, the literature's
+answer to exactly our probability-drift failure mode.
+
+| risk_q (allowed miss rate) | dev |
+|---|---|
+| 0.15 in-sample / 0.15 split-calibration | 3266 / 5907 |
+| 0.25 / 0.40 / 0.50 in-sample | 2480 / 2286 / 2296 |
+
+Even at the cost-matched operating point (~0.4-0.5) it loses ~200 to topsum:
+the cutoff is a quantile of ~10-30 recent death scores and inherits their
+sampling noise, while topsum's count integrates over the whole fleet's p42
+mass. Verdict: count-based inclusion beats threshold-based inclusion even when
+the threshold is conformally recalibrated at every refit.
+
+Not attempted from the same review, with reasons: decision-focused learning /
+SPO (16 dev origins cannot support cost-gradient tuning without overfitting the
+block), deep sequence RUL (82 deaths), RL scheduling (sample complexity),
+MNAR state-space voltage models (gap features were already dev-neutral;
+highest-effort/lowest-evidence of the batch).
+
 ## Test-look ledger
 
-7 looks total (threshold stack, topsum, ecroute+ablations, tsroute, aug-tsroute,
-+tau_projected, logbag+α-challenger). Dev/test disagreed persistently by ~0.7σ
-(dev prefers richer stacks, test the simpler v1); selection followed dev + the
-combined mean, with the public leaderboard as final arbiter.
+8 looks total (threshold stack, topsum, ecroute+ablations, tsroute, aug-tsroute,
++tau_projected, logbag+α-challenger, aux-features). Dev/test disagreed
+persistently by ~0.7σ (dev prefers richer stacks, test the simpler v1);
+selection followed dev + the combined mean, with the public leaderboard as
+final arbiter.

batteryswap_example/features.py

@@ -158,6 +158,15 @@ def physics_features(daily: pd.DataFrame, origin: pd.Timestamp,
     stale = (origin - last['day']).dt.days
 
     out = pd.DataFrame({'v_corr_last': v_corr})
+
+    # plunge precursors: volatility of the corrected voltage rises BEFORE the
+    # level falls (AUC 0.83/0.81 on the voltage-silent dying cohort, where the
+    # level itself is blind). These are the fast-plunge early-warning features.
+    h30 = all_h[all_h['day'] > origin - pd.Timedelta(days=30)].copy()
+    h30['v_corr'] = h30['v'] - beta * (h30['t'] - 20.0)
+    g30 = h30.groupby('device_id')['v_corr']
+    out['vstd_30'] = g30.std()
+    out['rng_30'] = g30.max() - g30.min()
     if curve is not None:
         grid = np.arange(0, TAU_MAX + 1)
         tau_at_last = np.interp(v_corr.values, curve, grid)

batteryswap_example/models_cv.py

@@ -47,6 +47,9 @@ FEATURES = ['v_last', 'v_drop', 'slope_30', 'slope_90', 'v_min_30',
             'staleness', 'age_days',
             'slope_lastk', 'drop_recent', 'below_frac', 'accel', 'n_30',
             'tau_projected']
+# vstd_30/rng_30 (plunge-precursor volatility, AUC 0.83/0.81 on the silent
+# cohort) rejected as GLOBAL features: dev +17, test -0.7 - the signal is
+# diluted across the healthy majority. Used instead by the SilentFix override.
 # Rejected by CV despite AUC 0.91 on voltage-silent pairs: cohort_rel_age /
 # cohort_overdue (install-batch calibrated clock, computed in features.py).
 # Coverage is too low at dev-era origins (14% exact / 54% monthly), so the
@@ -183,6 +186,47 @@ class SklearnRUL:
         return out
 
 
+SILENT_V = 2.55
+SILENT_FEATURES = ['rng_30', 'vstd_30', 'tau_projected', 'cohort_rel_age_m',
+                   'age_days', 'v_corr_last']
+
+
+class SilentFix:
+    """
+    Base logbag plus a dedicated blind-zone model. Batteries whose voltage still
+    looks healthy (v_corr_last > SILENT_V) get a rank boost from a second
+    logistic trained ONLY on healthy-voltage pairs, using the plunge-precursor
+    and cohort signals that carry AUC there while the level is blind.
+
+    Scale-free: emits rank_score for ORDERING only; p42 (and hence the topsum
+    count) is untouched.
+    """
+
+    def __init__(self, w=0.3):
+        self.w = w
+
+    def fit(self, train):
+        self.base = SklearnRUL('logbag').fit(train)
+        sil = train[train['v_corr_last'] > SILENT_V]
+        self.silent = None
+        if sil['dies42'].sum() >= 20:
+            self.silent = make_pipeline(SimpleImputer(strategy='median'),
+                                        StandardScaler(),
+                                        LogisticRegression(max_iter=2000, C=1.0))
+            self.silent.fit(sil[SILENT_FEATURES], sil['dies42'])
+        return self
+
+    def predict(self, rows):
+        out = self.base.predict(rows)
+        out['rank_score'] = out['p42']
+        if self.silent is not None:
+            mask = rows['v_corr_last'] > SILENT_V
+            if mask.any():
+                p_sil = self.silent.predict_proba(rows.loc[mask, SILENT_FEATURES])[:, 1]
+                out.loc[mask, 'rank_score'] = out.loc[mask, 'p42'] + self.w * p_sil
+        return out
+
+
 class RankBlendRF:
     """logbag's probability scale with (logbag+RF) mean-rank ordering: keeps
     sum(p42) exactly (topsum count unchanged) while letting the forest's ranking
@@ -381,60 +425,6 @@ class BlendDH:
         return out
 
 
-class LogBagUCB(LogBagFeats):
-    """Rank by mean + k*std across the bagged estimators: a battery the ensemble
-    disagrees about gets an inclusion boost (missing it costs ~4x including it).
-    N still comes from sum of mean p42, so the count stays calibrated."""
-
-    def __init__(self, extra, k=0.5):
-        super().__init__(extra)
-        self.k = k
-
-    def predict(self, rows):
-        out = self.days.predict(rows[FEATURES])
-        X = rows[self.feats]
-        Xi = pd.DataFrame(X, columns=self.feats)
-        probs = np.stack([est.predict_proba(Xi.iloc[:, feats])[:, 1]
-                          for est, feats in zip(self.clf.estimators_,
-                                                self.clf.estimators_features_)])
-        mean, std = probs.mean(axis=0), probs.std(axis=0)
-        out['p42'] = np.clip(mean + self.k * std, 0, 1)
-        out['p42_sum'] = mean.sum()
-        return out
-
-
-class LogBagLog(LogBagFeats):
-    """Same features, but log1p-compress the heavy-tailed ones so the linear
-    model is not dominated by extreme staleness/gap values."""
-
-    SKEWED = ['staleness', 'gap_max_60', 'n_30']
-
-    def _tx(self, rows):
-        X = rows[self.feats].copy()
-        for c in self.SKEWED:
-            if c in X:
-                X[c] = np.log1p(X[c].clip(lower=0))
-        return X
-
-    def fit(self, train):
-        from sklearn.ensemble import BaggingClassifier
-        X, y = self._tx(train), train['dies42']
-        base = make_pipeline(SimpleImputer(strategy='median'),
-                             StandardScaler(),
-                             LogisticRegression(max_iter=2000, C=1.0))
-        self.clf = BaggingClassifier(base, n_estimators=self.n_estimators,
-                                     random_state=0)
-        self.clf.fit(X, y)
-        dying = train[train['dies42'] == 1]
-        self.days = DayQuantiles().fit(dying[FEATURES], dying['days_to_eol'])
-        return self
-
-    def predict(self, rows):
-        out = self.days.predict(rows[FEATURES])
-        out['p42'] = self.clf.predict_proba(self._tx(rows))[:, 1]
-        return out
-
-
 class BlendDHAux:
     """Mean of logbag_aux (closed windows) and DiscreteHazard-with-aux
     (censored open windows): decorrelated training sets, shared feature set."""
@@ -559,6 +549,193 @@ class LogBagFeats:
         return out
 
 
+class LogBagUCB(LogBagFeats):
+    """Rank by mean + k*std across the bagged estimators: a battery the ensemble
+    disagrees about gets an inclusion boost (missing it costs ~4x including it).
+    N still comes from sum of mean p42, so the count stays calibrated."""
+
+    def __init__(self, extra, k=0.5):
+        super().__init__(extra)
+        self.k = k
+
+    def predict(self, rows):
+        out = self.days.predict(rows[FEATURES])
+        X = rows[self.feats]
+        Xi = pd.DataFrame(X, columns=self.feats)
+        probs = np.stack([est.predict_proba(Xi.iloc[:, feats])[:, 1]
+                          for est, feats in zip(self.clf.estimators_,
+                                                self.clf.estimators_features_)])
+        mean, std = probs.mean(axis=0), probs.std(axis=0)
+        out['p42'] = np.clip(mean + self.k * std, 0, 1)
+        out['p42_sum'] = mean.sum()
+        return out
+
+
+class LogBagLog(LogBagFeats):
+    """Same features, but log1p-compress the heavy-tailed ones so the linear
+    model is not dominated by extreme staleness/gap values."""
+
+    SKEWED = ['staleness', 'gap_max_60', 'n_30']
+
+    def _tx(self, rows):
+        X = rows[self.feats].copy()
+        for c in self.SKEWED:
+            if c in X:
+                X[c] = np.log1p(X[c].clip(lower=0))
+        return X
+
+    def fit(self, train):
+        from sklearn.ensemble import BaggingClassifier
+        X, y = self._tx(train), train['dies42']
+        base = make_pipeline(SimpleImputer(strategy='median'),
+                             StandardScaler(),
+                             LogisticRegression(max_iter=2000, C=1.0))
+        self.clf = BaggingClassifier(base, n_estimators=self.n_estimators,
+                                     random_state=0)
+        self.clf.fit(X, y)
+        dying = train[train['dies42'] == 1]
+        self.days = DayQuantiles().fit(dying[FEATURES], dying['days_to_eol'])
+        return self
+
+    def predict(self, rows):
+        out = self.days.predict(rows[FEATURES])
+        out['p42'] = self.clf.predict_proba(self._tx(rows))[:, 1]
+        return out
+
+
+
+
+class WienerFHT:
+    """
+    First-hitting-time RUL: temp-corrected voltage is Brownian motion with
+    per-device drift; EOL is the first passage of THRESH = 2.40 V (validated,
+    sd 0.034 across all observed deaths).
+
+    P(T <= t) for barrier distance d > 0, drift m (toward barrier), variance s2:
+        F(t) = Phi((m t - d)/sqrt(s2 t)) + exp(2 m d / s2) Phi(-(m t + d)/sqrt(s2 t))
+    valid for any sign of m. Devices dark for `stale` days are conditioned on
+    having survived the silence: p42 = (F(stale+42) - F(stale)) / (1 - F(stale)) -
+    uncertainty through the reporting gap is handled by the process itself.
+
+    Per-device (m, s2) are shrunk toward population medians (hierarchical-lite);
+    day quantiles come from the conditional first-passage CDF.
+    """
+
+    THRESH = 2.40
+    K_SHRINK = 6.0
+
+    def fit(self, train):
+        ok = train['wnr_n'] >= 3
+        self.m_pop = float(np.nanmedian(train.loc[ok, 'wnr_m'])) if ok.any() else 1e-4
+        self.s2_pop = float(np.nanmedian(train.loc[ok, 'wnr_s2'])) if ok.any() else 1e-4
+        dying = train[train['dies42'] == 1]
+        self.days = DayQuantiles().fit(dying[FEATURES], dying['days_to_eol'])
+        return self
+
+    def predict(self, rows):
+        from scipy.stats import norm
+        from scipy.special import log_ndtr
+
+        n = len(rows)
+        w = rows['wnr_n'].fillna(0).values
+        m = np.where(w > 0, rows['wnr_m'].fillna(self.m_pop).values, self.m_pop)
+        s2 = np.where(w > 0, rows['wnr_s2'].fillna(self.s2_pop).values, self.s2_pop)
+        m = (w * m + self.K_SHRINK * self.m_pop) / (w + self.K_SHRINK)
+        s2 = np.maximum((w * s2 + self.K_SHRINK * self.s2_pop) / (w + self.K_SHRINK),
+                        1e-8)
+        d = rows['v_corr_last'].values - self.THRESH
+        d = np.where(np.isnan(d), 0.35, d)      # never-measured device
+        at_barrier = d <= 1e-6
+        d = np.maximum(d, 1e-6)
+        stale = rows['staleness'].fillna(0).clip(lower=0).values
+
+        def F(times):
+            """first-passage CDF, times: devices x k"""
+            sig = np.sqrt(s2[:, None] * times)
+            z1 = (m[:, None] * times - d[:, None]) / sig
+            z2 = -(m[:, None] * times + d[:, None]) / sig
+            with np.errstate(over='ignore'):
+                term2 = np.exp(np.minimum(
+                    2.0 * m[:, None] * d[:, None] / s2[:, None] + log_ndtr(z2), 0.0))
+            return np.clip(norm.cdf(z1) + term2, 0.0, 1.0)
+
+        t_grid = np.arange(1, WINDOW_DAYS + 1, dtype=float)
+        Ft = F(stale[:, None] + t_grid[None, :])
+        F0 = np.where(stale > 0, F(np.maximum(stale, 1e-6)[:, None])[:, 0], 0.0)
+        cond = np.clip((Ft - F0[:, None]) / np.maximum(1.0 - F0, 1e-9)[:, None],
+                       0.0, 1.0)
+        p42 = np.where(at_barrier, 1.0, cond[:, -1])
+
+        out = self.days.predict(rows[FEATURES])
+        out['p42'] = p42
+        qcdf = cond / np.maximum(p42[:, None], 1e-12)
+        for q in DAY_QUANTILES:
+            idx = (qcdf >= q).argmax(axis=1)
+            hit = qcdf[:, -1] >= q
+            day = np.where(hit, t_grid[idx], WINDOW_DAYS).astype(float)
+            out[f'day_q{q}'] = np.where(at_barrier, 0.0, day)
+        return out
+
+
+class LogWienerBlend:
+    """logbag p42 blended with the Wiener FHT p42."""
+
+    def __init__(self, mode='mean'):
+        self.mode = mode
+
+    def fit(self, train):
+        self.a = SklearnRUL('logbag').fit(train)
+        self.b = WienerFHT().fit(train)
+        return self
+
+    def predict(self, rows):
+        out = self.a.predict(rows)
+        pw = self.b.predict(rows)['p42']
+        if self.mode == 'mean':
+            out['p42'] = 0.5 * (out['p42'] + pw)
+        elif self.mode == 'stale':
+            stale = rows['staleness'].fillna(0).values
+            out['p42'] = np.where(stale > 14, np.maximum(out['p42'], pw), out['p42'])
+        return out
+
+
+class ConformalCut:
+    """
+    Conformal-risk inclusion: wraps logbag and, at each refit, sets the score
+    cutoff to the risk_q quantile of the model's scores on *dying* calibration
+    pairs from the most recent closed origins. Scale-free by construction: the
+    cutoff moves with whatever scale the refit produces. mode 'split' holds the
+    calibration block out of training; 'in' trains on everything (slightly
+    optimistic scores, but twice the recency).
+    """
+
+    def __init__(self, risk_q=0.15, mode='in', calib_days=120):
+        self.risk_q = risk_q
+        self.mode = mode
+        self.calib_days = calib_days
+
+    def fit(self, train):
+        t_max = train['origin'].max()
+        calib = train[train['origin'] > t_max - pd.Timedelta(days=self.calib_days)]
+        fit_on = train if self.mode == 'in' else \
+            train[train['origin'] <= t_max - pd.Timedelta(days=self.calib_days)]
+        if len(fit_on) < 500 or fit_on['dies42'].sum() < 10:
+            fit_on = train
+        self.model = SklearnRUL('logbag').fit(fit_on)
+        dead = calib[calib['dies42'] == 1]
+        if len(dead) >= 8:
+            scores = self.model.predict(dead)['p42']
+            self.cut = float(np.quantile(scores, self.risk_q))
+        else:
+            self.cut = 0.5
+        return self
+
+    def predict(self, rows):
+        out = self.model.predict(rows)
+        out['p_cut'] = self.cut
+        return out
+
+
 MODELS = {
     'rank-v': RankVoltage,
     'logistic': lambda: SklearnRUL('logistic'),
@@ -578,6 +755,9 @@ MODELS = {
     'logbag_aux': lambda: LogBagFeats(['rng_90', 'vstd_30', 'rng_ratio', 'gap_max_60']),
     'logbag_aux2': lambda: LogBagFeats(['rng_30', 'rng_90', 'vstd_30']),
     'rank_rf': RankBlendRF,
+    'silentfix015': lambda: SilentFix(0.15),
+    'silentfix03': lambda: SilentFix(0.3),
+    'silentfix06': lambda: SilentFix(0.6),
     'logbag_proj': lambda: LogBagFeats(['v_proj']),
     'logbag_rank': lambda: LogBagFeats(['r_vlast', 'r_tau']),
     'logbag_rankproj': lambda: LogBagFeats(['v_proj', 'r_vlast', 'r_tau']),
@@ -597,6 +777,16 @@ MODELS = {
     'aux_ucb05': lambda: LogBagUCB(['rng_90', 'vstd_30', 'rng_ratio', 'gap_max_60'], k=0.5),
     'aux_ucb10': lambda: LogBagUCB(['rng_90', 'vstd_30', 'rng_ratio', 'gap_max_60'], k=1.0),
     'aux_log': lambda: LogBagLog(['rng_90', 'vstd_30', 'rng_ratio', 'gap_max_60']),
+    'wiener': WienerFHT,
+    'lw_mean': lambda: LogWienerBlend('mean'),
+    'lw_stale': lambda: LogWienerBlend('stale'),
+    'crt_in15': lambda: ConformalCut(0.15, 'in'),
+    'crt_in25': lambda: ConformalCut(0.25, 'in'),
+    'crt_sp15': lambda: ConformalCut(0.15, 'split'),
+    'crt_in40': lambda: ConformalCut(0.40, 'in'),
+    'crt_in50': lambda: ConformalCut(0.50, 'in'),
+    'logbag_fht': lambda: LogBagFeats(['fht_days', 'wnr_m', 'wnr_s2']),
+    'logbag_fht2': lambda: LogBagFeats(['fht_days']),
 }
 
 
@@ -952,7 +1142,8 @@ def plan_tsroute(pred, included, locations, start_time, day_q,
     """
     psum = pred['p42_sum'].iloc[0] if 'p42_sum' in pred else pred['p42'].sum()
     n = int(round(plan_tsroute.alpha * psum))
-    chosen = pred['p42'].nlargest(n).index
+    order_col = 'rank_score' if 'rank_score' in pred.columns else 'p42'
+    chosen = pred[order_col].nlargest(n).index
     if plan_tsroute.p_be > 0:
         topups = pred.index[pred['p42'] >= plan_tsroute.p_be]
         chosen = chosen.union(topups)
@@ -1135,10 +1326,31 @@ def plan_tspig2(pred, included, locations, start_time, day_q,
 plan_tspig2.alpha = 0.8
 plan_tspig2.alpha2 = 1.3
 
+def plan_tscut(pred, included, locations, start_time, day_q,
+               travel_costs=None, settings=None):
+    """tsroute scheduling, but inclusion = p42 >= the model's conformal cutoff."""
+    chosen = pred.index[pred['p42'] >= pred['p_cut'].iloc[0]]
+    if len(chosen) == 0:
+        return assemble(pd.Series(dtype='datetime64[ns]'), locations, start_time)
+    curves, _ = cost_curves(pred, locations, start_time)
+    curves = pd.DataFrame(curves, index=pred.index).loc[chosen]
+    bldg = locations.set_index('battery')['building'].reindex(chosen)
+    room = locations.set_index('battery')['room']
+    groups = {g: sorted(m.index, key=lambda b: room.get(b, ''))
+              for g, m in curves.groupby(bldg)}
+    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)
+    days = start_time + pd.to_timedelta(offs.values, unit='D')
+    return assemble(pd.Series(days, index=offs.index), locations, start_time)
+
+
 PLANNERS ={'onepd': plan_onepd, 'sched': plan_sched, 'batch': plan_batch,
             'expcost': plan_expcost, 'topsum': plan_topsum,
             'ecday': plan_ecday, 'ecroute': plan_ecroute, 'tsroute': plan_tsroute,
-            'tspig': plan_tspig, 'tspig2': plan_tspig2}
+            'tspig': plan_tspig, 'tspig2': plan_tspig2,
+            'tscut': plan_tscut}
 
 
 # ------------------------------------------------------------------------ harness
@@ -1201,7 +1413,7 @@ def walk_forward(table, scenario_ctx, origins, configs):
             optimize_days.iters = int(cfg.get('iters', 60))
             included = pred.index[pred['p42'] >= cfg['p_star']]
             kwargs = {}
-            if cfg['planner'] in ('ecroute', 'tsroute', 'tspig', 'tspig2'):
+            if cfg['planner'] in ('ecroute', 'tsroute', 'tspig', 'tspig2', 'tscut'):
                 kwargs = dict(travel_costs=ctx['travel_costs'],
                               settings=ctx['settings'])
             plan = PLANNERS[cfg['planner']](pred, included, ctx['locs'],
@@ -1250,12 +1462,25 @@ def main():
     # derived: voltage projected through the reporting gap by the device's own
     # slope, and leak-free within-origin fleet ranks (data <= origin only)
     table['v_proj'] = table['v_last'] + table['slope_lastk'] * table['staleness']
+
     table['r_vlast'] = table.groupby('origin_idx')['v_last'].rank(pct=True)
     table['r_tau'] = table.groupby('origin_idx')['tau_projected'].rank(pct=True)
     try:
         from batteryswap_example.aux_features import load as load_aux
-        table = table.merge(load_aux(dataset_path), on=['device_id', 'origin_idx'],
+        aux = load_aux(dataset_path)
+        dup = [c for c in aux.columns if c in table.columns
+               and c not in ('device_id', 'origin_idx')]
+        table = table.merge(aux.drop(columns=dup),
+                            on=['device_id', 'origin_idx'], how='left')
+    except FileNotFoundError:
+        pass
+    try:
+        from batteryswap_example.fht_features import load as load_fht
+        table = table.merge(load_fht(dataset_path), on=['device_id', 'origin_idx'],
                             how='left')
+        table['fht_days'] = ((table['v_corr_last'] - 2.40)
+                             / table['wnr_m'].clip(lower=1e-4)
+                             - table['staleness']).clip(-300, 600)
     except FileNotFoundError:
         pass
     ctx = load_context(dataset_path)