Upload 15 files

app.py

@@ -127,15 +127,16 @@ def ui_explain_detail(ticker):
         return
     # keep only the ruling chain — the per-signal diagnostics block is huge and
     # would cost a minute of silent CPU prompt-processing for no benefit
-    core = txt.split("日线买卖点逐项诊断")[0][:2400]
+    core = txt.split("日线买卖点逐项诊断")[0][:1500]
     prompt = ("Below is a Chan-theory (缠论) multi-timeframe decision log in Chinese "
               "for a US stock. Do NOT repeat or quote the log. Write a fresh plain-"
               "English explanation for a trader: 1) the final action; 2) why each "
               "timeframe gate passed/failed; 3) what price/event would invalidate "
               "the call. ≤160 words.\n\n" + core)
-    yield "🤖 _Generating (local Qwen3 via llama.cpp)…_"
-    for acc in llm_local.chat_stream(prompt, max_tokens=420):
-        yield "🤖 **AI explanation (local Qwen3 via llama.cpp):**\n\n" + acc
+    yield ("🤖 _Translator sub-agent (Qwen3-1.7B · llama.cpp) is reading the "
+           "decision log — first words in ~5-15s…_")
+    for acc in llm_local.chat_stream(prompt, max_tokens=340, worker="fast"):
+        yield "🤖 **Translator sub-agent (Qwen3-1.7B · llama.cpp):**\n\n" + acc
 
 
 def ui_refresh_rotation():
@@ -159,9 +160,10 @@ def ui_rotation_ai():
               "write a crisp brief (<150 words): 1) where capital is rotating INTO/OUT "
               "OF; 2) do 1-day moves agree with the 5/20-day trend; 3) one watch item. "
               "No disclaimers.\n\nDATA:\n" + brief[:2200])
-    yield "🤖 _Generating…_"
-    for acc in llm_local.chat_stream(prompt, max_tokens=380):
-        yield "🤖 **AI rotation narrative (local Qwen3 via llama.cpp):**\n\n" + acc
+    yield ("🤖 _Narrator sub-agent (Qwen3-1.7B · llama.cpp) is reading the flow "
+           "tables — first words in ~5-15s…_")
+    for acc in llm_local.chat_stream(prompt, max_tokens=340, worker="fast"):
+        yield "🤖 **Narrator sub-agent (Qwen3-1.7B · llama.cpp):**\n\n" + acc
 
 
 def ui_save_holdings(text):
@@ -186,7 +188,7 @@ def ui_open_report(fname):
 
 
 def ui_load_model(name):
-    return llm_local.load_model(name)
+    return llm_local.load_model(name, worker="deep")
 
 
 def ui_automation_panel():
@@ -206,7 +208,7 @@ with gr.Blocks(title="Chan Compass · US", **_style_kw) as demo:
       <div class="chips">
         <span>🧠 Local GGUF · no cloud APIs</span><span>🦙 llama.cpp runtime</span>
         <span>📊 Yahoo Finance data</span><span>⏰ Auto-update 18:10 ET</span>
-        <span>🤖 Multi-step research agent</span><span>💾 Persistent /data bucket</span><span>🎨 Spectrum 2 design</span>
+        <span>🤖 Sub-agent pool · 1.7B + 4B</span><span>💾 Persistent /data bucket</span><span>🎨 Spectrum 2 design</span>
       </div>
     </div>""")
 
@@ -291,12 +293,16 @@ with gr.Blocks(title="Chan Compass · US", **_style_kw) as demo:
                     "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.")
+        gr.Markdown("**Sub-agent pool:** `fast` Translator/Narrator (Qwen3-1.7B, "
+                    "fixed) handles Explain / rotation narrative / news briefs; "
+                    "`deep` Analyst writes research reports. Each has its own lock — "
+                    "they run in parallel. Pick the Analyst model below:")
         model_pick = gr.Radio(choices=list(llm_local.MODEL_ZOO.keys()),
-                              value=llm_local.DEFAULT_MODEL, label="Model")
+                              value=llm_local.DEFAULT_MODEL, label="Analyst (deep) model")
         with gr.Row():
             load_btn = gr.Button("⬇ Load model", variant="primary")
             status_btn = gr.Button("↻ Refresh status")
-            test_btn = gr.Button("⚡ Test model (3s)")
+            test_btn = gr.Button("⚡ Test sub-agents")
         model_status = gr.Markdown(llm_local.status())
 
     gr.Markdown("Chan Compass · educational tool, not investment advice · "
@@ -327,11 +333,10 @@ automation.start_scheduler()
 # explanations, rotation narrative, research agent) are ready without a click.
 def _auto_load_model():
     try:
-        automation._log("Auto-loading local model (llama.cpp)…")
-        msg = llm_local.load_model(llm_local.DEFAULT_MODEL)
-        automation._log(f"Model: {msg}")
+        automation._log("Auto-loading sub-agents (llama.cpp)…")
+        llm_local.auto_load_all()
     except Exception as e:
-        automation._log(f"Model auto-load failed: {e}")
+        automation._log(f"Sub-agent auto-load failed: {e}")
 
 try:
     import paths as _paths

llm_local.py

@@ -1,17 +1,21 @@
 """
-llm_local.py — local small-model brain (llama.cpp runtime, no cloud APIs).
-
-Earns the hackathon "Off the Grid" + "Llama Champion" badges:
-  * Models are Qwen3 GGUF files (all far below the 32B parameter cap)
-  * Inference runs through llama.cpp via llama-cpp-python
-  * The GGUF is downloaded once from the HF Hub, then everything is local
-
-The model's job in this app is language work the rule engine can't do:
-  1. Brief today's news on held US tickers, tagging POSITIVE/NEGATIVE/NEUTRAL.
-  2. Read the sector ETF flow tables and narrate where capital is rotating.
-  3. Write the Research Note (beta): valuation, moat, bull/bear case.
-  4. Translate the (Chinese) Chan-theory decision chain into plain English.
+llm_local.py — local sub-agent pool (llama.cpp runtime, no cloud APIs).
+
+Two independent model instances ("sub-agents"), each with its own lock, so
+features never block each other with "model busy":
+
+    fast  · Translator/Narrator — Qwen3-1.7B Q8 (≈2 GB RAM)
+            → Explain-in-English, sector-rotation narrative, news briefs.
+            Small = quick CPU prefill, answers start streaming in seconds.
+    deep  · Analyst — Qwen3-4B Q4_K_M by default (swappable in the Model tab)
+            → the multi-step Auto Research agent's report writing.
+
+Both run through llama.cpp (llama-cpp-python) and are far below the 32B cap;
+the fast worker doubles as the "Tiny Titan" (≤4B) story. ~5 GB RAM total on a
+32 GB Space. Earns "Off the Grid" + "Llama Champion".
 """
+from __future__ import annotations
+
 import os
 import re
 import threading
@@ -19,7 +23,7 @@ import threading
 import paths  # sets HF_HOME + sys.path for /data persistence
 from huggingface_hub import hf_hub_download
 
-# name -> (HF repo, gguf filename, note)
+# name -> (HF repo, gguf filename)
 MODEL_ZOO = {
     "Qwen3-1.7B · Tiny Titan (≤4B award class)": (
         "Qwen/Qwen3-1.7B-GGUF", "Qwen3-1.7B-Q8_0.gguf"),
@@ -30,41 +34,47 @@ MODEL_ZOO = {
     "Qwen3-14B · max quality (still far under 32B cap)": (
         "Qwen/Qwen3-14B-GGUF", "Qwen3-14B-Q4_K_M.gguf"),
 }
+FAST_MODEL = "Qwen3-1.7B · Tiny Titan (≤4B award class)"
 DEFAULT_MODEL = "Qwen3-4B  · default — fast + smart, still ≤4B"
 
-_lock = threading.Lock()        # serializes inference only
-_load_lock = threading.Lock()   # serializes install/download/load
-_llm = None
-_loaded_name = None
+_THINK_RE = re.compile(r"<think>.*?</think>", re.S)
+_NCPU = max(2, (os.cpu_count() or 4))
+
+WORKER_LABEL = {"fast": "Translator/Narrator sub-agent",
+                "deep": "Analyst sub-agent"}
 
-# Visible progress for the Model tab / Automation log — every stage updates this,
-# so "nothing happens" can never happen again: the status always says WHY.
-PROGRESS = {"stage": "idle", "detail": "", "ts": None}
+WORKERS = {
+    "fast": {"model": FAST_MODEL, "llm": None, "lock": threading.Lock(),
+             "load_lock": threading.Lock(), "stage": "idle", "detail": "", "ts": None},
+    "deep": {"model": DEFAULT_MODEL, "llm": None, "lock": threading.Lock(),
+             "load_lock": threading.Lock(), "stage": "idle", "detail": "", "ts": None},
+}
 
+_install_lock = threading.Lock()
 
-def _set_stage(stage: str, detail: str = ""):
+
+def _set_stage(worker: str, stage: str, detail: str = ""):
     import datetime as _dt
-    PROGRESS.update(stage=stage, detail=detail[:400],
-                    ts=_dt.datetime.utcnow().strftime("%H:%M:%S UTC"))
+    w = WORKERS[worker]
+    w.update(stage=stage, detail=detail[:400],
+             ts=_dt.datetime.utcnow().strftime("%H:%M:%S UTC"))
     try:
         import automation
-        automation._log(f"[model] {stage}: {detail[:160]}")
+        automation._log(f"[{WORKER_LABEL[worker]}] {stage}: {detail[:140]}")
     except Exception:
         pass
 
-_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.
+# ─────────────────────── runtime install (once, persisted) ───────────────────────
+# Installed at RUNTIME, not at Space build time: the HF build container has
+# little RAM and gets OOM-killed compiling the C++ extension; the runtime
+# container has the real hardware. Prebuilt CPU wheel first, capped-parallelism
+# source build as fallback. Persisted to /data/pylibs.
 _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."""
+def _ensure_llama_cpp(worker: str) -> str:
     try:
         import llama_cpp  # noqa: F401
         return ""
@@ -72,123 +82,137 @@ def _ensure_llama_cpp() -> str:
         pass
     import subprocess
     import sys
-    env = dict(os.environ)
-    env["CMAKE_BUILD_PARALLEL_LEVEL"] = "4"   # bound memory if a compile happens
-    _set_stage("installing llama.cpp runtime",
-               "trying official prebuilt CPU wheel (≈1 min)…")
-    if paths.PERSISTENT:
-        base = [sys.executable, "-m", "pip", "install", "--prefer-binary",
-                "--target", paths.PYLIBS_DIR]
-    else:
-        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)
-        _set_stage("installing llama.cpp runtime",
-                   "no prebuilt wheel matched — compiling from source "
-                   "(one-time, ~10-15 min; other tabs keep working)…")
-        r = subprocess.run(base + ["--extra-index-url", _WHEEL_INDEX, _LLAMA_REQ],
-                           capture_output=True, text=True, env=env, timeout=2400)
-    if r.returncode != 0:
-        err = (r.stderr or r.stdout or "")[-800:]
-        _set_stage("install FAILED", err)
-        return "Could not install llama-cpp-python at runtime:\n" + err
-    # make the freshly installed package importable in this process
-    import importlib
-    import site
-    cands = [paths.PYLIBS_DIR] if paths.PERSISTENT else []
-    usp = site.getusersitepackages()
-    cands += usp if isinstance(usp, list) else [usp]
-    for p in cands:
-        if p and p not in sys.path:
-            sys.path.append(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 not None:
-        return (f"✅ **Model ready:** {_loaded_name} · runtime: llama.cpp "
-                f"(local, no cloud APIs)")
-    st, dt_, ts = PROGRESS["stage"], PROGRESS["detail"], PROGRESS["ts"]
-    if st == "idle":
-        return ("No model loaded yet. It auto-loads at startup — press "
-                "“↻ Refresh status”, or “⬇ Load model”.")
-    line1 = f"⏳ **{st}** ({ts}) — {dt_ or '...'}"
-    return line1 + "\n\nOther tabs keep working; press “↻ Refresh status” to update."
-
-
-def available() -> bool:
-    return _llm is not None
-
-
-def load_model(name: str) -> str:
-    """Download (once) and load a GGUF model. Returns a status string.
-    Non-blocking: if another install/load is already running (e.g. the startup
-    auto-load), this returns its live status instead of hanging the click."""
-    global _llm, _loaded_name
-    repo, fname = MODEL_ZOO[name]
-    if not _load_lock.acquire(timeout=2):
-        return ("⏳ A model install/load is already running in the background — "
-                f"current stage: **{PROGRESS['stage']}** ({PROGRESS['detail'] or '…'}). "
-                "Press “↻ Refresh status” to watch it.")
+    with _install_lock:
+        try:  # another thread may have finished it while we waited
+            import llama_cpp  # noqa: F401
+            return ""
+        except ImportError:
+            pass
+        env = dict(os.environ)
+        env["CMAKE_BUILD_PARALLEL_LEVEL"] = "4"
+        _set_stage(worker, "installing llama.cpp runtime",
+                   "trying official prebuilt CPU wheel (≈1 min)…")
+        if paths.PERSISTENT:
+            base = [sys.executable, "-m", "pip", "install", "--prefer-binary",
+                    "--target", paths.PYLIBS_DIR]
+        else:
+            base = [sys.executable, "-m", "pip", "install", "--user", "--prefer-binary"]
+        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:
+            _set_stage(worker, "installing llama.cpp runtime",
+                       "no prebuilt wheel matched — compiling from source "
+                       "(one-time ~10-15 min; other tabs keep working)…")
+            r = subprocess.run(base + ["--extra-index-url", _WHEEL_INDEX, _LLAMA_REQ],
+                               capture_output=True, text=True, env=env, timeout=2400)
+        if r.returncode != 0:
+            err = (r.stderr or r.stdout or "")[-800:]
+            _set_stage(worker, "install FAILED", err)
+            return "Could not install llama-cpp-python at runtime:\n" + err
+        import importlib
+        import site
+        cands = [paths.PYLIBS_DIR] if paths.PERSISTENT else []
+        usp = site.getusersitepackages()
+        cands += usp if isinstance(usp, list) else [usp]
+        for p in cands:
+            if p and p not in sys.path:
+                sys.path.append(p)
+        importlib.invalidate_caches()
+        try:
+            import llama_cpp  # noqa: F401
+            return ""
+        except Exception as e:
+            _set_stage(worker, "install FAILED", f"installed but import failed: {e}")
+            return f"Installed but import failed: {e}"
+
+
+# ─────────────────────── loading ───────────────────────
+def load_model(name: str, worker: str = "deep") -> str:
+    """Load a GGUF into a worker slot. Non-blocking: if that worker is already
+    installing/loading, returns its live stage instead of hanging the click."""
+    w = WORKERS[worker]
+    if not w["load_lock"].acquire(timeout=2):
+        return (f"⏳ {WORKER_LABEL[worker]} is busy — current stage: "
+                f"**{w['stage']}** ({w['detail'] or '…'}). Press “↻ Refresh status”.")
     try:
-        if _loaded_name == name and _llm is not None:
-            return f"Already loaded: {name}"
-        err = _ensure_llama_cpp()
+        if w["llm"] is not None and w["model"] == name:
+            return f"Already loaded on {WORKER_LABEL[worker]}: {name}"
+        err = _ensure_llama_cpp(worker)
         if err:
             return err
         try:
             from llama_cpp import Llama
-        except Exception as e:  # llama-cpp-python missing / failed to build
-            _set_stage("import FAILED", str(e))
+        except Exception as e:
+            _set_stage(worker, "import FAILED", str(e))
             return f"llama-cpp-python is not available: {e}"
+        repo, fname = MODEL_ZOO[name]
         try:
-            _set_stage("downloading GGUF", f"{repo}/{fname} (cached on /data after first time)")
+            _set_stage(worker, "downloading GGUF",
+                       f"{repo}/{fname} (cached on /data after first time)")
             path = hf_hub_download(repo_id=repo, filename=fname)
         except Exception as e:
-            _set_stage("download FAILED", str(e))
+            _set_stage(worker, "download FAILED", str(e))
             return f"Could not download {repo}/{fname}: {e}"
         try:
-            _set_stage("loading model into RAM", name)
-            _llm = None
-            _llm = Llama(
+            _set_stage(worker, "loading model into RAM", name)
+            w["llm"] = None
+            w["llm"] = Llama(
                 model_path=path,
-                n_ctx=6144,
-                n_threads=max(2, (os.cpu_count() or 4)),
-                n_threads_batch=max(2, (os.cpu_count() or 4)),
+                n_ctx=4096 if worker == "fast" else 6144,
+                n_threads=_NCPU,
+                n_threads_batch=_NCPU,
                 n_batch=512,
                 verbose=False,
             )
-            _loaded_name = name
-            _set_stage("ready", name)
-            return f"✅ Loaded: {name}"
+            w["model"] = name
+            _set_stage(worker, "ready", name)
+            return f"✅ {WORKER_LABEL[worker]} ready: {name}"
         except Exception as e:
-            _llm = None
-            _loaded_name = None
-            _set_stage("load FAILED", str(e))
+            w["llm"] = None
+            _set_stage(worker, "load FAILED", str(e))
             return f"Failed to load model: {e}"
     finally:
-        _load_lock.release()
+        w["load_lock"].release()
+
 
+def auto_load_all():
+    """Startup: bring the fast sub-agent up first (small download, features go
+    live quickly), then the deep one. Runs in a background thread."""
+    load_model(WORKERS["fast"]["model"], worker="fast")
+    load_model(WORKERS["deep"]["model"], worker="deep")
 
-DEFAULT_SYSTEM = ("You are the analysis brain of Chan Compass, a US-equity "
-                  "dashboard. Answer in clear, concise English.")
 
+# ─────────────────────── status ───────────────────────
+def is_loaded(worker: str = None) -> bool:
+    if worker:
+        return WORKERS[worker]["llm"] is not None
+    return any(w["llm"] is not None for w in WORKERS.values())
 
-def is_loaded() -> bool:
-    return _llm is not None
+
+def available() -> bool:
+    return is_loaded()
 
 
-# CPU reality check: prompt prefill is the slow part on a Space (≈100-200 tok/s).
-# Keep prompts SHORT — every kilobyte of prompt is seconds of silence for the user.
+def status() -> str:
+    lines = []
+    for key in ("fast", "deep"):
+        w = WORKERS[key]
+        label = WORKER_LABEL[key]
+        if w["llm"] is not None:
+            lines.append(f"✅ **{label}** — {w['model']} · llama.cpp, local")
+        elif w["stage"] == "idle":
+            lines.append(f"⚪ **{label}** — not loaded yet (auto-loads at startup)")
+        else:
+            lines.append(f"⏳ **{label}** — {w['stage']} ({w['ts']}): {w['detail'] or '…'}")
+    lines.append("\n_Each sub-agent has its own lock — Explain / narrative / "
+                 "research run in parallel without “model busy”._")
+    return "\n\n".join(lines)
+
+
+# ─────────────────────── inference ───────────────────────
+DEFAULT_SYSTEM = ("You are a sub-agent of Chan Compass, a US-equity dashboard. "
+                  "Answer in clear, concise English.")
 MAX_PROMPT_CHARS = 3200
 
 
@@ -198,14 +222,15 @@ def _messages(user: str, system: str):
 
 
 def chat(user: str, max_tokens: int = 500, temperature: float = 0.3,
-         system: str = DEFAULT_SYSTEM) -> str:
-    """One blocking chat turn (used by the pipeline/agent)."""
-    if _llm is None:
+         system: str = DEFAULT_SYSTEM, worker: str = "fast") -> str:
+    """Blocking chat on one sub-agent (used by pipeline/agent code)."""
+    w = WORKERS[worker]
+    if w["llm"] is None:
         return ""
-    if not _lock.acquire(timeout=180):
-        return "(model busy — another generation is running, try again in a moment)"
+    if not w["lock"].acquire(timeout=180):
+        return f"({WORKER_LABEL[worker]} busy — try again in a moment)"
     try:
-        out = _llm.create_chat_completion(
+        out = w["llm"].create_chat_completion(
             messages=_messages(user, system),
             max_tokens=max_tokens, temperature=temperature)
         txt = out["choices"][0]["message"]["content"] or ""
@@ -213,22 +238,23 @@ def chat(user: str, max_tokens: int = 500, temperature: float = 0.3,
     except Exception as e:
         return f"(model error: {e})"
     finally:
-        _lock.release()
+        w["lock"].release()
 
 
 def chat_stream(user: str, max_tokens: int = 500, temperature: float = 0.3,
-                system: str = DEFAULT_SYSTEM):
-    """Streaming chat turn — yields the cumulative text so the UI shows tokens
-    immediately instead of a dead spinner."""
-    if _llm is None:
-        yield "⏳ The local model isn't loaded yet — check the **Model** tab."
+                system: str = DEFAULT_SYSTEM, worker: str = "fast"):
+    """Streaming chat on one sub-agent — yields cumulative text immediately."""
+    w = WORKERS[worker]
+    if w["llm"] is None:
+        yield (f"⏳ {WORKER_LABEL[worker]} isn't ready yet — "
+               f"stage: {w['stage']}. Check the **Model** tab.")
         return
-    if not _lock.acquire(timeout=5):
-        yield "⏳ Model is busy with another generation — try again in a moment."
+    if not w["lock"].acquire(timeout=5):
+        yield f"⏳ {WORKER_LABEL[worker]} is finishing another answer — try again in a few seconds."
         return
     try:
         acc = ""
-        for chunk in _llm.create_chat_completion(
+        for chunk in w["llm"].create_chat_completion(
                 messages=_messages(user, system),
                 max_tokens=max_tokens, temperature=temperature, stream=True):
             delta = chunk["choices"][0]["delta"].get("content") or ""
@@ -241,15 +267,18 @@ def chat_stream(user: str, max_tokens: int = 500, temperature: float = 0.3,
     except Exception as e:
         yield f"(model error: {e})"
     finally:
-        _lock.release()
+        w["lock"].release()
 
 
 def quick_test() -> str:
-    """3-second sanity check that inference works."""
+    """Sanity check both sub-agents."""
     import time
-    if _llm is None:
-        return status()
-    t0 = time.time()
-    out = chat("Reply with exactly: Chan Compass model OK", max_tokens=12,
-               temperature=0.0)
-    return f"**{out or '(no output)'}** · {time.time()-t0:.1f}s"
+    outs = []
+    for key in ("fast", "deep"):
+        if WORKERS[key]["llm"] is None:
+            outs.append(f"{WORKER_LABEL[key]}: not loaded ({WORKERS[key]['stage']})")
+            continue
+        t0 = time.time()
+        out = chat("Reply with exactly: OK", max_tokens=6, temperature=0.0, worker=key)
+        outs.append(f"{WORKER_LABEL[key]}: **{out or '(no output)'}** · {time.time()-t0:.1f}s")
+    return "\n\n".join(outs)

news_watch.py

@@ -91,7 +91,7 @@ def _llm_brief(ticker: str, items: list) -> str:
             "action (e.g. 'no action', 'review stop level', 'watch earnings'). "
             "Be specific, no disclaimers."
         )
-        return llm_local.chat(prompt, max_tokens=240)
+        return llm_local.chat(prompt, max_tokens=240, worker="fast")
     except Exception:
         return ""
 

research_agent.py

@@ -80,8 +80,10 @@ class Trace:
 def _llm(prompt: str, max_tokens: int = 500) -> str:
     try:
         import llm_local
-        if llm_local.is_loaded():
-            return llm_local.chat(prompt, max_tokens=max_tokens)
+        if llm_local.is_loaded("deep"):
+            return llm_local.chat(prompt, max_tokens=max_tokens, worker="deep")
+        if llm_local.is_loaded("fast"):       # deep still loading → fall back
+            return llm_local.chat(prompt, max_tokens=max_tokens, worker="fast")
     except Exception:
         pass
     return ""
@@ -337,7 +339,8 @@ def run_research_stream(ticker: str):
     body = ""
     try:
         import llm_local
-        for acc in llm_local.chat_stream(prompt, max_tokens=900):
+        wk = "deep" if llm_local.is_loaded("deep") else "fast"
+        for acc in llm_local.chat_stream(prompt, max_tokens=900, worker=wk):
             body = acc
             yield "\n".join(log_lines), head + body
     except Exception as e:

rotation.py

@@ -150,6 +150,6 @@ def llm_narrative(df_1d, df_5d, df_20d) -> str:
             "trend (rotation vs one-day noise); 3) one actionable watch item. "
             "No disclaimers.\n\nDATA:\n" + brief
         )
-        return llm_local.chat(prompt, max_tokens=420)
+        return llm_local.chat(prompt, max_tokens=380, worker="fast")
     except Exception as e:
         return f"**Raw read:**\n{brief}\n\n_(LLM unavailable: {e})_"