ADOPT campaign-2 frontier ft_vmin7r_wnr20: BATTERYSWAP_FT2 default ON

Ft2RUL = logbag on FEATURES+vmin7_rank, 0.20 value-preserving WienerFHT
order blend (order remapped onto primary's own sorted p42 values; count/
pricing/timing untouched). bgkf v5: 1688.4 vs 1760.2 (-71.8 +/- 23.5,
3.05 sigma, Wilcoxon .037, swaps flat, count-clean; reproduced exactly by
3 lanes). Worst-case within-test-fleet vmin7 recompute still -60.8 (2.3
sigma). Deployment parity vs the CV frontier: bit-exact (max cell diff 0).
wnr_m/s2/n merged into the shipped train table; split-path wiener params
computed past-only from the scored split's own telemetry (0.1s/scenario).
Soft degradation: missing wnr -> pure vm7 order; fit error -> legacy
champion. BATTERYSWAP_FT2=0 reverts to the measured-1661.45 config.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

agent_reports_bgkf/artifacts/compose.py

@@ -0,0 +1,45 @@
+"""General composer on cv.run_bgkf: registers vm7 variant + custom aux kinds
+in-process, then runs any (kind, variant, blend) combo. No repo edits.
+Usage: compose.py <label> kind=<k> [variant=base] [blend=<k2>:<w>]"""
+import sys, time
+sys.path.insert(0, '/Users/THIF/repos/BatterySwapAI2026-Example')
+import os
+os.chdir('/Users/THIF/repos/BatterySwapAI2026-Example')
+import numpy as np, pandas as pd
+from batteryswap_example import models_cv as mc
+from batteryswap_example import cv
+
+label = sys.argv[1]
+kind, variant, blend = 'logbag', 'base', None
+for a in sys.argv[2:]:
+    k, v = a.split('=', 1)
+    if k == 'kind':
+        kind = v
+    elif k == 'variant':
+        variant = v
+    elif k == 'blend':
+        b, w = v.split(':')
+        blend = (b, float(w))
+
+cv.VARIANTS['vm7'] = lambda t: cv.BASE_FEATURES + ['vmin7_rank']
+mc.MODELS['aux_ho'] = lambda: mc.LogBagFeats(['hot_90', 'oob_90'])
+mc.MODELS['aux_hot'] = lambda: mc.LogBagFeats(['hot_90'])
+mc.MODELS['aux_oob'] = lambda: mc.LogBagFeats(['oob_90'])
+mc.MODELS['aux_ho30'] = lambda: mc.LogBagFeats(['hot_90', 'oob_90'],
+                                               n_estimators=30)
+mc.MODELS['aux_ho50'] = lambda: mc.LogBagFeats(['hot_90', 'oob_90'],
+                                               n_estimators=50)
+
+t0 = time.time()
+df = cv.run_bgkf(kind=kind, variant=variant, blend=blend)
+df['cand'] = label
+df.to_csv(f'/tmp/cv_bgkfcand_{label}.csv', index=False)
+base = pd.read_csv('/tmp/cv_bgkf.csv').groupby('origin')[
+    ['total_cost', 'n_swaps']].sum()
+d = df.groupby('origin')[['total_cost', 'n_swaps']].sum()
+delta = (d['total_cost'] - base['total_cost']).dropna()
+se = delta.std() / np.sqrt(len(delta))
+print(f'{label}: SCORE {d["total_cost"].mean():.1f} '
+      f'delta {delta.mean():+.1f} SE {se:.1f} '
+      f'{int((delta<0).sum())}W/{int((delta>0).sum())}L '
+      f'swaps {d["n_swaps"].mean():.1f} [{time.time()-t0:.0f}s]')

agent_reports_bgkf/artifacts/mdmodels.py

@@ -0,0 +1,132 @@
+"""md-agent candidate models (rebuilt post-outage). Registered by run.py."""
+import numpy as np
+import pandas as pd
+from sklearn.impute import SimpleImputer
+from sklearn.preprocessing import StandardScaler, RobustScaler
+from sklearn.pipeline import make_pipeline
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import BaggingClassifier, HistGradientBoostingClassifier
+
+import batteryswap_example.models_cv as mc
+
+# risk-direction of p42 in each feature (0 = unconstrained)
+MONO = {
+    'v_last': -1, 'v_drop': +1, 'slope_30': -1, 'slope_90': -1,
+    'v_min_30': -1, 'staleness': +1, 'age_days': +1, 'slope_lastk': -1,
+    'drop_recent': +1, 'below_frac': +1, 'accel': -1, 'n_30': 0,
+    'tau_projected': -1,
+    'vrel': -1, 'vmin7_rank': -1, 'r_vlast': -1, 'r_tau': -1,
+}
+
+
+class _DaysMixin:
+    def _fit_days(self, train):
+        dying = train[train['dies42'] == 1]
+        self.days = mc.DayQuantiles().fit(dying[mc.FEATURES], dying['days_to_eol'])
+
+    def _out(self, rows, p42):
+        out = self.days.predict(rows[mc.FEATURES])
+        out['p42'] = p42
+        return out
+
+
+class HGBMono(_DaysMixin):
+    """HistGradientBoosting with monotonic constraints (risk-direction by name)."""
+
+    def __init__(self, **kw):
+        self.kw = dict(max_iter=200, max_depth=3, learning_rate=0.1,
+                       min_samples_leaf=20, random_state=0)
+        self.kw.update(kw)
+
+    def fit(self, train):
+        feats = list(mc.FEATURES)
+        cst = [MONO.get(f, 0) for f in feats]
+        self.feats = feats
+        self.clf = HistGradientBoostingClassifier(monotonic_cst=cst, **self.kw)
+        self.clf.fit(train[feats], train['dies42'])
+        self._fit_days(train)
+        return self
+
+    def predict(self, rows):
+        return self._out(rows, self.clf.predict_proba(rows[self.feats])[:, 1])
+
+
+class MeanBlend(_DaysMixin):
+    """Mean of logbag p42 and a partner model's p42."""
+
+    def __init__(self, partner, w=0.5):
+        self.partner_factory = partner
+        self.w = w
+
+    def fit(self, train):
+        self.a = mc.SklearnRUL('logbag').fit(train)
+        self.b = self.partner_factory().fit(train)
+        return self
+
+    def predict(self, rows):
+        out = self.a.predict(rows)
+        out['p42'] = ((1 - self.w) * out['p42']
+                      + self.w * self.b.predict(rows)['p42'])
+        return out
+
+
+class MeanBlendCM(MeanBlend):
+    """Mean blend, count-matched: p42 rescaled so sum(p42) equals logbag's."""
+
+    def predict(self, rows):
+        pa = self.a.predict(rows)
+        pb = self.b.predict(rows)['p42']
+        blend = (1 - self.w) * pa['p42'] + self.w * pb
+        s = blend.sum()
+        if s > 0:
+            blend = (blend * (pa['p42'].sum() / s)).clip(upper=1.0)
+        out = pa
+        out['p42'] = blend
+        return out
+
+
+class OrderBlend3(_DaysMixin):
+    """Value-preserving 3-way ORDER blend: logbag p42 values kept (count
+    machinery untouched), ordering = weighted mean of pct-ranks of
+    logbag / partner2 / partner3."""
+
+    def __init__(self, p2, w2, p3=None, w3=0.0):
+        self.p2f, self.w2 = p2, w2
+        self.p3f, self.w3 = p3, w3
+
+    def fit(self, train):
+        self.a = mc.SklearnRUL('logbag').fit(train)
+        self.b = self.p2f().fit(train)
+        self.c = self.p3f().fit(train) if self.p3f is not None else None
+        return self
+
+    def predict(self, rows):
+        out = self.a.predict(rows)
+        w1 = 1.0 - self.w2 - self.w3
+        r = (w1 * out['p42'].rank(pct=True)
+             + self.w2 * self.b.predict(rows)['p42'].rank(pct=True))
+        if self.c is not None:
+            r = r + self.w3 * self.c.predict(rows)['p42'].rank(pct=True)
+        vals = np.sort(out['p42'].values)[::-1]
+        out['p42'] = pd.Series(
+            vals, index=r.sort_values(ascending=False).index).reindex(out.index)
+        return out
+
+
+def register():
+    M = mc.MODELS
+    M['md_hgb_d2'] = lambda: HGBMono(max_depth=2, l2_regularization=1.0)
+    M['md_hgb_d2l2'] = lambda: HGBMono(max_depth=2, l2_regularization=2.0)
+    M['md_hgb_d2l10'] = lambda: HGBMono(max_depth=2, l2_regularization=10.0)
+    M['md_hgb_d1'] = lambda: HGBMono(max_depth=1, l2_regularization=1.0,
+                                     learning_rate=0.05, max_iter=400)
+    M['md_hgb_d1l25'] = lambda: HGBMono(max_depth=1, l2_regularization=5.0,
+                                        learning_rate=0.05, max_iter=400)
+    M['md_bl_hgbd2'] = lambda: MeanBlend(M['md_hgb_d2'], 0.5)
+    M['md_blcm_hgbd2'] = lambda: MeanBlendCM(M['md_hgb_d2'], 0.5)
+    M['md_blcm_hgbd1'] = lambda: MeanBlendCM(M['md_hgb_d1'], 0.5)
+    # 3-way order blend on the frontier recipe: logbag .55 / hgb .25 / wiener .20
+    M['md_ord3_d2'] = lambda: OrderBlend3(M['md_hgb_d2'], 0.25, mc.WienerFHT, 0.20)
+    M['md_ord3_d1l25'] = lambda: OrderBlend3(M['md_hgb_d1l25'], 0.25,
+                                             mc.WienerFHT, 0.20)
+    M['md_ord3_d2w15'] = lambda: OrderBlend3(M['md_hgb_d2'], 0.15, mc.WienerFHT, 0.20)

agent_reports_bgkf/artifacts/rankers.py

@@ -0,0 +1,212 @@
+"""Learning-to-rank partners for the bgkf value-preserving blend API.
+
+All rankers: .fit(train_df)->self, .predict(rows)->DataFrame['p42'] where
+p42 is any monotone score (used as rank source only).
+
+Pair schemes (groups are the comparison sets deployment makes):
+  'building' : pairs within (origin_idx, building)  -- REFUTED pre-crash: worst
+  'origin'   : pairs within origin_idx (cross-building comparisons included)
+Weighting:
+  'none'     : all pairs weight 1
+  'days'     : pair weight ~ urgency of the dying device,
+               1 + (WINDOW-days_to_eol)/WINDOW  (sooner death = costlier miss)
+"""
+import numpy as np
+import pandas as pd
+from pathlib import Path
+from sklearn.impute import SimpleImputer
+from sklearn.preprocessing import StandardScaler
+from sklearn.linear_model import LogisticRegression
+
+DATASET = Path('/Users/THIF/repos/BatterySwapAI2026-Example/dataset')
+WINDOW = 42.0
+
+F13 = ['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']
+FV = F13 + ['vrel', 'vmin7_rank']
+
+_DEV_B = None
+def dev_building():
+    global _DEV_B
+    if _DEV_B is None:
+        _DEV_B = (pd.read_csv(DATASET / 'train' / 'devices.csv')
+                  .drop_duplicates('device_id')
+                  .set_index('device_id')['building_id'])
+    return _DEV_B
+
+
+def add_group_ranks(df, feats, group):
+    out = df.copy()
+    out['g_rvlast'] = df.groupby(group)['v_last'].rank(pct=True)
+    out['g_rtau'] = df.groupby(group)['tau_projected'].rank(pct=True)
+    return out, feats + ['g_rvlast', 'g_rtau']
+
+
+def build_pairs(df, mode, rng, max_neg_per_pos=50):
+    """Return (i_idx, j_idx, days_i) positional indices into df where i is the
+    dying device, j the surviving one, within the comparison group."""
+    b = df['device_id'].map(dev_building())
+    if mode == 'building':
+        keys = list(zip(df['origin_idx'].values, b.values))
+    else:
+        keys = list(df['origin_idx'].values)
+    gmap = {}
+    for p, k in enumerate(keys):
+        gmap.setdefault(k, []).append(p)
+    y = df['dies42'].values
+    days = df['days_to_eol'].values
+    ii, jj, dd = [], [], []
+    for k, idxs in gmap.items():
+        idxs = np.asarray(idxs)
+        p_ = idxs[y[idxs] == 1]
+        n_ = idxs[y[idxs] == 0]
+        if len(p_) == 0 or len(n_) == 0:
+            continue
+        for i in p_:
+            n_sel = n_
+            if len(n_) > max_neg_per_pos:
+                n_sel = rng.choice(n_, size=max_neg_per_pos, replace=False)
+            ii.extend([i] * len(n_sel))
+            jj.extend(n_sel)
+            dd.extend([days[i]] * len(n_sel))
+    return np.asarray(ii), np.asarray(jj), np.asarray(dd)
+
+
+def pair_weights(dd, weighting):
+    if weighting == 'days':
+        w = 1.0 + np.clip((WINDOW - dd) / WINDOW, 0, 1)
+        return w / w.mean()
+    return np.ones(len(dd))
+
+
+class _Prep:
+    def fit(self, X):
+        self.imp = SimpleImputer(strategy='median').fit(X)
+        self.sc = StandardScaler().fit(self.imp.transform(X))
+        return self
+    def transform(self, X):
+        return self.sc.transform(self.imp.transform(X))
+
+
+class PairwiseLogistic:
+    """Linear scorer fit by logistic regression on standardized pair
+    differences (symmetric +/- augmentation, no intercept)."""
+
+    def __init__(self, feats=F13, mode='building', weighting='none',
+                 use_group_ranks=False, C=1.0, seed=0, max_neg_per_pos=50):
+        self.feats0 = list(feats)
+        self.mode, self.weighting = mode, weighting
+        self.ugr = use_group_ranks
+        self.C, self.seed, self.mnp = C, seed, max_neg_per_pos
+
+    def _table(self, df, group):
+        feats = list(self.feats0)
+        if self.ugr:
+            df, feats = add_group_ranks(df, feats, group)
+        return df, feats
+
+    def fit(self, train):
+        rng = np.random.default_rng(self.seed)
+        b = train['device_id'].map(dev_building())
+        grp = ([train['origin_idx'], b] if self.mode == 'building'
+               else train['origin_idx'])
+        df, feats = self._table(train, grp)
+        self.feats = feats
+        self.prep = _Prep().fit(df[feats])
+        X = self.prep.transform(df[feats])
+        ii, jj, dd = build_pairs(df, self.mode, rng, self.mnp)
+        D = X[ii] - X[jj]
+        w = pair_weights(dd, self.weighting)
+        Xp = np.vstack([D, -D])
+        yp = np.r_[np.ones(len(D)), np.zeros(len(D))]
+        wp = np.r_[w, w]
+        self.clf = LogisticRegression(fit_intercept=False, C=self.C,
+                                      max_iter=2000)
+        self.clf.fit(Xp, yp, sample_weight=wp)
+        return self
+
+    def predict(self, rows):
+        df = rows.copy()
+        feats = list(self.feats0)
+        if self.ugr:
+            df['g_rvlast'] = df['v_last'].rank(pct=True)
+            df['g_rtau'] = df['tau_projected'].rank(pct=True)
+            feats = feats + ['g_rvlast', 'g_rtau']
+        X = self.prep.transform(df[feats])
+        s = X @ self.clf.coef_.ravel()
+        return pd.DataFrame({'p42': s}, index=rows.index)
+
+
+class RankNet:
+    """Small MLP RankNet, N-seed bag, pairwise logistic loss on within-group
+    pairs. Deterministic per seed; torch threads pinned to 2."""
+
+    def __init__(self, feats=F13, mode='building', weighting='none',
+                 use_group_ranks=False, seeds=(0, 1, 2), hidden=(32, 16),
+                 epochs=300, lr=3e-3, wd=1e-3, max_neg_per_pos=50):
+        self.feats0 = list(feats)
+        self.mode, self.weighting = mode, weighting
+        self.ugr = use_group_ranks
+        self.seeds, self.hidden = seeds, hidden
+        self.epochs, self.lr, self.wd = epochs, lr, wd
+        self.mnp = max_neg_per_pos
+
+    def fit(self, train):
+        import torch
+        torch.set_num_threads(2)
+        b = train['device_id'].map(dev_building())
+        grp = ([train['origin_idx'], b] if self.mode == 'building'
+               else train['origin_idx'])
+        df = train
+        feats = list(self.feats0)
+        if self.ugr:
+            df, feats = add_group_ranks(df, feats, grp)
+        self.feats = feats
+        self.prep = _Prep().fit(df[feats])
+        X = self.prep.transform(df[feats]).astype(np.float32)
+        rng = np.random.default_rng(0)
+        ii, jj, dd = build_pairs(df, self.mode, rng, self.mnp)
+        w = pair_weights(dd, self.weighting).astype(np.float32)
+        Xi = torch.tensor(X[ii]); Xj = torch.tensor(X[jj])
+        wt = torch.tensor(w)
+        self.nets = []
+        d_in = X.shape[1]
+        for seed in self.seeds:
+            torch.manual_seed(seed)
+            layers, prev = [], d_in
+            for h in self.hidden:
+                layers += [torch.nn.Linear(prev, h), torch.nn.ReLU()]
+                prev = h
+            layers += [torch.nn.Linear(prev, 1)]
+            net = torch.nn.Sequential(*layers)
+            opt = torch.optim.Adam(net.parameters(), lr=self.lr,
+                                   weight_decay=self.wd)
+            lossf = torch.nn.BCEWithLogitsLoss(weight=wt)
+            target = torch.ones(len(ii))
+            for _ in range(self.epochs):
+                opt.zero_grad()
+                diff = (net(Xi) - net(Xj)).squeeze(-1)
+                loss = lossf(diff, target)
+                loss.backward()
+                opt.step()
+            net.eval()
+            self.nets.append(net)
+        return self
+
+    def predict(self, rows):
+        import torch
+        torch.set_num_threads(2)
+        df = rows.copy()
+        feats = list(self.feats0)
+        if self.ugr:
+            df['g_rvlast'] = df['v_last'].rank(pct=True)
+            df['g_rtau'] = df['tau_projected'].rank(pct=True)
+            feats = feats + ['g_rvlast', 'g_rtau']
+        X = self.prep.transform(df[feats]).astype(np.float32)
+        with torch.no_grad():
+            ss = [net(torch.tensor(X)).squeeze(-1).numpy()
+                  for net in self.nets]
+        s = np.mean([pd.Series(s_).rank(pct=True).values for s_ in ss], axis=0)
+        return pd.DataFrame({'p42': s}, index=rows.index)

agent_reports_bgkf/artifacts/run3w.py

@@ -0,0 +1,72 @@
+"""3-way value-preserving order injection on the vm7+wiener frontier base.
+Usage: run3w.py LABEL A B C [NSEEDS SEED0 FEATS]
+  final order = A*logbag(vm7)_rank + B*wiener_rank + C*ranknet_rank,
+  injected at harness weight 1.0 so values (and counts) stay the primary
+  logbag(vm7)'s. (A,B,C)=(0.8,0.2,0) reproduces ft_vmin7r_wnr20 exactly.
+  RankNet: within-origin pairs, days weighting (the champion-base survivor),
+  FEATS f13|fvm7 (fvm7 = F13 + vmin7_rank, per coordinator).
+"""
+import sys, time, os
+sys.path.insert(0, '/tmp/rk2')
+sys.path.insert(0, '/Users/THIF/repos/BatterySwapAI2026-Example')
+import numpy as np
+import pandas as pd
+import rankers as rk
+import batteryswap_example.cv as cv
+import batteryswap_example.models_cv as mc
+
+label = sys.argv[1]
+A, B, C = (float(x) for x in sys.argv[2:5])
+nseeds = int(sys.argv[5]) if len(sys.argv) > 5 else 7
+seed0 = int(sys.argv[6]) if len(sys.argv) > 6 else 0
+feats_name = sys.argv[7] if len(sys.argv) > 7 else 'fvm7'
+D = float(sys.argv[8]) if len(sys.argv) > 8 else 0.0
+feats = {'f13': rk.F13,
+         'fvm7': rk.F13 + ['vmin7_rank'],
+         'fvm7h': rk.F13 + ['vmin7_rank', 'hot_90', 'oob_90']}[feats_name]
+
+cv.VARIANTS['vm7'] = lambda t: cv.BASE_FEATURES + ['vmin7_rank']
+
+
+class ThreeWay:
+    def fit(self, train):
+        self.lb = mc.SklearnRUL('logbag').fit(train)
+        self.wn = mc.MODELS['wiener']().fit(train) if B > 0 else None
+        self.rk = (rk.RankNet(feats=feats, mode='origin', weighting='days',
+                              seeds=tuple(range(seed0, seed0 + nseeds)))
+                   .fit(train) if C > 0 else None)
+        self.ho = (mc.LogBagFeats(['hot_90', 'oob_90']).fit(train)
+                   if D > 0 else None)
+        return self
+
+    def predict(self, rows):
+        s = A * self.lb.predict(rows)['p42'].rank(pct=True)
+        if self.wn is not None:
+            s = s + B * self.wn.predict(rows)['p42'].rank(pct=True)
+        if self.rk is not None:
+            s = s + C * self.rk.predict(rows)['p42'].rank(pct=True)
+        if self.ho is not None:
+            s = s + D * self.ho.predict(rows)['p42'].rank(pct=True)
+        return pd.DataFrame({'p42': s.values}, index=rows.index)
+
+
+mc.MODELS[label] = ThreeWay
+t0 = time.time()
+df = cv.run_bgkf(kind='logbag', variant='vm7', blend=(label, 1.0))
+df['cand'] = label
+out = f'/tmp/cv_bgkfcand_{label}.csv'
+df.to_csv(out, index=False)
+
+d = df.groupby('origin')[['total_cost', 'n_swaps']].sum()
+line = (f"{label} (A={A} B={B} C={C} D={D} s{nseeds}+{seed0} {feats_name}): "
+        f"SCORE {d['total_cost'].mean():.2f} swaps {d['n_swaps'].mean():.2f}")
+if os.path.exists('/tmp/cv_bgkf.csv'):
+    base = pd.read_csv('/tmp/cv_bgkf.csv').groupby('origin')[
+        ['total_cost', 'n_swaps']].sum()
+    delta = (d['total_cost'] - base['total_cost']).dropna()
+    se = delta.std() / np.sqrt(len(delta))
+    line += (f" delta {delta.mean():+.2f} SE {se:.2f} "
+             f"W/L {int((delta<0).sum())}W/{int((delta>0).sum())}L")
+else:
+    line += "  [baseline missing - pair later]"
+print(f"\n{line}  [{time.time()-t0:.0f}s] -> {out}")

batteryswap_example/data/train_features.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4d7e31ddec4d82eec9e062848ed0c019811068947a3bd6ccf7e42d6f7d8e7376
-size 6159081
+oid sha256:a5be48b744effea696e1443bff9b00b0ebab496920e83a3b823737e67563a16f
+size 7434713

batteryswap_example/submit.py

@@ -194,7 +194,82 @@ class FrontierRUL:
         return out
 
 
+# CAMPAIGN-2 FRONTIER (2026-08-23, building-GroupKFold v5 instrument):
+# ft_vmin7r_wnr20 = logbag on FEATURES + vmin7_rank (fleet pct-rank of the
+# 7d-min voltage, computed by features_at_origin over whatever fleet it
+# ranks - own-fleet semantics in deployment) with a 0.20 value-preserving
+# WienerFHT order blend. THE SCORE 1688.4 vs champion 1760.2 (-71.8 +/-
+# 23.5, 3.05 sigma, Wilcoxon p=.037, swaps 9.58 flat, count-clean by every
+# control; components additive: wiener -50.3, vmin7_rank -23.2; reproduced
+# independently by three lanes). Worst-case reference-shift bound: with
+# vmin7_rank recomputed WITHIN each ~5-building test fleet the stack still
+# reads -60.8 +/- 26.3 (2.31 sigma); the scored fleets are full ~922-device
+# populations, much closer to the shared-reference case. Value-preserving
+# means the blended rank ORDER is mapped back onto the primary's own sorted
+# p42 values: count/pricing/timing machinery see the primary's exact p42
+# distribution (the phase-56/58 shipping bar). Both components degrade
+# softly: missing wnr_* columns drop the wiener source (pure vm7 logbag),
+# any fit error falls back to the legacy champion via _fit_model.
+FT2 = os.environ.get('BATTERYSWAP_FT2', '1') != '0'
+FT2_W = float(os.environ.get('BATTERYSWAP_FT2_W', '0.20'))
+
+
+class Ft2RUL:
+    """Faithful deployment of cv.run_bgkf(kind='logbag', variant='vm7',
+    blend=('wiener', 0.20)): primary = SklearnRUL('logbag') fit with
+    FEATURES + vmin7_rank (the CV sets mc.FEATURES globally; here the swap
+    is scoped to this class's fits and predicts), partner = WienerFHT
+    (fit under the same feature list, exactly as the CV's global swap did),
+    blended rank order mapped onto the primary's own sorted p42 values,
+    timing columns staying with their device."""
+
+    def _swap(self):
+        class _S:
+            def __enter__(s):
+                s.old = models_cv.FEATURES
+                if 'vmin7_rank' not in models_cv.FEATURES:
+                    models_cv.FEATURES = models_cv.FEATURES + ['vmin7_rank']
+                return s
+            def __exit__(s, *a):
+                models_cv.FEATURES = s.old
+        return _S()
+
+    def fit(self, train):
+        with self._swap():
+            self.primary = SklearnRUL(MODEL_KIND).fit(train)
+            self.wiener = (models_cv.WienerFHT().fit(train)
+                           if FT2_W > 0 and 'wnr_n' in train.columns else None)
+        return self
+
+    def predict(self, rows):
+        if 'vmin7_rank' not in rows.columns:
+            rows = rows.copy()
+            rows['vmin7_rank'] = (rows['v_min_7'].rank(pct=True)
+                                  if 'v_min_7' in rows.columns else np.nan)
+        with self._swap():
+            pred = self.primary.predict(rows)
+            rk = pred['p42'].rank(pct=True)
+            if self.wiener is not None and 'wnr_n' in rows.columns:
+                # inside the swap: the wiener's DayQuantiles was fit under
+                # the same swapped feature list (exactly the CV's global set)
+                p2 = self.wiener.predict(rows)
+                rk = (1 - FT2_W) * rk + FT2_W * p2['p42'].rank(pct=True)
+        vals = np.sort(pred['p42'].values)[::-1]
+        out = pred.copy()
+        out['p42'] = pd.Series(
+            vals, index=rk.sort_values(ascending=False).index
+        ).reindex(out.index)
+        return out
+
+
 def _fit_model(train):
+    if FT2:
+        try:
+            return Ft2RUL().fit(train)
+        except Exception:
+            # deadline-day discipline: a broken frontier fit degrades to the
+            # measured champion, never to a crash
+            traceback.print_exc()
     return (FrontierRUL() if FRONTIER else SklearnRUL(MODEL_KIND)).fit(train)
 # Inclusion appetite, tuned by local CV: alpha sweep 0.7-1.3 on dev has a clear
 # minimum at 0.8 (beats every alternative on 11-12 of 16 origins), confirmed on
@@ -387,6 +462,18 @@ def adaptive_split_plans(split, split_path, log=print, deadline=None):
     locations, timeseries, eol_times, scenarios = load_best_effort(split_path, log)
     scen_starts = [pd.Timestamp(s['start_time']) for s in scenarios]
     daily = daily_voltage(timeseries)
+    ft2_daily = None
+    if FT2:
+        # per-scenario Wiener (drift, variance) for the ft2 order blend -
+        # computed from THIS split's own past-only telemetry, same estimator
+        # the training cache used. Any failure just drops the wiener source.
+        try:
+            from batteryswap_example.fht_features import (
+                daily_corrected, wiener_at_origin)
+            ft2_daily = daily_corrected(timeseries)
+        except Exception as e:
+            log(f'  WARNING ft2 wiener daily build failed ({e}); '
+                f'order blend drops the wiener source')
     cert_days = cert_confirm_days(daily) if CERT_FIRST else pd.Series(dtype='datetime64[ns]')
     dall = daily_all(timeseries)
     betas = weekly_betas(dall)
@@ -529,6 +616,12 @@ def adaptive_split_plans(split, split_path, log=print, deadline=None):
         dead = eol_times[eol_times.notna() & (eol_times <= T)]
         curve = master_curve(dall[dall['day'] <= T], dead, beta)
         feats = feats.join(physics_features(dall, T, beta, curve, match=False))
+        if ft2_daily is not None:
+            try:
+                feats = feats.join(wiener_at_origin(ft2_daily, T))
+            except Exception as e:
+                log(f'  WARNING {scenario["name"]}: ft2 wiener params failed '
+                    f'({e}); wiener source dropped this scenario')
         feats = feats.reindex(locs['battery'])
 
         pred = model.predict(feats)