Upload 18 files

app.py

@@ -11,6 +11,7 @@ github.com/adobe/react-spectrum), approximated in Gradio CSS:
 from __future__ import annotations
 
 import os
+import re
 import threading
 
 import gradio as gr
@@ -44,6 +45,11 @@ def ui_run_signals(tickers_text, force):
     automation.STATE["signals_df"] = df
     automation.STATE["signals_details"] = details
     automation.STATE["signals_summary"] = summary
+    # Pre-translate every ruling chain to English in the BACKGROUND on the
+    # dedicated rchain sub-agent, so when the user clicks AI summary the English
+    # chain is already cached → faster, and the merge step gets English-only
+    # input (no Chinese can leak into the output).
+    _kick_chain_translation(details)
     choices = sorted(details.keys())
     return (
         df if df is not None else pd.DataFrame(),
@@ -52,6 +58,50 @@ def ui_run_signals(tickers_text, force):
     )
 
 
+def _chain_core(ticker: str) -> str:
+    """The ruling chain minus the huge per-signal diagnostics block."""
+    chain = automation.STATE.get("signals_details", {}).get(ticker, "")
+    return chain.split("日线买卖点逐项诊断")[0].strip()[:2000] if chain else ""
+
+
+def _translate_chain(ticker: str) -> str:
+    """Translate one ruling chain to English on the dedicated rchain sub-agent;
+    cache the result. Returns the English text (or '' if no model/chain)."""
+    cache = automation.STATE.setdefault("chain_en", {})
+    if ticker in cache:
+        return cache[ticker]
+    core = _chain_core(ticker)
+    if not core:
+        return ""
+    if not (llm_local.is_loaded("rchain") or llm_local.is_loaded("translator")):
+        return ""
+    wk = "rchain" if llm_local.is_loaded("rchain") else "translator"
+    prompt = ("Translate this Chinese multi-timeframe Chan-theory decision log "
+              "into concise English. Keep the structure (one line per level: "
+              "yearly / monthly / weekly / daily / 60m / 30m …). Output ENGLISH "
+              "ONLY, no Chinese characters, no commentary.\n\n" + core)
+    en = llm_local.chat(prompt, max_tokens=380, temperature=0.1, worker=wk)
+    if en and not en.startswith(("(", "⏳")):
+        cache[ticker] = en
+        return en
+    return ""
+
+
+def _kick_chain_translation(details: dict):
+    """Background: translate all ruling chains to English right after analysis,
+    so AI summary is instant and English-only later."""
+    import threading
+    automation.STATE["chain_en"] = {}   # reset for the new run
+
+    def _run():
+        for tk in list(details.keys()):
+            try:
+                _translate_chain(tk)
+            except Exception:
+                pass
+    threading.Thread(target=_run, daemon=True).start()
+
+
 def ui_show_detail(ticker):
     if not ticker:
         return "Select a ticker after running the analysis."
@@ -66,28 +116,42 @@ def ui_explain_detail(ticker):
     if not raw:
         yield "Run the analysis and select a ticker first."
         return
-    # The full Chan ruling chain (Chinese) is kept BACKSTAGE in STATE and fed to
-    # the model alongside the English raw read, so the summary reflects the real
-    # multi-timeframe reasoning — but the chain is never shown and output is
-    # English only. (This restores the merged raw-read + ruling-chain logic.)
-    chain = automation.STATE.get("signals_details", {}).get(ticker or "", "")
-    chain_core = chain.split("日线买卖点逐项诊断")[0].strip()[:2000] if chain else ""
+    # Use the pre-translated English ruling chain (translated in the background
+    # right after Run analysis). If it isn't ready yet, translate it now on the
+    # rchain sub-agent. Both the fact line AND the chain are now English, so the
+    # merge step cannot leak Chinese into the output.
+    chain_en = automation.STATE.get("chain_en", {}).get(ticker or "")
+    if not chain_en:
+        yield "🤖 _Translating the multi-timeframe ruling chain to English…_"
+        chain_en = _translate_chain(ticker or "")
     prompt = ("You are an equity analyst. Write a SHORT plain-English summary "
               "(≤100 words) for a long-term holder of a US stock: the situation "
               "today, whether to act or wait, and the key price levels.\n"
-              "Use the FACT LINE for the numbers, and the RULING CHAIN (a "
-              "Chinese multi-timeframe Chan-theory decision log) for the reasoning "
-              "— translate and synthesize it; output ENGLISH ONLY, no Chinese "
-              "characters, do not quote the log, no disclaimers.\n\n"
+              "Base it on the FACT LINE (numbers) and the REASONING (an English "
+              "translation of the multi-timeframe Chan-theory verdict). Output "
+              "ENGLISH ONLY, do not quote the inputs, no disclaimers.\n\n"
               f"FACT LINE:\n{raw}")
-    if chain_core:
-        prompt += f"\n\nRULING CHAIN (translate & synthesize, don't quote):\n{chain_core}"
+    if chain_en:
+        prompt += f"\n\nREASONING:\n{chain_en}"
     yield "🤖 _Translator sub-agent (Qwen3-1.7B · llama.cpp) is summarizing…_"
     final = ""
-    for acc in llm_local.chat_stream(prompt, max_tokens=260, temperature=0.2,
+    for acc in llm_local.chat_stream(prompt, max_tokens=240, temperature=0.2,
                                      worker="translator"):
         final = acc
         yield "🤖 **AI narrative (Translator sub-agent · Qwen3-1.7B):**\n\n" + acc
+    # English-only guarantee: if the model still slipped in Chinese, re-run once
+    # asking for a strict English rewrite.
+    if re.search(r"[\u4e00-\u9fff]", final):
+        fix = ("Rewrite the following as an English-only equity summary "
+               "(≤100 words). Remove ALL Chinese characters, keep the meaning "
+               "and numbers, no disclaimers:\n\n" + final)
+        fixed = ""
+        for acc in llm_local.chat_stream(fix, max_tokens=240, temperature=0.1,
+                                         worker="translator"):
+            fixed = acc
+            yield "🤖 **AI narrative (Translator sub-agent · Qwen3-1.7B):**\n\n" + acc
+        if fixed:
+            final = fixed
     # capture (raw read → narrative) as a fine-tuning pair (🎯 Well-Tuned)
     try:
         import finetune_data

llm_local.py

@@ -51,6 +51,7 @@ _NCPU = max(2, (os.cpu_count() or 4))
 # the 4B Analyst writes reports. Total ≈ 9 GB on a 32 GB Space.
 WORKER_LABEL = {
     "translator": "Translator sub-agent (Signals · Explain)",
+    "rchain":     "Ruling-Chain Translator sub-agent (中文→EN)",
     "narrator":   "Narrator sub-agent (Sector Rotation)",
     "reporter":   "Reporter sub-agent (News · Research support)",
     "analyst":    "Analyst sub-agent (Auto Research)",
@@ -64,6 +65,7 @@ def _mk(model):
 
 WORKERS = {
     "translator": _mk(FAST_MODEL),
+    "rchain":     _mk(FAST_MODEL),
     "narrator":   _mk(FAST_MODEL),
     "reporter":   _mk(FAST_MODEL),
     "analyst":    _mk(DEFAULT_MODEL),
@@ -206,7 +208,7 @@ def load_model(name: str, worker: str = "analyst") -> str:
 def auto_load_all():
     """Startup: tiny agents first (one small GGUF download serves all three),
     then the Analyst. Runs in a background thread."""
-    for key in ("translator", "narrator", "reporter", "analyst"):
+    for key in ("translator", "rchain", "narrator", "reporter", "analyst"):
         load_model(WORKERS[key]["model"], worker=key)
 
 
@@ -219,7 +221,7 @@ def is_loaded(worker: str = None) -> bool:
 
 def status() -> str:
     lines = []
-    for key in ("translator", "narrator", "reporter", "analyst"):
+    for key in ("translator", "rchain", "narrator", "reporter", "analyst"):
         w = WORKERS[key]
         label = WORKER_LABEL[key]
         if w["llm"] is not None:
@@ -297,7 +299,7 @@ def quick_test() -> str:
     """Sanity check both sub-agents."""
     import time
     outs = []
-    for key in ("translator", "narrator", "reporter", "analyst"):
+    for key in ("translator", "rchain", "narrator", "reporter", "analyst"):
         if WORKERS[key]["llm"] is None:
             outs.append(f"{WORKER_LABEL[key]}: not loaded ({WORKERS[key]['stage']})")
             continue