Upload folder using huggingface_hub

README.md

@@ -7,23 +7,22 @@ sdk: gradio
 sdk_version: 5.50.0
 app_file: app.py
 pinned: false
-short_description: Autonomous agentic fund - built to beat the S&P 500
+short_description: The AI-managed fund - researched, run and governed by AI
 ---
 
 # DeepQuant
 
-A **fully autonomous fund** running end-to-end on an Alpaca **paper** account — no human in the loop. Under the hood, a hybrid architecture: a deterministic quant engine
-executes a 20-year-validated, regime-aware multi-asset strategy, while an **agentic AI layer** supervises it,
-narrates it, and — within strict evidence gates — recalibrates it.
+**The AI-managed fund** — its strategy was *discovered by AI research agents* through 150+ walk-forward-validated
+strategy configurations over 21 years of survivorship-free data, and it is *run and governed by AI* end-to-end on a
+live Alpaca **paper** account with no human in the loop.
 
-**Division of labour, by design:**
-- **Deterministic:** stock ranking (MarketFM, ~11,800-name survivorship-free universe), order execution over the
-  Alpaca API, risk rails (long-only, 10% cap, no leverage), daily statistical health checks vs the strategy's own
-  backtest distribution.
-- **Agentic (Claude Opus 5):** a weekly role-separated crew — Analyst → adversarial Critic → PM — that assesses
-  the evidence and decides to hold, adopt a better-validated strategy variant, or pause trading; every action is
-  re-checked by a code validator (full walk-forward acceptance criteria, 90-day rate limit, hard rails).
-- **MarketGuruLLM** (fine-tuned Qwen2.5-14B) narrates every rebalance and decision in plain English.
+- **The secret recipe:** ~60 U.S. large caps selected monthly by a proprietary AI-researched quality signal, plus a
+  crisis-only defense (40% into bonds + gold, only in confirmed severe bears). The exact signal is undisclosed;
+  every trade and result is published live.
+- **AI governance:** a weekly AI investment committee (Analyst → adversarial Critic → PM on Claude Opus 5) reviews
+  the fund against its own 20-year envelope; changes require walk-forward proof via a code validator. Failure → HOLD.
+- **Deterministic where it must be:** execution, risk rails (long-only, 10% cap, no leverage), reconciliation.
+- **MarketGuruLLM** narrates every move in plain English; daily AI self-diagnosis is published openly.
 
-The page is **read-only**: live positions, the fund vs the S&P 500 since inception, agent health, the latest decision
-with its reasoning, and a dry-run rebalance preview. Backtested results, paper trading — not investment advice.
+Strategy v2, live since September 2026 (v1's full record is archived). Simulated research results, paper trading —
+not investment advice.

app.py

@@ -137,6 +137,12 @@ def refresh():
             "Weight": f"{mv / eq * 100:.1f}%" if eq else "—",
             "Unrealized P&L": f'${float(p["unrealized_pl"]):,.2f} ({float(p["unrealized_plpc"]) * 100:+.1f}%)',
         })
+    rows.sort(key=lambda r: -float(str(r["Mkt value"]).replace("$", "").replace(",", "")))
+    hidden = max(0, len(rows) - 10)
+    rows = rows[:10]
+    if hidden:
+        rows.append({"Symbol": f"… +{hidden} more", "Qty": "", "Avg entry": "", "Last": "",
+                     "Mkt value": "undisclosed", "Weight": "", "Unrealized P&L": ""})
     df = pd.DataFrame(rows) if rows else pd.DataFrame([{"Symbol": "— no open positions —"}])
     curve, cnote = build_curve()
     stamp = f"_Last updated {now} · auto-refreshes every 30 min_"
@@ -205,14 +211,16 @@ def load_governance():
            .replace("impl_alert", "implementation-drift alert").replace("SPY/MTUM", "the S&P 500 and the momentum factor"))
     if len(why) > 420:
         why = why[:420].rsplit(" ", 1)[0] + "…"
-    CONMAP = {"abs10_sec5": "10% cap · ≤5/sector", "rel12b2_sec5": "index-aware caps (≤12%, index wt +2%) · ≤5/sector",
-              "abs10_sec6": "10% cap · ≤6/sector"}
-    sig = " + ".join(SIGMAP.get(x, x) for x in (inc.get("signal") or []))
+    CONMAP = {"n60_nocap": "~60 AI-selected large caps · 10% position cap", "n50_nocap": "~50 AI-selected large caps · 10% cap",
+              "n75_nocap": "~75 AI-selected large caps · 10% cap", "abs10_sec5": "10% cap · ≤5/sector"}
+    REGMAP = {"gate20": "crisis-only severity gate (trend break + deep-drawdown confirmation)",
+              "gate15": "severity gate (15%)", "cross10/40": "10/40-week trend crossover"}
+    sig = "proprietary AI-researched quality signal (undisclosed)"
     return (f"### 🤝 Strategy governance — the crew's latest decision\n"
             f"**{act.strip()}** — {why}\n"
             f"- **Tracking:** 8-week gap vs S&P {tr.get('gap_8w_pp', '—')}pp — the {tr.get('pctile_8w', '—')}th percentile "
             f"of the strategy's 20-year history · implementation drift {tr.get('impl_drift_pp', '—')}pp vs its own simulation\n"
-            f"- **Live strategy (v{inc.get('version', '?')}):** {sig} selection · {inc.get('regime', '?')} trend rule · "
+            f"- **Live strategy (v{inc.get('version', '?')}):** {sig} · {REGMAP.get(inc.get('regime'), inc.get('regime'))} · "
             f"defense = {DEFMAP.get(inc.get('defense'), inc.get('defense'))} · {CONMAP.get(inc.get('construction'), '10% cap · ≤5/sector')} · rebalanced every {inc.get('cadence_weeks', 1)} week(s)\n"
             f"- **Change policy:** decided weekly by an agentic crew — Analyst → adversarial Critic → PM (Claude Opus 5) — "
             f"gated by a code validator. A variant is adopted only if it beats the incumbent on the full 20-year "
@@ -263,7 +271,7 @@ def rebalance_preview():
     reg = tgt["regime"]
     mode = "🟢 OFFENSE" if reg["offense"] else "🛡️ DEFENSE"
     sma = (f"SPY 10-wk {reg['sma10']:,.0f} vs 40-wk {reg['sma40']:,.0f}" if reg.get("sma10") else reg.get("warn", ""))
-    mix = "50 stocks · 100% equity" if reg["offense"] else "60% stocks + 20% AGG + 20% GLD"
+    mix = "~60 AI-selected stocks · 100% equity" if reg["offense"] else "60% stocks + 20% AGG + 20% GLD (crisis defense)"
     nb = sum(1 for o in orders if o["side"] == "BUY")
     ns = sum(1 for o in orders if o["side"] == "SELL")
     traded = sum(abs(o["delta"]) for o in orders)
@@ -273,43 +281,50 @@ def rebalance_preview():
     banner = (f"## {mode}\n**Regime:** {sma}  ·  equity **${eq:,.0f}**  ·  target: {mix}\n\n{summ}\n\n"
               f"<sub>Preview only — **no orders are placed**. This is exactly what the agent would submit at the next "
               f"Monday-after-open rebalance (notional market orders, sells before buys).</sub>")
-    tdf = pd.DataFrame([{"Ticker": r["ticker"], "Sector": r["sector"], "Target %": f'{r["weight"] * 100:.1f}%',
-                         "Target $": f'${r["weight"] * eq:,.0f}'} for r in tgt["rows"]])
+    import collections as _c
+    secagg = _c.defaultdict(float)
+    for r in tgt["rows"]: secagg[r["sector"]] += r["weight"]
+    tdf = pd.DataFrame([{"Sector": k, "Target %": f"{v*100:.1f}%", "Names": sum(1 for r in tgt["rows"] if r["sector"] == k)}
+                        for k, v in sorted(secagg.items(), key=lambda x: -x[1])])
     if orders:
-        odf = pd.DataFrame([{"Symbol": o["symbol"], "Side": ("🔻 SELL" if o["side"] == "SELL" else "🟢 BUY"),
-                             "Trade $": f'${abs(o["delta"]):,.0f}', "Now": f'{o["cur_w"] * 100:.1f}%',
-                             "→ Target": f'{o["tgt_w"] * 100:.1f}%'} for o in orders])
+        buys = sum(o["delta"] for o in orders if o["side"] == "BUY")
+        sells = sum(-o["delta"] for o in orders if o["side"] == "SELL")
+        odf = pd.DataFrame([{"Side": "🟢 BUY", "Orders": sum(1 for o in orders if o["side"] == "BUY"), "Total": f"${buys:,.0f}"},
+                            {"Side": "🔻 SELL", "Orders": sum(1 for o in orders if o["side"] == "SELL"), "Total": f"${sells:,.0f}"}])
     else:
-        odf = pd.DataFrame([{"Symbol": "— already at target —"}])
+        odf = pd.DataFrame([{"Side": "— already at target —", "Orders": 0, "Total": "$0"}])
     return banner, tdf, odf
 
 
 with gr.Blocks(title="DeepQuant — live paper monitor", theme=gr.themes.Soft()) as demo:
     gr.Markdown(
         "# 🤖 DeepQuant\n"
-        "### A fully autonomous, agentic fund — built to beat the S&P 500 across market cycles\n"
-        "DeepQuant runs a 20-year-validated, regime-aware multi-asset strategy **end-to-end on a live paper account** — "
-        "it selects, executes, monitors, explains, recalibrates and even pauses itself, **with no human in the loop**. Under the hood it is a **hybrid "
-        "of deterministic and agentic AI frameworks**, with every responsibility assigned by one principle: **deterministic code wherever correctness must be provable, "
-        "agentic AI wherever judgment adds value** — never the other way around.\n\n"
-        "**The stack:**\n"
-        "- 🧠 **[MarketFM](https://huggingface.co/spaces/s-ttp/marketfm-ranker)** — a survivorship-free quant model "
-        "(~11,800 US stocks, 21 point-in-time factors) ranks the cross-section and sets the target portfolio\n"
-        "- ⚙️ **Deterministic execution engine** — turns targets into orders over the **Alpaca API**: weekly rebalances, "
-        "market-open checks, notional market orders, idempotent reconciliation — inside uncrossable rails "
-        "(long-only, 10% position cap, no leverage, cash buffer)\n"
-        "- 🩺 **Deterministic supervision** — daily health checks locate live performance *inside the strategy's own "
-        "20-year backtest distribution* and watch guardrails, drift and pipeline freshness\n"
-        "- 🤝 **Agentic decision crew** (Claude Opus 5) — every week an **Analyst** assesses the evidence, an adversarial "
-        "**Critic** stress-tests it, and a **PM** decides: hold, adopt a better-validated strategy variant, or pause "
-        "trading — each action gated by a **code validator** (walk-forward acceptance criteria, 90-day rate limit, hard rails)\n"
-        "- 💬 **[MarketGuruLLM](https://huggingface.co/s-ttp/qwen25-14b-fin-lora)** — a fine-tuned analyst model narrates "
-        "every rebalance and every decision in plain English\n\n"
-        "**The strategy:** large-cap **momentum + quality** while the market trend is up; when it turns down, de-risk into "
-        "a blend of **stocks + bonds + gold** (60 / 20 / 20). Backtested 2002–2026, net of costs: **~14% / yr vs the "
-        "S&P 500's ~11%**, higher Sharpe, −35% max drawdown vs the index's −49%.\n"
-        "<sub>Fully autonomous, paper trading, this page is read-only. Backtested results — past performance ≠ future. "
-        "Not investment advice.</sub>")
+        "### The AI-managed fund — researched by AI, run by AI, governed by AI\n"
+        "DeepQuant is managed end-to-end by artificial intelligence — **no human in the loop**. Its strategy was not "
+        "designed by a portfolio manager: it was **discovered by AI research agents** that stress-tested more than **150 "
+        "strategy configurations across 21 years of survivorship-free market data** — every candidate walk-forward "
+        "validated, net of costs, across five market eras — before converging on the recipe running today.\n\n"
+        "**The secret recipe:** the exact selection signal is proprietary. What we disclose: the fund holds **~60 U.S. "
+        "large caps chosen by an AI-researched quality signal**, refreshed monthly — and a **crisis-only defense**: in "
+        "confirmed severe bears (and only then) it shifts 40% into bonds and gold. No reaction to noise, corrections, "
+        "or headlines. Every trade and every result is published here, live.\n\n"
+        "**The AI stack:**\n"
+        "- 🧠 **[MarketFM](https://huggingface.co/spaces/s-ttp/marketfm-ranker)** — the AI research platform: ~11,800 US "
+        "stocks, 4.1M stock-weeks, 21 point-in-time factors — the laboratory where the recipe was found and is re-verified\n"
+        "- 🤝 **An AI investment committee** (Claude Opus 5) — every week an **Analyst** reviews the fund against its own "
+        "20-year statistical envelope, an adversarial **Critic** attacks, and a **PM** rules: hold, adopt a better-proven "
+        "variant, or pause — every action gated by a **code validator** (walk-forward proof required, rate-limited)\n"
+        "- ⚙️ **Deterministic execution** — orders, risk rails (long-only, 10% cap, no leverage), market-hours gates, "
+        "self-reconciliation: the parts where correctness must be provable are code, not judgment\n"
+        "- 🩺 **AI self-diagnosis** — daily health checks published openly; deviation from the strategy's own history is "
+        "flagged before anyone asks\n"
+        "- 💬 **[MarketGuruLLM](https://huggingface.co/s-ttp/qwen25-14b-fin-lora)** — a fine-tuned analyst model explains "
+        "every move in plain English\n\n"
+        "**Simulated record of the recipe (2005–2026, walk-forward, net of costs):** ~14%/yr vs the S&P 500's ~11% · "
+        "beat the index in **14 of 22 years** and **~69% of all rolling 3-year windows** · 2008 cushioned to −29% · "
+        "verified across 4 of 5 market eras.\n"
+        "<sub>Fully autonomous, paper trading, read-only page. Strategy v2, live since September 2026; the v1 record is "
+        "archived and available. Simulated results — past performance ≠ future. Not investment advice.</sub>")
     with gr.Tabs():
         with gr.Tab("📊 Live account"):
             stats = gr.Markdown()
@@ -319,7 +334,8 @@ with gr.Blocks(title="DeepQuant — live paper monitor", theme=gr.themes.Soft())
             plot = gr.LinePlot(x="date", y="value", color="series", height=320,
                                y_title="Account value ($)", x_title="")
             note = gr.Markdown(visible=False)
-            gr.Markdown("### 📋 Current holdings")
+            gr.Markdown("### 📋 Top 10 holdings\n<sub>Top 10 by value. The full ~60-name book is not disclosed — "
+                        "the selection signal is the fund's proprietary, AI-researched recipe.</sub>")
             tbl = gr.Dataframe(wrap=True, interactive=False)
             gov = gr.Markdown()
             with gr.Row():
@@ -333,10 +349,10 @@ with gr.Blocks(title="DeepQuant — live paper monitor", theme=gr.themes.Soft())
             pbtn = gr.Button("⟳ Recompute preview", scale=0)
             with gr.Row():
                 with gr.Column():
-                    gr.Markdown("**Target portfolio**")
+                    gr.Markdown("**Target allocation by sector** <sub>(name-level book undisclosed)</sub>")
                     tgt_tbl = gr.Dataframe(interactive=False, wrap=True)
                 with gr.Column():
-                    gr.Markdown("**Proposed orders** — sells first, then buys")
+                    gr.Markdown("**Proposed orders** — aggregate (sells execute first)")
                     ord_tbl = gr.Dataframe(interactive=False, wrap=True)
     with gr.Accordion("🧬 Why hybrid? Who decides what — and why", open=False):
         gr.Markdown(

rebalance_engine.py

@@ -42,14 +42,15 @@ def cap_weights(w, mw=MAX_W):
     return w
 
 
-DEFAULT_CFG = {"signal": ["n_mom_12_1", "n_roe"], "regime": "cross10/40",
-               "defense": "mom60_agg20_gld20", "cadence_weeks": 1, "construction": "abs10_sec5", "version": 1}
+DEFAULT_CFG = {"signal": ["n_roa"], "regime": "gate20",
+               "defense": "mom60_agg20_gld20", "cadence_weeks": 4, "construction": "n60_nocap", "version": 2}
 
 
 CONSTRUCTIONS = {
-    "abs10_sec5": {"rule": "abs", "hard": 0.10, "buffer": 0.0,  "sector_cap": 5},
-    "rel12b2_sec5": {"rule": "rel", "hard": 0.12, "buffer": 0.02, "sector_cap": 5},
-    "abs10_sec6": {"rule": "abs", "hard": 0.10, "buffer": 0.0,  "sector_cap": 6},
+    "n60_nocap": {"rule": "abs", "hard": 0.10, "buffer": 0.0, "sector_cap": 999, "size": 60},
+    "n50_nocap": {"rule": "abs", "hard": 0.10, "buffer": 0.0, "sector_cap": 999, "size": 50},
+    "n75_nocap": {"rule": "abs", "hard": 0.10, "buffer": 0.0, "sector_cap": 999, "size": 75},
+    "abs10_sec5": {"rule": "abs", "hard": 0.10, "buffer": 0.0, "sector_cap": 5, "size": 50},
 }
 
 
@@ -83,12 +84,25 @@ def _spy_series():
     return pd.Series({k: float(v["5. adjusted close"]) for k, v in ts.items()}).sort_index()
 
 
-def detect_regime(rule="cross10/40"):
+def _trail_dd(closes, n=52):
+    win = list(closes[-n:])
+    if len(win) < 26:
+        return 0.0
+    pk, m = win[0], 0.0
+    for p in win:
+        pk = max(pk, p); m = max(m, 1 - p/pk)
+    return m
+
+
+def detect_regime(rule="gate20"):
     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":
+        if rule in ("gate20", "gate15"):
+            thr = 0.20 if rule == "gate20" else 0.15
+            off = not ((s10 < s40) and (_trail_dd(list(s.values)) >= thr))
+        elif 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))
@@ -118,7 +132,7 @@ def _rank_sleeve(df, cols, sign=1, con=None):
             continue
         sec[r["sector"]] = sec.get(r["sector"], 0) + 1
         picked.append(r)
-        if len(picked) >= SIZE:
+        if len(picked) >= con.get("size", SIZE):
             break
     mc = np.array([r["marketcap"] for r in picked], float)
     if con["rule"] == "rel":