Upload 13 files

app.py

@@ -177,7 +177,7 @@ with gr.Blocks(title="Chan Compass · US", **_style_kw) as demo:
             force_cb = gr.Checkbox(value=True, label="Force fresh download", scale=1)
             run_btn = gr.Button("▶ Run analysis", variant="primary", scale=1)
         sig_summary = gr.Markdown(automation.STATE["signals_summary"])
-        sig_table = gr.Dataframe(label="Next-session plan (sorted: BUY → SELL → HOLD → WATCH)",
+        sig_table = gr.Dataframe(label="Tomorrow's plan — long-hold mode (sorted: BUY → SELL → HOLD → WAIT)",
                                  interactive=False, wrap=True)
         gr.Markdown("**Decision log** — the engine's full multi-timeframe ruling chain "
                     "(engine output is in Chinese; use the button for an English explanation).",
@@ -234,7 +234,9 @@ with gr.Blocks(title="Chan Compass · US", **_style_kw) as demo:
     with gr.Tab("🧠 Model"):
         gr.Markdown("All AI runs **locally** through **llama.cpp** (llama-cpp-python) with "
                     "Qwen3 GGUF weights — every option is far below the 32B-parameter cap, "
-                    "and nothing leaves the machine. First load downloads the GGUF once.")
+                    "and nothing leaves the machine. **First load installs the llama.cpp "
+                    "runtime + downloads the GGUF (one-time, usually 1–3 min; worst case "
+                    "~15 min if it has to compile).** Signals/rotation/news never depend on it.")
         model_pick = gr.Radio(choices=list(llm_local.MODEL_ZOO.keys()),
                               value=llm_local.DEFAULT_MODEL, label="Model")
         load_btn = gr.Button("⬇ Load model", variant="primary")

llm_local.py

@@ -35,6 +35,52 @@ _loaded_name = None
 
 _THINK_RE = re.compile(r"<think>.*?</think>", re.S)
 
+# llama-cpp-python is installed at RUNTIME, not at Space build time.
+# Why: the HF build container has little RAM and gets OOM-killed compiling the
+# C++ extension; the runtime container has the real hardware (8 vCPU / 32 GB).
+# We try the official prebuilt CPU wheel first (seconds), and only compile from
+# source as a fallback — with capped parallelism so memory stays bounded.
+_WHEEL_INDEX = "https://abetlen.github.io/llama-cpp-python/whl/cpu"
+_LLAMA_REQ = "llama-cpp-python>=0.3.8"   # >=0.3.8 → Qwen3 architecture support
+
+
+def _ensure_llama_cpp() -> str:
+    """Install llama-cpp-python on first use. Returns '' on success, else error."""
+    try:
+        import llama_cpp  # noqa: F401
+        return ""
+    except ImportError:
+        pass
+    import subprocess
+    import sys
+    env = dict(os.environ)
+    env["CMAKE_BUILD_PARALLEL_LEVEL"] = "4"   # bound memory if a compile happens
+    base = [sys.executable, "-m", "pip", "install", "--user", "--prefer-binary"]
+    # 1) prebuilt CPU wheel from the official index (fast path)
+    r = subprocess.run(base + ["--extra-index-url", _WHEEL_INDEX,
+                               "--only-binary", "llama-cpp-python", _LLAMA_REQ],
+                       capture_output=True, text=True, env=env, timeout=600)
+    if r.returncode != 0:
+        # 2) fallback: allow source build (runtime box has plenty of RAM)
+        r = subprocess.run(base + ["--extra-index-url", _WHEEL_INDEX, _LLAMA_REQ],
+                           capture_output=True, text=True, env=env, timeout=2400)
+    if r.returncode != 0:
+        return ("Could not install llama-cpp-python at runtime:\n"
+                + (r.stderr or r.stdout or "")[-800:])
+    # make the freshly installed --user package importable in this process
+    import importlib
+    import site
+    for p in site.getusersitepackages() if isinstance(site.getusersitepackages(), list) \
+            else [site.getusersitepackages()]:
+        if p not in sys.path:
+            sys.path.insert(0, p)
+    importlib.invalidate_caches()
+    try:
+        import llama_cpp  # noqa: F401
+        return ""
+    except Exception as e:
+        return f"Installed but import failed: {e}"
+
 
 def status() -> str:
     if _llm is None:
@@ -53,6 +99,9 @@ def load_model(name: str) -> str:
     with _lock:
         if _loaded_name == name and _llm is not None:
             return f"Already loaded: {name}"
+        err = _ensure_llama_cpp()
+        if err:
+            return err
         try:
             from llama_cpp import Llama
         except Exception as e:  # llama-cpp-python missing / failed to build

requirements.txt

@@ -1,8 +1,7 @@
-gradio>=4.44
+gradio>=5.49
 pandas>=2.0
 numpy>=1.24
 pyarrow>=14
 yfinance>=0.2.40
 apscheduler>=3.10
 huggingface_hub>=0.23
-llama-cpp-python>=0.2.90 --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu

signal_runner.py

@@ -21,6 +21,72 @@ import data_us
 
 DEFAULT_POOL = ["AAPL", "MSFT", "NVDA", "TSLA", "AMZN", "GOOGL", "META", "AMD", "NFLX", "JPM"]
 
+# ── LONG-HOLD mode (user requirement for the US version) ────────────────
+# Operating level = weekly: ride the pivot uplift, don't get shaken out early.
+#   mode='long'                     → daily S1/S2 in a big uptrend → HOLD (armed)
+#   require_sublevel_sell_confirm   → unconfirmed daily sells in an uptrend → HOLD
+# Real exits that still fire: S3 (pivot breakdown), structural stop,
+# and the armed exit line once the nested-interval top is confirmed.
+MultiLevelChan.CFG["mode"] = "long"
+MultiLevelChan.CFG["require_sublevel_sell_confirm"] = True
+
+STOP_MAX_LOSS = 0.05  # same global loss cap as the user's backtest
+
+
+def _structural_stop(kind: str, res) -> float | None:
+    """Simplified invalidation price, lifted from the user's backtest logic:
+    B1 → divergence low; B2 → retest low / B1 anchor; B3 → daily pivot ZD.
+    Capped so a single position can never lose much more than STOP_MAX_LOSS."""
+    sig = res.daily.signal if (res and res.daily) else None
+    ex = (sig.extras if sig is not None else None) or {}
+    close_p = float(res.cur_price)
+    stop = None
+    if kind == "B1":
+        stop = ex.get("c_new_low") or ex.get("b1_price")
+    elif kind == "B2":
+        stop = ex.get("cur_low") or ex.get("b1_price")
+    elif kind == "B3":
+        stop = res.daily.zd if (res.daily and res.daily.zd) else ex.get("pull_low")
+    if stop is None:
+        stop = close_p * (1 - STOP_MAX_LOSS)
+    stop = max(min(float(stop), close_p * 0.999), close_p * (1 - STOP_MAX_LOSS))
+    return round(stop, 2)
+
+
+def _next_day_plan(res) -> dict:
+    """The simplified answer the user asked for:
+    Do I buy/sell TOMORROW, in what price zone, and where is it wrong?"""
+    kind, act = res.final_kind, res.action
+    px = float(res.cur_price)
+    if act == "BUY" and kind in ("B1", "B2", "B3"):
+        stop = _structural_stop(kind, res)
+        if kind == "B3" and res.daily and res.daily.zg:
+            lo = max(stop, float(res.daily.zg))
+        else:
+            lo = stop
+        hi = px * 1.015
+        return {"plan": "🟢 BUY tomorrow at open",
+                "zone": f"${lo:,.2f} – ${hi:,.2f}",
+                "stop": f"${stop:,.2f}",
+                "hint": "Long-hold entry: keep until S3 / stop / armed exit line."}
+    if act == "SELL":
+        hint = {"STOP": "Structural stop hit — exit to protect capital.",
+                "S3": "Pivot breakdown (S3) — the long-hold exit signal. Exit, don't average down."}
+        return {"plan": "🔴 SELL tomorrow at open",
+                "zone": f"≈ ${px:,.2f}",
+                "stop": "—",
+                "hint": hint.get(kind, "Confirmed top (divergence verified at sub-levels) — take profit.")}
+    if act == "HOLD":
+        if res.sell_armed and res.arm_zd:
+            return {"plan": "🟡 HOLD (exit line armed)",
+                    "zone": "—",
+                    "stop": f"${float(res.arm_zd):,.2f}",
+                    "hint": f"Keep holding; sell only if price closes below ${float(res.arm_zd):,.2f}."}
+        return {"plan": "🟡 HOLD", "zone": "—", "stop": "—",
+                "hint": "Trend intact — long-hold, ignore daily noise."}
+    return {"plan": "⚪ WAIT", "zone": "—", "stop": "—",
+            "hint": (res.blocked_reason or res.note or "No actionable signal.")[:110]}
+
 OUT_DIR = "./_app_output"
 os.makedirs(OUT_DIR, exist_ok=True)
 
@@ -61,18 +127,17 @@ def analyze_one(ticker: str, force: bool = False):
 
     enh = chan_enhance.predict_enhance(res)
     weight = enh.get("suggest_weight")
+    plan = _next_day_plan(res)
     row = {
         "Ticker": ticker,
-        "Action": ACTION_BADGE.get(res.action, res.action),
+        "Tomorrow": plan["plan"],
+        "Buy zone": plan["zone"],
+        "Invalid below": plan["stop"],
         "Signal": KIND_EN.get(res.final_kind, res.final_kind or "—"),
         "Confidence": res.confidence,
         "Close": f"${res.cur_price:,.2f}",
-        "Weekly": TREND_EN.get(res.weekly.trend if res.weekly else "", "?"),
-        "Daily": TREND_EN.get(res.daily.trend if res.daily else "", "?"),
-        "Sell-trap armed": "Yes" if res.sell_armed else "—",
-        "Arm line": (f"${res.arm_zd:,.2f}" if res.arm_zd else "—"),
-        "Suggested weight": (f"{weight:.2f}" if weight else "—"),
-        "Note": (res.note or res.blocked_reason or "")[:160],
+        "Weight": (f"{weight:.2f}" if weight else "—"),
+        "Note": plan["hint"],
         "_action_raw": res.action,
         "_kind_raw": res.final_kind,
         "_date": res.analysis_date.strftime("%Y-%m-%d"),
@@ -113,7 +178,7 @@ def run_signals(tickers=None, force: bool = False):
         except Exception:
             pass
     else:
-        show = pd.DataFrame(columns=["Ticker", "Action", "Signal", "Confidence", "Close"])
+        show = pd.DataFrame(columns=["Ticker", "Tomorrow", "Buy zone", "Invalid below", "Signal", "Confidence", "Close"])
     n_buy = sum(1 for r in rows if r["_action_raw"] == "BUY")
     n_sell = sum(1 for r in rows if r["_action_raw"] == "SELL")
     asof = rows[0]["_date"] if rows else "—"