Upload folder using huggingface_hub

app.py

@@ -157,6 +157,21 @@ def load_health():
         lines = [f"### 🩺 Agent health — {icon.get(r.get('overall'), '⚪')} {r.get('overall')} <sub>(checked {r.get('date')})</sub>"]
         for c in r.get("checks", []):
             lines.append(f"- {icon.get(c['status'], '⚪')} **{c['name']}** — {c['detail']}")
+        try:
+            rr = json.load(open(hf_hub_download("s-ttp/marketfm-panel", "recalibration_report.json", repo_type="dataset",
+                                                token=tok, force_download=True)))
+            tr = rr.get("tracking", {})
+            inc = rr.get("incumbent", {})
+            flag = "🔁" if rr.get("changed") else ("🟡" if rr.get("triggered") else "🟢")
+            lines.append(f"- {flag} **Autonomous recalibration agent** (weekly) — 8-wk gap vs SPY "
+                         f"{tr.get('gap_8w_pp', '—')}pp ({tr.get('pctile_8w', '—')}th pctile of backtest) · "
+                         f"implementation drift {tr.get('impl_drift_pp', '—')}pp · {rr.get('decision', '')[:160]}")
+            lines.append(f"<sub>Live strategy config v{inc.get('version', '?')}: signal {inc.get('signal')} · regime "
+                         f"{inc.get('regime')} · defense {inc.get('defense')} · cadence {inc.get('cadence_weeks')}w. "
+                         f"Recalibration only adopts a variant that beats the incumbent on a full 20-year walk-forward, "
+                         f"net of cost, across folds — never a re-fit to recent weeks; max one change per 90 days.</sub>")
+        except Exception:
+            pass
         lines.append("<sub>Deterministic daily checks: live tracking gap located in the 20-year backtest distribution, "
                      "risk guardrails, and pipeline freshness. Flags only — the supervisor never trades.</sub>")
         return "\n".join(lines)
@@ -174,6 +189,11 @@ def load_rebalance():
         if not log:
             return ""
         e = log[-1]
+        if e.get("type") == "recalibration":
+            head = f"### 🔁 Strategy recalibrated — {e.get('date','')}\n{e.get('summary','')}\n\n"
+            if e.get("narration"):
+                return head + f"> 💬 *{e['narration']}*\n\n<sub>— {e.get('narrated_by','MarketGuruLLM')}</sub>"
+            return head
         mode = "🟢 OFFENSE" if e.get("mode") == "OFFENSE" else "🛡️ DEFENSE"
         head = (f"### 🗓️ Latest rebalance — {e.get('date','')} · {mode}\n"
                 f"{e.get('buys',0)} buys · {e.get('sells',0)} sells · {e.get('turnover_pct',0)}% turnover · "
@@ -231,7 +251,8 @@ with gr.Blocks(title="DeepQuant — live paper monitor", theme=gr.themes.Soft())
         "**Under the hood:**\n"
         "- 🧠 **[MarketFM](https://huggingface.co/spaces/s-ttp/marketfm-ranker)** — a survivorship-free quant model — ranks the universe and sets the target portfolio\n"
         "- 💬 **[MarketGuruLLM](https://huggingface.co/s-ttp/qwen25-14b-fin-lora)** — a fine-tuned analyst LLM — reasons over and narrates every rebalance\n"
-        "- ⚡ **Alpaca API** — the brokerage rails the **quant execution engine** drives to place orders and stream live fills, positions and P&L\n\n"
+        "- ⚡ **Alpaca API** — the brokerage rails the **quant execution engine** drives to place orders and stream live fills, positions and P&L\n"
+        "- 🔁 **Autonomous recalibration** — tracks live vs backtest over rolling 8-week windows; on statistically unusual deviation it re-runs the full walk-forward due diligence and adopts a better-validated variant on its own\n\n"
         "**The strategy:** large-cap **momentum + quality** while the trend is up; when it turns down it de-risks into a "
         "blend of **stocks + bonds + gold** (60 / 20 / 20). Backtested 2002–2026: **~14% / yr vs the S&P 500's ~11%**, "
         "higher Sharpe, smaller drawdown.\n"

rebalance_engine.py

@@ -42,24 +42,51 @@ def cap_weights(w, mw=MAX_W):
     return w
 
 
-def detect_regime():
+DEFAULT_CFG = {"signal": ["n_mom_12_1", "n_roe"], "regime": "cross10/40",
+               "defense": "mom60_agg20_gld20", "cadence_weeks": 1, "version": 1}
+
+
+def load_config(token):
+    """Live strategy config written by the autonomous recalibration agent (falls back to the incumbent)."""
     try:
-        u = f"https://www.alphavantage.co/query?function=TIME_SERIES_WEEKLY_ADJUSTED&symbol=SPY&apikey={AV}"
-        ts = json.load(urllib.request.urlopen(u, timeout=25, context=_CTX))["Weekly Adjusted Time Series"]
-        s = pd.Series({k: float(v["5. adjusted close"]) for k, v in ts.items()}).sort_index()
-        sma10, sma40 = s.rolling(10).mean().iloc[-1], s.rolling(40).mean().iloc[-1]
-        return {"offense": bool(sma10 >= sma40), "sma10": float(sma10), "sma40": float(sma40), "spy": float(s.iloc[-1])}
+        c = json.load(open(hf_hub_download(PANEL_REPO, "strategy_config.json", repo_type="dataset", token=token, force_download=True)))
+        return {**DEFAULT_CFG, **{k: c[k] for k in DEFAULT_CFG if k in c}}
+    except Exception:
+        return dict(DEFAULT_CFG)
+
+
+def _spy_series():
+    u = f"https://www.alphavantage.co/query?function=TIME_SERIES_WEEKLY_ADJUSTED&symbol=SPY&apikey={AV}"
+    ts = json.load(urllib.request.urlopen(u, timeout=25, context=_CTX))["Weekly Adjusted Time Series"]
+    return pd.Series({k: float(v["5. adjusted close"]) for k, v in ts.items()}).sort_index()
+
+
+def detect_regime(rule="cross10/40"):
+    try:
+        s = _spy_series()
+        p = float(s.iloc[-1]); s10 = float(s.rolling(10).mean().iloc[-1]); s20 = float(s.rolling(20).mean().iloc[-1])
+        s40 = float(s.rolling(40).mean().iloc[-1]); p_prev = float(s.iloc[-2]); s40_prev = float(s.rolling(40).mean().iloc[-2])
+        if rule == "single40":
+            off = p >= s40
+        elif rule == "dual20/40":
+            off = True if (p >= s20 and p >= s40) else (False if (p < s20 and p < s40) else (s10 >= s40))
+        elif rule == "hyst5":
+            off = True if p > 1.05 * s40 else (False if p < 0.95 * s40 else (s10 >= s40))
+        elif rule == "confirm2":
+            cur, prev = p >= s40, p_prev >= s40_prev
+            off = cur if cur == prev else (s10 >= s40)
+        else:                                   # cross10/40 (incumbent)
+            off = s10 >= s40
+        return {"offense": bool(off), "rule": rule, "sma10": s10, "sma40": s40, "spy": p}
     except Exception as e:
-        return {"offense": True, "sma10": None, "sma40": None, "spy": None,
+        return {"offense": True, "rule": rule, "sma10": None, "sma40": None, "spy": None,
                 "warn": f"SPY fetch failed ({type(e).__name__}); defaulting to OFFENSE"}
 
 
-def equity_sleeve(token):
-    p = hf_hub_download(PANEL_REPO, "marketfm_snapshot.parquet", repo_type="dataset", token=token)
-    df = pd.read_parquet(p)
+def _rank_sleeve(df, cols, sign=1):
     df = df[df["marketcap"].notna() & (df["marketcap"] > 0)].copy()
     df = df.sort_values("marketcap", ascending=False).head(SEG_K)
-    df["score"] = df["n_mom_12_1"].fillna(0) + df["n_roe"].fillna(0)
+    df["score"] = sum(sign * df[c].fillna(0) for c in cols)
     df = df.sort_values("score", ascending=False)
     picked, sec = [], {}
     for _, r in df.iterrows():
@@ -75,18 +102,37 @@ def equity_sleeve(token):
             for r, wi in zip(picked, w)]
 
 
+def equity_sleeve(token, cols=None):
+    cols = cols or DEFAULT_CFG["signal"]
+    p = hf_hub_download(PANEL_REPO, "marketfm_snapshot.parquet", repo_type="dataset", token=token)
+    return _rank_sleeve(pd.read_parquet(p), cols)
+
+
 def get_target(token):
-    reg = detect_regime()
-    sleeve = equity_sleeve(token)
+    cfg = load_config(token)
+    reg = detect_regime(cfg["regime"])
+    snap = pd.read_parquet(hf_hub_download(PANEL_REPO, "marketfm_snapshot.parquet", repo_type="dataset", token=token))
+    sleeve = _rank_sleeve(snap, cfg["signal"])
     if reg["offense"]:
         rows = [dict(x) for x in sleeve]
     else:
-        rows = [dict(x, weight=DEF_EQ * x["weight"]) for x in sleeve]
-        for sym, (nm, sct) in ETF.items():
-            rows.append({"ticker": sym, "name": nm, "sector": sct,
-                         "weight": DEF_AGG if sym == "AGG" else DEF_GLD})
+        d = cfg["defense"]
+        if d == "agg50_gld50":
+            rows = []
+            eq_frac, agg_w, gld_w = 0.0, 0.5, 0.5
+        elif d == "lowvol":
+            rows = _rank_sleeve(snap, ["n_vol_13w"], sign=-1)
+            eq_frac, agg_w, gld_w = 1.0, 0.0, 0.0
+        elif d == "mom40_agg30_gld30":
+            rows = [dict(x, weight=0.4 * x["weight"]) for x in sleeve]; eq_frac, agg_w, gld_w = 0.4, 0.3, 0.3
+        else:                                       # mom60_agg20_gld20 (incumbent)
+            rows = [dict(x, weight=DEF_EQ * x["weight"]) for x in sleeve]; eq_frac, agg_w, gld_w = DEF_EQ, DEF_AGG, DEF_GLD
+        for sym, wv in [("AGG", agg_w), ("GLD", gld_w)]:
+            if wv > 0:
+                nm, sct = ETF[sym]
+                rows.append({"ticker": sym, "name": nm, "sector": sct, "weight": wv})
     weights = {r["ticker"]: r["weight"] for r in rows}
-    return {"regime": reg, "weights": weights, "rows": rows}
+    return {"regime": reg, "weights": weights, "rows": rows, "config": cfg}
 
 
 def compute_orders(weights, positions, equity, band_pct=0.005, invest_frac=0.995, force_sells=False):