Upload 13 files

app.py

@@ -0,0 +1,267 @@
+"""
+Chan Compass — US edition
+Multi-timeframe Chan-theory signals · sector rotation · local-LLM research.
+
+UI follows Adobe Spectrum 2 design language (https://s2.spectrum.adobe.com /
+github.com/adobe/react-spectrum), approximated in Gradio CSS:
+  * Adobe Clean is proprietary → Source Sans 3 (Adobe's open font) instead
+  * Spectrum 2 accent blue #0265DC, gray-50 canvas, white cards
+  * signature fully-rounded "pill" buttons, soft 16px card radii, focus rings
+"""
+from __future__ import annotations
+
+import gradio as gr
+import pandas as pd
+
+import automation
+import llm_local
+import news_watch
+import research
+import rotation
+import signal_runner
+
+# ─────────────────────────────────────────── Spectrum 2 theme ──
+S2_FONT = gr.themes.GoogleFont("Source Sans 3")
+S2_MONO = gr.themes.GoogleFont("Source Code Pro")
+
+theme = gr.themes.Default(
+    font=[S2_FONT, "Adobe Clean", "system-ui", "sans-serif"],
+    font_mono=[S2_MONO, "monospace"],
+    primary_hue=gr.themes.colors.blue,
+    neutral_hue=gr.themes.colors.gray,
+    radius_size=gr.themes.sizes.radius_lg,
+).set(
+    button_primary_background_fill="#0265DC",
+    button_primary_background_fill_hover="#0054B6",
+    button_primary_text_color="#FFFFFF",
+    button_secondary_background_fill="#FFFFFF",
+    button_secondary_border_color="#B1B1B1",
+    button_secondary_text_color="#222222",
+    block_background_fill="#FFFFFF",
+    background_fill_primary="#F8F8F8",
+    background_fill_secondary="#FFFFFF",
+    border_color_primary="#E6E6E6",
+    block_shadow="0 1px 4px rgba(0,0,0,.06)",
+    block_radius="16px",
+    input_radius="8px",
+)
+
+S2_CSS = """
+:root{
+  --s2-accent:#0265DC; --s2-accent-down:#0054B6;
+  --s2-gray-50:#F8F8F8; --s2-gray-75:#F3F3F3; --s2-gray-200:#E6E6E6;
+  --s2-gray-800:#292929; --s2-positive:#007A39; --s2-negative:#D7373F;
+}
+body, .gradio-container{background:var(--s2-gray-50)!important;color:var(--s2-gray-800);}
+.gradio-container{max-width:1280px!important;margin:0 auto!important;}
+
+/* Spectrum 2 signature: pill buttons */
+button{border-radius:999px!important;font-weight:600!important;}
+button:focus-visible{outline:2px solid var(--s2-accent)!important;outline-offset:2px;}
+
+/* hero */
+#s2-hero{background:linear-gradient(120deg,#0265DC 0%,#5258E4 55%,#7326D3 100%);
+  border-radius:20px;padding:28px 32px;color:#fff;margin-bottom:6px;}
+#s2-hero h1{margin:0;font-size:30px;font-weight:800;letter-spacing:-.5px;color:#fff;}
+#s2-hero p{margin:6px 0 0;opacity:.92;font-size:15px;color:#fff;}
+#s2-hero .chips span{display:inline-block;background:rgba(255,255,255,.16);
+  border:1px solid rgba(255,255,255,.35);border-radius:999px;padding:3px 12px;
+  font-size:12.5px;margin:10px 8px 0 0;}
+
+/* tab strip — Spectrum quiet tabs with accent underline */
+.tab-nav{border-bottom:2px solid var(--s2-gray-200)!important;}
+.tab-nav button{border-radius:8px 8px 0 0!important;font-size:15px!important;
+  color:#6e6e6e!important;background:transparent!important;border:none!important;}
+.tab-nav button.selected{color:var(--s2-accent)!important;
+  box-shadow:inset 0 -3px 0 var(--s2-accent)!important;font-weight:700!important;}
+
+/* cards */
+.block{border:1px solid var(--s2-gray-200)!important;}
+table{font-size:13.5px!important;}
+thead th{background:var(--s2-gray-75)!important;font-weight:700!important;}
+
+.s2-footnote{color:#6e6e6e;font-size:12.5px;}
+#detail-log textarea{font-family:'Source Code Pro',monospace!important;font-size:12.5px!important;}
+"""
+
+# ─────────────────────────────────────────── UI callbacks ──
+def ui_run_signals(tickers_text, force):
+    tickers = [t for t in tickers_text.replace("\n", ",").split(",") if t.strip()]
+    msg = automation.run_pipeline(tickers or None, force=bool(force))
+    df = automation.STATE["signals_df"]
+    choices = sorted(automation.STATE["signals_details"].keys())
+    d1, d5, d20, asof = automation.STATE["rotation"]
+    return (
+        df if df is not None else pd.DataFrame(),
+        automation.STATE["signals_summary"] + f"  ·  {msg}",
+        gr.update(choices=choices, value=(choices[0] if choices else None)),
+        rotation.fmt_table(d1), rotation.fmt_table(d5), rotation.fmt_table(d20),
+        f"Sector flows as of **{asof}**",
+        automation.STATE["rotation_narrative"],
+        automation.STATE["news_md"],
+    )
+
+
+def ui_show_detail(ticker):
+    if not ticker:
+        return "Select a ticker after running the pipeline."
+    return automation.STATE["signals_details"].get(ticker, "No detail for this ticker yet.")
+
+
+def ui_explain_detail(ticker):
+    txt = automation.STATE["signals_details"].get(ticker or "", "")
+    if not txt:
+        return "Run the pipeline and select a ticker first."
+    if not llm_local.is_loaded():
+        return "Load a model in the **Model** tab first."
+    prompt = ("Below is a Chan-theory (缠论) multi-timeframe decision log in Chinese "
+              "for a US stock. Explain it in plain English for a trader: the final "
+              "action, why each timeframe gate passed/failed, and what would "
+              "invalidate the call. ≤200 words.\n\n" + txt[:6000])
+    return llm_local.chat(prompt, max_tokens=520)
+
+
+def ui_refresh_rotation():
+    d1, d5, d20, asof = rotation.build_rotation(force=True)
+    automation.STATE["rotation"] = (d1, d5, d20, asof)
+    narrative = rotation.llm_narrative(d1, d5, d20)
+    automation.STATE["rotation_narrative"] = narrative
+    return (rotation.fmt_table(d1), rotation.fmt_table(d5), rotation.fmt_table(d20),
+            f"Sector flows as of **{asof}**", narrative)
+
+
+def ui_save_holdings(text):
+    saved = news_watch.save_holdings(text.replace("\n", ",").split(","))
+    return f"Saved {len(saved)} holding(s): {', '.join(saved) if saved else '—'}"
+
+
+def ui_check_news():
+    md = news_watch.check_holdings_news()
+    automation.STATE["news_md"] = md
+    return md
+
+
+def ui_research(ticker):
+    return research.research_note(ticker)
+
+
+def ui_load_model(name):
+    return llm_local.load_model(name)
+
+
+def ui_automation_panel():
+    return automation.schedule_info(), "\n".join(automation.STATE["log"][-30:]) or "(no log yet)"
+
+
+# ─────────────────────────────────────────── layout ──
+_GR_MAJOR = int(gr.__version__.split(".")[0])
+_style_kw = {} if _GR_MAJOR >= 6 else {"theme": theme, "css": S2_CSS}
+
+with gr.Blocks(title="Chan Compass · US", **_style_kw) as demo:
+    gr.HTML("""
+    <div id="s2-hero">
+      <h1>Chan Compass <span style="font-weight:300">· US Markets</span></h1>
+      <p>Multi-timeframe 缠论 (Chan theory) signal engine — monthly → weekly → daily → 60m → 30m → 15m → 5m
+         nested-interval confirmation — plus sector capital rotation and a fully local llama.cpp research brain.</p>
+      <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>🎨 Spectrum 2 design</span>
+      </div>
+    </div>""")
+
+    with gr.Tab("📈 Signals"):
+        with gr.Row():
+            tickers_in = gr.Textbox(value=", ".join(signal_runner.DEFAULT_POOL),
+                                    label="Ticker pool (comma separated)", scale=4)
+            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)",
+                                 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).",
+                    elem_classes=["s2-footnote"])
+        with gr.Row():
+            detail_pick = gr.Dropdown(choices=[], label="Ticker", scale=2)
+            explain_btn = gr.Button("🌐 Explain in English (local LLM)", scale=1)
+        detail_box = gr.Textbox(lines=18, label="Ruling chain", elem_id="detail-log")
+        explain_box = gr.Markdown()
+
+    with gr.Tab("🔄 Sector Rotation"):
+        gr.Markdown("Capital rotation across the 11 SPDR sector ETFs (full S&P 500 coverage). "
+                    "**Flow proxy = price change % × dollar volume**; RS = return minus SPY. "
+                    "True per-sector fund-flow feeds are paid data — this is the standard free proxy.")
+        rot_btn = gr.Button("↻ Refresh rotation", variant="primary")
+        rot_asof = gr.Markdown("Press refresh (or Run analysis on the Signals tab).")
+        with gr.Row():
+            rot_1d = gr.Dataframe(label="1-Day (today's rotation)", interactive=False)
+        with gr.Row():
+            rot_5d = gr.Dataframe(label="5-Day (week trend)", interactive=False)
+            rot_20d = gr.Dataframe(label="20-Day (month trend)", interactive=False)
+        rot_ai = gr.Markdown(label="AI rotation narrative")
+
+    with gr.Tab("📰 Watchlist News"):
+        gr.Markdown("Daily rule: for each **holding**, only **today's** news is checked. "
+                    "News found → AI brief is pushed below. No news → the ticker is ignored "
+                    "(listed under *Quiet today*).")
+        with gr.Row():
+            hold_in = gr.Textbox(value=", ".join(news_watch.load_holdings()),
+                                 label="My holdings (comma separated)", scale=3)
+            save_btn = gr.Button("💾 Save holdings", scale=1)
+            news_btn = gr.Button("🔍 Check today's news", variant="primary", scale=1)
+        hold_status = gr.Markdown()
+        news_out = gr.Markdown()
+
+    with gr.Tab("🧪 Research (beta)"):
+        gr.Markdown("**Research Note (beta)** — first slice of Auto-Research: fundamentals + "
+                    "headlines from Yahoo → the local model writes a structured note: "
+                    "valuation · moat & supply-chain position · bull/bear case · risks. "
+                    "_V2 (planned): multi-step agent research and auto-report on every new ticker._")
+        with gr.Row():
+            res_in = gr.Textbox(label="Ticker", placeholder="e.g. NVDA", scale=3)
+            res_btn = gr.Button("📝 Generate research note", variant="primary", scale=1)
+        res_out = gr.Markdown()
+
+    with gr.Tab("⏰ Automation"):
+        auto_md = gr.Markdown(automation.schedule_info())
+        with gr.Row():
+            auto_now = gr.Button("⚡ Run now", variant="primary")
+            auto_refresh = gr.Button("↻ Refresh status")
+        auto_msg = gr.Markdown()
+        auto_log = gr.Textbox(lines=12, label="Pipeline log", elem_id="detail-log")
+
+    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.")
+        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")
+        model_status = gr.Markdown(llm_local.status())
+
+    gr.Markdown("Chan Compass · educational tool, not investment advice · "
+                "data: Yahoo Finance · design language: Adobe Spectrum 2",
+                elem_classes=["s2-footnote"])
+
+    # wiring
+    run_btn.click(ui_run_signals, [tickers_in, force_cb],
+                  [sig_table, sig_summary, detail_pick,
+                   rot_1d, rot_5d, rot_20d, rot_asof, rot_ai, news_out])
+    detail_pick.change(ui_show_detail, detail_pick, detail_box)
+    explain_btn.click(ui_explain_detail, detail_pick, explain_box)
+    rot_btn.click(ui_refresh_rotation, None, [rot_1d, rot_5d, rot_20d, rot_asof, rot_ai])
+    save_btn.click(ui_save_holdings, hold_in, hold_status)
+    news_btn.click(ui_check_news, None, news_out)
+    res_btn.click(ui_research, res_in, res_out)
+    auto_now.click(lambda: automation.run_pipeline(force=True), None, auto_msg)
+    auto_refresh.click(ui_automation_panel, None, [auto_md, auto_log])
+    load_btn.click(ui_load_model, model_pick, model_status)
+
+automation.start_scheduler()
+
+if __name__ == "__main__":
+    if _GR_MAJOR >= 6:
+        demo.launch(theme=theme, css=S2_CSS)
+    else:
+        demo.launch()

automation.py

@@ -0,0 +1,117 @@
+"""
+automation.py — daily auto-update pipeline.
+
+Chosen update time (requirement #2): **18:10 America/New_York**, Mon–Fri.
+Why: NYSE/Nasdaq close at 16:00 ET; the closing auction, after-hours prints
+and Yahoo's consolidated daily bar settle over the following ~1–2 hours.
+By 18:10 ET the official daily OHLCV is stable, so we always capture the
+finished trading day exactly once (= 07:10 next morning Beijing time).
+
+Pipeline per run:
+    1. refresh data for the signal pool + holdings + sector ETFs (yfinance)
+    2. re-run multi-level Chan signals  → cached for the Signals tab
+    3. rebuild the sector rotation tables
+    4. check today's news for every holding (push brief / ignore if quiet)
+
+NOTE for Hugging Face free Spaces: free hardware sleeps after ~48h without
+traffic, and a sleeping Space cannot fire its scheduler. Everything here also
+runs on demand via the "Run now" button; on paid "always-on" hardware the
+schedule fires unattended.
+"""
+from __future__ import annotations
+
+import datetime as dt
+import threading
+import traceback
+from zoneinfo import ZoneInfo
+
+NY = ZoneInfo("America/New_York")
+RUN_HOUR, RUN_MINUTE = 18, 10
+
+STATE = {
+    "signals_df": None,
+    "signals_details": {},
+    "signals_summary": "Not run yet — press “Run now” or wait for the 18:10 ET schedule.",
+    "rotation": (None, None, None, "—"),
+    "rotation_narrative": "",
+    "news_md": "",
+    "last_run": None,
+    "running": False,
+    "log": [],
+}
+_lock = threading.Lock()
+
+
+def _log(msg: str):
+    stamp = dt.datetime.now(NY).strftime("%m-%d %H:%M:%S ET")
+    STATE["log"] = (STATE["log"] + [f"[{stamp}] {msg}"])[-60:]
+
+
+def run_pipeline(tickers=None, force: bool = True) -> str:
+    """Full daily refresh. Safe to call from the UI or the scheduler."""
+    import news_watch
+    import rotation
+    import signal_runner
+
+    with _lock:
+        if STATE["running"]:
+            return "A pipeline run is already in progress."
+        STATE["running"] = True
+    try:
+        _log("Pipeline start: refreshing data + signals…")
+        df, details, summary, errors = signal_runner.run_signals(tickers, force=force)
+        STATE["signals_df"] = df
+        STATE["signals_details"] = details
+        STATE["signals_summary"] = summary
+        for e in errors:
+            _log(f"signal skip: {e}")
+        _log(f"Signals done: {summary}")
+
+        d1, d5, d20, asof = rotation.build_rotation(force=force)
+        STATE["rotation"] = (d1, d5, d20, asof)
+        try:
+            STATE["rotation_narrative"] = rotation.llm_narrative(d1, d5, d20)
+        except Exception as e:
+            STATE["rotation_narrative"] = f"(narrative failed: {e})"
+        _log(f"Sector rotation rebuilt (as of {asof}).")
+
+        STATE["news_md"] = news_watch.check_holdings_news()
+        _log("Holdings news checked.")
+
+        STATE["last_run"] = dt.datetime.now(NY)
+        _log("Pipeline finished.")
+        return f"Done. {summary}"
+    except Exception as e:
+        traceback.print_exc()
+        _log(f"Pipeline error: {e}")
+        return f"Pipeline error: {e}"
+    finally:
+        STATE["running"] = False
+
+
+def start_scheduler():
+    """Cron: Mon–Fri 18:10 America/New_York."""
+    try:
+        from apscheduler.schedulers.background import BackgroundScheduler
+        from apscheduler.triggers.cron import CronTrigger
+    except Exception as e:
+        _log(f"APScheduler unavailable: {e}")
+        return None
+    sched = BackgroundScheduler(timezone=NY)
+    sched.add_job(run_pipeline, CronTrigger(day_of_week="mon-fri",
+                                            hour=RUN_HOUR, minute=RUN_MINUTE),
+                  id="daily_pipeline", max_instances=1, coalesce=True)
+    sched.start()
+    _log(f"Scheduler armed: Mon–Fri {RUN_HOUR:02d}:{RUN_MINUTE:02d} America/New_York.")
+    return sched
+
+
+def schedule_info() -> str:
+    now = dt.datetime.now(NY)
+    last = STATE["last_run"].strftime("%Y-%m-%d %H:%M ET") if STATE["last_run"] else "never"
+    return (f"**Schedule:** Mon–Fri **{RUN_HOUR:02d}:{RUN_MINUTE:02d} America/New_York** "
+            f"(market closes 16:00 ET; by 18:10 the official daily bar has settled — "
+            f"that's 07:10 next morning Beijing time).\n\n"
+            f"**Now (ET):** {now.strftime('%Y-%m-%d %H:%M')} · **Last run:** {last}\n\n"
+            f"⚠️ On free Space hardware the app sleeps when idle and the timer can't fire; "
+            f"use **Run now**, or upgrade to always-on hardware for unattended updates.")

chan_engine.py

@@ -0,0 +1,1451 @@
+"""
+缠论引擎 v2.1 (原始版, 用于P0-P3改造的基线)
+"""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Optional
+import numpy as np
+import pandas as pd
+
+PIVOT_MAX_EXTEND_SEGS = 6
+
+
+@dataclass
+class Fractal:
+    idx: int
+    date: pd.Timestamp
+    kind: str
+    price: float
+    k_high: float
+    k_low: float
+
+
+@dataclass
+class Bi:
+    start: Fractal
+    end: Fractal
+    direction: str
+    bars: int
+    high: float
+    low: float
+    @property
+    def amplitude(self) -> float:
+        return self.high - self.low
+
+
+@dataclass
+class Seg:
+    start: Fractal
+    end: Fractal
+    direction: str
+    bis: list
+    high: float
+    low: float
+    confirmed: bool = True
+
+
+@dataclass
+class Pivot:
+    start_date: pd.Timestamp
+    end_date: pd.Timestamp
+    zg: float
+    zd: float
+    gg: float
+    dd: float
+    bis: list
+    direction: str
+    zg_date: Optional[pd.Timestamp] = None
+    zd_date: Optional[pd.Timestamp] = None
+    gg_date: Optional[pd.Timestamp] = None
+    dd_date: Optional[pd.Timestamp] = None
+    g: Optional[float] = None
+    d: Optional[float] = None
+    state: str = 'new'
+    death_combo: str = ''
+    capped: bool = False
+    upgraded_level: str = ''
+
+
+@dataclass
+class DivergenceGrade:
+    grade: str
+    area_ok: bool
+    dif_ok: bool
+    area_ratio: float
+    a_area: float
+    c_area: float
+    a_dif: float
+    c_dif: float
+    direction: str
+    reason: str
+    is_trend_divergence: bool = False
+    n_trend_pivots: int = 0
+
+
+@dataclass
+class Signal:
+    kind: str
+    date: pd.Timestamp
+    price: float
+    reason: str
+    pivot_zg: Optional[float] = None
+    pivot_zd: Optional[float] = None
+    macd_ratio: Optional[float] = None
+    dif_value: Optional[float] = None
+    n_pivots: int = 0
+    trend: str = ''
+    extras: dict = field(default_factory=dict)
+    diverge_grade: Optional[DivergenceGrade] = None
+
+
+def merge_klines(df: pd.DataFrame) -> pd.DataFrame:
+    if len(df) == 0:
+        return df.copy()
+    h = df['high'].values; l = df['low'].values; d = df['date'].values
+    out_h, out_l, out_d, out_idx = [h[0]], [l[0]], [d[0]], [0]
+    for i in range(1, len(df)):
+        ph, pl = out_h[-1], out_l[-1]; ch, cl = h[i], l[i]
+        direction = 1 if (len(out_h) >= 2 and out_h[-1] >= out_h[-2]) else (1 if len(out_h) < 2 else -1)
+        contained_a = ph >= ch and pl <= cl
+        contained_b = ch >= ph and cl <= pl
+        if contained_a or contained_b:
+            if direction >= 0:
+                out_h[-1] = max(ph, ch); out_l[-1] = max(pl, cl)
+            else:
+                out_h[-1] = min(ph, ch); out_l[-1] = min(pl, cl)
+            out_idx[-1] = i
+        else:
+            out_h.append(ch); out_l.append(cl); out_d.append(d[i]); out_idx.append(i)
+    return pd.DataFrame({'date': out_d, 'high': out_h, 'low': out_l, 'orig_idx': out_idx})
+
+
+def find_fractals(merged: pd.DataFrame) -> list:
+    res = []
+    n = len(merged)
+    if n < 3:
+        return res
+    h = merged['high'].values; l = merged['low'].values; d = merged['date'].values
+    hi = h[1:-1]; hp = h[:-2]; hn = h[2:]
+    li = l[1:-1]; lp = l[:-2]; ln = l[2:]
+    top = (hi > hp) & (hi > hn) & (li >= lp) & (li >= ln)
+    bot = (li < lp) & (li < ln) & (hi <= hp) & (hi <= hn)
+    idxs = np.nonzero(top | bot)[0]
+    if len(idxs) == 0:
+        return res
+    # 仅对被选中的(稀疏)分型点构造 Timestamp, 避免对全序列逐根转换
+    is_top = top  # 局部别名
+    for j in idxs:
+        i = j + 1
+        if is_top[j]:
+            res.append(Fractal(i, pd.Timestamp(d[i]), 'top', float(h[i]), float(h[i]), float(l[i])))
+        else:
+            res.append(Fractal(i, pd.Timestamp(d[i]), 'bottom', float(l[i]), float(h[i]), float(l[i])))
+    return res
+
+
+def find_bis(fractals: list, min_k: int = 4) -> list:
+    if len(fractals) < 2:
+        return []
+    cleaned = [fractals[0]]
+    for fx in fractals[1:]:
+        last = cleaned[-1]
+        if fx.kind == last.kind:
+            if fx.kind == 'top' and fx.price > last.price:
+                cleaned[-1] = fx
+            elif fx.kind == 'bottom' and fx.price < last.price:
+                cleaned[-1] = fx
+        else:
+            cleaned.append(fx)
+    alt = [cleaned[0]]
+    for fx in cleaned[1:]:
+        if fx.kind != alt[-1].kind and fx.idx - alt[-1].idx >= min_k - 1:
+            alt.append(fx)
+        elif fx.kind != alt[-1].kind:
+            continue
+    bis = []
+    for i in range(len(alt) - 1):
+        a, b = alt[i], alt[i+1]
+        if a.kind == b.kind:
+            continue
+        direction = 'up' if b.kind == 'top' else 'down'
+        bis.append(Bi(start=a, end=b, direction=direction, bars=b.idx - a.idx,
+                      high=max(a.price, b.price), low=min(a.price, b.price)))
+    return bis
+
+
+def _find_feature_fractal(std: list, seg_dir: str):
+    """[保留] 供调试/对照用的非增量实现; 主路径已改用 _first_feature_fractal_incremental。"""
+    up = (seg_dir == 'up')
+    for i in range(1, len(std) - 1):
+        a = std[i-1]; b = std[i]; c = std[i+1]
+        if up:
+            if b['high'] > a['high'] and b['high'] > c['high'] \
+               and b['low'] > a['low'] and b['low'] > c['low']:
+                return (i, b.get('has_gap_before', False))
+        else:
+            if b['low'] < a['low'] and b['low'] < c['low'] \
+               and b['high'] < a['high'] and b['high'] < c['high']:
+                return (i, b.get('has_gap_before', False))
+    return None
+
+
+def _first_feature_fractal_incremental(bis, start_i, end_i, seg_dir):
+    """增量构建特征序列, 在第一个特征分型被"锁定"时立即返回。
+
+    锁定条件: 出现特征分型(a,b,c)后, 再追加一个新的标准元素(即 c 之后
+    已有一个不被包含的元素 d)。此时 c 不会再被向后合并改变, 分型 b 的
+    左右高低关系已固定, 与"先把整段展开再找首个分型"语义等价。
+    返回 (b_first_bi_idx, b_has_gap_before) 或 None。
+    """
+    feat_dir = 'down' if seg_dir == 'up' else 'up'
+    up = (seg_dir == 'up')
+    std = []  # 每元素: [high, low, bi_idx, has_gap_before, first_bi_idx]
+    for k in range(start_i, end_i + 1):
+        b = bis[k]
+        if b.direction != feat_dir:
+            continue
+        ch = b.high; cl = b.low
+        if not std:
+            std.append([ch, cl, k, False, k]); continue
+        prev = std[-1]
+        ph = prev[0]; pl = prev[1]
+        contained = (ph >= ch and pl <= cl) or (ch >= ph and cl <= pl)
+        if contained:
+            if up:
+                prev[0] = ph if ph > ch else ch
+                prev[1] = pl if pl > cl else cl
+            else:
+                prev[0] = ph if ph < ch else ch
+                prev[1] = pl if pl < cl else cl
+            prev[2] = k
+            continue
+        std.append([ch, cl, k, gap_flag(cl, ch, ph, pl)] + [k])
+        # 锁定检查: 需要至少4个已定型元素, 才能保证倒数第3个(候选分型b)
+        # 的右邻c已被其后元素d终结、不会再被向后合并。
+        if len(std) >= 4:
+            a = std[-4]; bm = std[-3]; c = std[-2]
+            if up:
+                ok = (bm[0] > a[0] and bm[0] > c[0] and bm[1] > a[1] and bm[1] > c[1])
+            else:
+                ok = (bm[1] < a[1] and bm[1] < c[1] and bm[0] < a[0] and bm[0] < c[0])
+            if ok:
+                return (bm[4], bm[3])
+    # 收尾: 末端无后继元素, 用最终 std 找首个内部分型(与原实现等价)
+    for i in range(1, len(std) - 1):
+        a = std[i-1]; bm = std[i]; c = std[i+1]
+        if up:
+            ok = (bm[0] > a[0] and bm[0] > c[0] and bm[1] > a[1] and bm[1] > c[1])
+        else:
+            ok = (bm[1] < a[1] and bm[1] < c[1] and bm[0] < a[0] and bm[0] < c[0])
+        if ok:
+            return (bm[4], bm[3])
+    return None
+
+
+def gap_flag(cl, ch, ph, pl):
+    return (cl > ph) or (ch < pl)
+
+
+def _seq_fractal_confirms_reversal(bis, start_i, end_i, cur_dir):
+    fr = _first_feature_fractal_incremental(bis, start_i, end_i, cur_dir)
+    if fr is None:
+        return (False, None)
+    feat_first_bi, has_gap = fr
+    seg_end_bi = feat_first_bi - 1
+    if seg_end_bi <= start_i:
+        return (False, None)
+    if has_gap:
+        opp = 'down' if cur_dir == 'up' else 'up'
+        fr2 = _first_feature_fractal_incremental(bis, feat_first_bi, end_i, opp)
+        if fr2 is None:
+            return (False, None)
+    return (True, seg_end_bi)
+
+
+def find_segs(bis: list) -> list:
+    n = len(bis)
+    if n < 3:
+        return []
+    base = bis[0].start.price
+    look = min(3, n)
+    net = bis[look - 1].end.price - base
+    cur_dir = 'up' if net > 0 else 'down'
+    segs = []
+    i = 0
+    while i < n - 2:
+        confirmed, seg_end_bi = _seq_fractal_confirms_reversal(bis, i, n - 1, cur_dir)
+        if confirmed and seg_end_bi > i:
+            seg_bis = bis[i:seg_end_bi + 1]
+            net_up = seg_bis[-1].end.price > seg_bis[0].start.price
+            if (cur_dir == 'up') == net_up:
+                segs.append(Seg(start=bis[i].start, end=seg_bis[-1].end, direction=cur_dir,
+                                bis=seg_bis, high=max(b.high for b in seg_bis),
+                                low=min(b.low for b in seg_bis), confirmed=True))
+                i = seg_end_bi + 1
+                cur_dir = 'down' if cur_dir == 'up' else 'up'
+                continue
+        alt = 'down' if cur_dir == 'up' else 'up'
+        confirmed2, seg_end_bi2 = _seq_fractal_confirms_reversal(bis, i, n - 1, alt)
+        if confirmed2 and seg_end_bi2 > i:
+            seg_bis = bis[i:seg_end_bi2 + 1]
+            net_up = seg_bis[-1].end.price > seg_bis[0].start.price
+            if (alt == 'up') == net_up:
+                segs.append(Seg(start=seg_bis[0].start, end=seg_bis[-1].end, direction=alt,
+                                bis=seg_bis, high=max(b.high for b in seg_bis),
+                                low=min(b.low for b in seg_bis), confirmed=True))
+                i = seg_end_bi2 + 1
+                cur_dir = 'down' if alt == 'up' else 'up'
+                continue
+        break
+    if i < n - 1 and (n - i) >= 1:
+        seg_bis = bis[i:]
+        if len(seg_bis) >= 1:
+            net_up = seg_bis[-1].end.price > seg_bis[0].start.price
+            d = 'up' if net_up else 'down'
+            segs.append(Seg(start=seg_bis[0].start, end=seg_bis[-1].end, direction=d,
+                            bis=seg_bis, high=max(b.high for b in seg_bis),
+                            low=min(b.low for b in seg_bis), confirmed=False))
+    return segs
+
+
+PIVOT_UPGRADE_SPAN_DAYS = 540
+
+
+def find_pivots(bis: list, segs: Optional[list] = None) -> list:
+    confirmed_segs = [s for s in (segs or []) if getattr(s, 'confirmed', True)]
+    units = confirmed_segs if len(confirmed_segs) >= 3 else bis
+    using_segs = units is confirmed_segs
+    pivots = []; n = len(units)
+    if n < 3:
+        return pivots
+
+    bi_pos = {id(b): k for k, b in enumerate(bis)}
+
+    def _unit_bi_range(u):
+        if hasattr(u, 'bis'):
+            idxs = [bi_pos[id(b)] for b in u.bis if id(b) in bi_pos]
+            return (min(idxs), max(idxs)) if idxs else (0, 0)
+        k = bi_pos.get(id(u), 0)
+        return (k, k)
+
+    def _unit_bi_indices(unit_list):
+        out = []
+        for u in unit_list:
+            a, b = _unit_bi_range(u)
+            out.extend(range(a, b + 1))
+        return sorted(set(out))
+
+    def _unit_high_date(u):
+        return u.start.date if u.start.price >= u.end.price else u.end.date
+
+    def _unit_low_date(u):
+        return u.start.date if u.start.price <= u.end.price else u.end.date
+
+    max_ext = PIVOT_MAX_EXTEND_SEGS if PIVOT_MAX_EXTEND_SEGS else 10 ** 9
+
+    i = 0
+    while i <= n - 3:
+        b1, b2, b3 = units[i], units[i+1], units[i+2]
+        r1 = (b1.low, b1.high)
+        r2 = (b2.low, b2.high)
+        r3 = (b3.low, b3.high)
+        zg = min(r1[1], r2[1], r3[1]); zd = max(r1[0], r2[0], r3[0])
+        if zg > zd:
+            direction = b1.direction; zg_orig, zd_orig = zg, zd; gg, dd = zg, zd
+            highs = [r1[1], r2[1], r3[1]]; lows = [r1[0], r2[0], r3[0]]
+            zg_bi = (b1, b2, b3)[highs.index(zg_orig)]
+            zd_bi = (b1, b2, b3)[lows.index(zd_orig)]
+            zg_d = _unit_high_date(zg_bi)
+            zd_d = _unit_low_date(zd_bi)
+            gg_d, dd_d = zg_d, zd_d
+            zn_dir = direction
+            gn_list = []; dn_list = []
+            for bb in (b1, b2, b3):
+                if bb.direction == zn_dir:
+                    gn_list.append(max(bb.start.price, bb.end.price))
+                    dn_list.append(min(bb.start.price, bb.end.price))
+            piv_units = [i, i+1, i+2]; j = i + 3
+            capped = False
+            while j < n:
+                if (len(piv_units) - 3) >= max_ext:
+                    capped = True
+                    break
+                bj = units[j]; lo_j = bj.low; hi_j = bj.high
+                if hi_j >= zd_orig and lo_j <= zg_orig:
+                    if hi_j > gg:
+                        gg = hi_j; gg_d = _unit_high_date(bj)
+                    if lo_j < dd:
+                        dd = lo_j; dd_d = _unit_low_date(bj)
+                    if bj.direction == zn_dir:
+                        gn_list.append(hi_j); dn_list.append(lo_j)
+                    piv_units.append(j); j += 1
+                else:
+                    break
+            g_val = min(gn_list) if gn_list else zg_orig
+            d_val = max(dn_list) if dn_list else zd_orig
+            piv_bis = _unit_bi_indices([units[k] for k in piv_units]) if using_segs else piv_units
+            p_start = b1.start.date
+            p_end = units[piv_units[-1]].end.date
+            piv = Pivot(start_date=p_start, end_date=p_end,
+                        zg=zg_orig, zd=zd_orig, gg=gg, dd=dd, bis=piv_bis, direction=direction,
+                        zg_date=zg_d, zd_date=zd_d, gg_date=gg_d, dd_date=dd_d,
+                        g=g_val, d=d_val, capped=capped)
+            try:
+                span_days = (pd.Timestamp(p_end) - pd.Timestamp(p_start)).days
+            except Exception:
+                span_days = 0
+            if capped or span_days > PIVOT_UPGRADE_SPAN_DAYS:
+                piv.upgraded_level = 'weekly'
+            pivots.append(piv)
+            i = piv_units[-1] + 1
+        else:
+            i += 1
+
+    for k in range(1, len(pivots)):
+        prev, cur = pivots[k-1], pivots[k]
+        no_overlap = (cur.dd > prev.gg) or (cur.gg < prev.dd)
+        if no_overlap:
+            cur.state = 'new'
+        else:
+            cur.state = 'expand'
+
+    for k in range(len(pivots) - 1):
+        cur = pivots[k]
+        nxt = pivots[k + 1]
+        gap_start = cur.bis[-1] + 1
+        gap_end = nxt.bis[0]
+        gap_bis = bis[gap_start:gap_end] if gap_end > gap_start else []
+        if len(gap_bis) >= 2:
+            leave = gap_bis[:max(1, len(gap_bis) // 2)]
+            pull = gap_bis[max(1, len(gap_bis) // 2):]
+            leave_trend = len(leave) >= 3
+            pull_trend = len(pull) >= 3
+            if leave_trend and not pull_trend:
+                cur.death_combo = 'trend+consol'
+            elif leave_trend and pull_trend:
+                cur.death_combo = 'trend+counter'
+            else:
+                cur.death_combo = 'consol+counter'
+    return pivots
+
+
+def classify_trend(pivots: list) -> str:
+    if len(pivots) < 2:
+        return 'consolidation'
+    p1, p2 = pivots[-2], pivots[-1]
+    if p2.dd > p1.gg:
+        return 'up_trend'
+    if p2.gg < p1.dd:
+        return 'down_trend'
+    if (p2.zg < p1.zd and p2.gg >= p1.dd) or (p2.zd > p1.zg and p2.dd <= p1.gg):
+        return 'expanding'
+    return 'consolidation'
+
+
+def count_trend_pivots(pivots: list) -> int:
+    if not pivots:
+        return 0
+    if len(pivots) == 1:
+        return 1
+    cnt = 1
+    for k in range(len(pivots) - 1, 0, -1):
+        p_prev, p_cur = pivots[k - 1], pivots[k]
+        if p_cur.dd > p_prev.gg:
+            cnt += 1
+        elif p_cur.gg < p_prev.dd:
+            cnt += 1
+        else:
+            break
+    return cnt
+
+
+def calc_macd(close: pd.Series, fast=12, slow=26, signal=9):
+    ema_fast = close.ewm(span=fast, adjust=False).mean()
+    ema_slow = close.ewm(span=slow, adjust=False).mean()
+    dif = ema_fast - ema_slow
+    dea = dif.ewm(span=signal, adjust=False).mean()
+    macd_bar = 2 * (dif - dea)
+    return dif, dea, macd_bar
+
+
+def macd_area_between(start_date, end_date, bar_series, date_series, direction):
+    mask = (date_series >= start_date) & (date_series <= end_date)
+    vals = bar_series[mask]
+    if len(vals) == 0:
+        return 0.0
+    if direction == 'up':
+        return float(vals.clip(lower=0).sum())
+    return float(vals.clip(upper=0).abs().sum())
+
+
+def dif_extreme_in(start_date, end_date, dif_series, date_series, kind='peak'):
+    mask = (date_series >= start_date) & (date_series <= end_date)
+    vals = dif_series[mask]
+    if len(vals) == 0:
+        return 0.0
+    return float(vals.max()) if kind == 'peak' else float(vals.min())
+
+
+class ChanAnalyzer:
+    DIVERGE_RATIO = 0.80
+    PIVOT_TOLERANCE = 0.02
+    MIN_BI_BARS = 4
+    DIF_TOLERANCE = 0.01
+
+    CFG = {
+        'b1_allow_consol_diverge': True,
+        'b3s3_first_pullback_only': False,
+        'b2s2_anchor_to_first': False,
+        'b2_macd_zero_pullback': False,
+        'drop_upgraded_pivots': False,
+        # L88-90 中阴阶段MACD精确运用: 中阴判定除BOLL收口外, 加入MACD特征
+        #   'off'  = 维持原判定(仅BOLL收口+末笔未离开中枢)
+        #   'and'  = 须同时满足"黄白线绕0轴缠绕"(更严格, 减少误判中阴而拦截的好买点)
+        #   'or'   = 满足其一即算中阴(更宽松, 拦截更多)
+        'zhongyin_macd_mode': 'or',   # 实测'or'最优: 累计收益+35pp(383%→418%), 胜率45.3%→46.8%
+    }
+
+    def __init__(self, df: pd.DataFrame):
+        self.df_raw = df.reset_index(drop=True)
+        self.close = self.df_raw['close']
+        self.dif, self.dea, self.macd_bar = calc_macd(self.close)
+        self.merged = merge_klines(self.df_raw)
+        self.fractals = find_fractals(self.merged)
+        self.bis = find_bis(self.fractals, min_k=self.MIN_BI_BARS)
+        self._bi_index = {id(b): k for k, b in enumerate(self.bis)}
+        self.segs = find_segs(self.bis)
+        self.pivots_all = find_pivots(self.bis, self.segs)
+        if self.CFG.get('drop_upgraded_pivots'):
+            last_upg_idx = -1
+            for k, p in enumerate(self.pivots_all):
+                if p.upgraded_level:
+                    last_upg_idx = k
+            operative = [p for k, p in enumerate(self.pivots_all)
+                         if k > last_upg_idx and not p.upgraded_level]
+            self.pivots = operative
+        else:
+            self.pivots = self.pivots_all
+        self.trend = classify_trend(self.pivots)
+
+    @property
+    def n_bis(self): return len(self.bis)
+    @property
+    def n_segs(self): return len(self.segs)
+    @property
+    def n_pivots(self): return len(self.pivots)
+    @property
+    def n_pivots_all(self): return len(self.pivots_all)
+    @property
+    def n_trend_pivots(self): return count_trend_pivots(self.pivots)
+    @property
+    def has_upgraded_pivot(self):
+        return any(p.upgraded_level for p in self.pivots_all)
+
+    @staticmethod
+    def _ds(ts):
+        ts = pd.Timestamp(ts)
+        if ts.hour == 0 and ts.minute == 0:
+            return ts.strftime('%Y-%m-%d')
+        return ts.strftime('%Y-%m-%d %H:%M')
+
+    def _validate_abc(self, direction: str):
+        if self.n_pivots < 2:
+            return None
+        last_piv = self.pivots[-1]
+        prev_piv = self.pivots[-2]
+        ratio = len(prev_piv.bis) / max(len(last_piv.bis), 1)
+        if not (1 / 3 <= ratio <= 3):
+            return None
+        a_start_idx = prev_piv.bis[0]
+        a_end_idx = last_piv.bis[0]
+        if a_end_idx <= a_start_idx:
+            return None
+        c_start_idx = last_piv.bis[-1] + 1
+        if c_start_idx >= self.n_bis:
+            return None
+        return {'a_start_idx': a_start_idx, 'a_end_idx': a_end_idx,
+                'b_pivot': last_piv, 'c_start_idx': c_start_idx}
+
+    def _validate_abc_consol(self, direction: str):
+        if self.n_pivots < 1:
+            return None
+        piv = self.pivots[-1]
+        a_end_idx = piv.bis[0]
+        if a_end_idx <= 0:
+            return None
+        c_start_idx = piv.bis[-1] + 1
+        if c_start_idx >= self.n_bis:
+            return None
+        want = 'down' if direction == 'down' else 'up'
+        a_start_idx = a_end_idx
+        for k in range(a_end_idx - 1, -1, -1):
+            a_start_idx = k
+            if k >= 1 and self.bis[k].direction != want and self.bis[k-1].direction != want:
+                a_start_idx = k + 1
+                break
+        if a_start_idx >= a_end_idx:
+            return None
+        return {'a_start_idx': a_start_idx, 'a_end_idx': a_end_idx,
+                'b_pivot': piv, 'c_start_idx': c_start_idx}
+
+    def _check_c_new_extreme(self, c_start_idx: int, direction: str):
+        want = 'up' if direction == 'up' else 'down'
+        c_bis = [self.bis[k] for k in range(c_start_idx, self.n_bis)
+                 if self.bis[k].direction == want]
+        if not c_bis:
+            return False, None
+        last_piv = self.pivots[-1] if self.pivots else None
+        if direction == 'up':
+            c_ext = max(b.end.price for b in c_bis)
+            prior = (last_piv.gg if last_piv is not None
+                     else max((b.high for b in self.bis[:c_start_idx]), default=0.0))
+            return c_ext > prior * (1 - 0.001), c_ext
+        else:
+            c_ext = min(b.end.price for b in c_bis)
+            prior = (last_piv.dd if last_piv is not None
+                     else min((b.low for b in self.bis[:c_start_idx]), default=1e18))
+            return c_ext < prior * (1 + 0.001), c_ext
+
+    def _b_returns_to_zero(self, pivot) -> bool:
+        dates = self.df_raw['date']
+        mask = (dates >= pivot.start_date) & (dates <= pivot.end_date)
+        dif_b = self.dif[mask]
+        dea_b = self.dea[mask]
+        if len(dif_b) == 0 or len(dea_b) == 0:
+            return False
+        def near_zero(x):
+            if x.min() <= 0 <= x.max():
+                return True
+            return x.abs().min() < max(float(x.abs().max()), 1e-9) * 0.25
+        return near_zero(dif_b) and near_zero(dea_b)
+
+    def detect_double_pullback_to_zero(self, window: int = 40) -> bool:
+        n = len(self.dif)
+        if n < 10:
+            return False
+        dif = self.dif.iloc[-min(window, n):].reset_index(drop=True)
+        dea = self.dea.iloc[-min(window, n):].reset_index(drop=True)
+        hist = self.macd_bar.iloc[-min(window, n):].reset_index(drop=True)
+        scale = max(float(dif.abs().max()), float(dea.abs().max()), 1e-9)
+        near = scale * 0.25
+        zero_pulls = [i for i in range(len(dif))
+                      if abs(float(dif.iloc[i])) <= near and abs(float(dea.iloc[i])) <= near]
+        if len(zero_pulls) < 2:
+            return False
+        def peak_between(left, right):
+            vals = dif.iloc[left + 1:right]
+            if len(vals) < 2:
+                return None
+            rel = int(vals.idxmax())
+            return float(dif.iloc[rel]), float(hist.iloc[max(left + 1, rel - 3):rel + 1].clip(lower=0).sum())
+        def trough_between(left, right):
+            vals = dif.iloc[left + 1:right]
+            if len(vals) < 2:
+                return None
+            rel = int(vals.idxmin())
+            return float(dif.iloc[rel]), float(hist.iloc[max(left + 1, rel - 3):rel + 1].clip(upper=0).abs().sum())
+        first_pull, second_pull = zero_pulls[-2], zero_pulls[-1]
+        p1, p2 = peak_between(first_pull, second_pull), peak_between(second_pull, len(dif))
+        if p1 and p2 and p1[0] > 0 and p2[0] > 0 and p2[0] < p1[0] and p2[1] <= p1[1]:
+            return True
+        t1, t2 = trough_between(first_pull, second_pull), trough_between(second_pull, len(dif))
+        if t1 and t2 and t1[0] < 0 and t2[0] < 0 and t2[0] > t1[0] and t2[1] <= t1[1]:
+            return True
+        return False
+
+    def divergence_strength_by_position(self) -> str:
+        if len(self.dif) < 5:
+            return 'strong_pullback'
+        dif_now = float(self.dif.iloc[-1])
+        dif_abs_max = float(self.dif.abs().max())
+        if dif_abs_max <= 1e-9:
+            return 'strong_pullback'
+        if abs(dif_now) >= dif_abs_max * 0.85:
+            return 'weak_pullback'
+        return 'strong_pullback'
+
+    def classify_post_divergence(self, direction: str) -> dict:
+        if not self.pivots or self.n_bis < 2:
+            return {'evolution': 'unknown', 'reason': '无中枢或笔不足'}
+        last_piv = self.pivots[-1]
+        after_idx = last_piv.bis[-1] + 1
+        def first_reversal_seg(want_dir):
+            for s in self.segs:
+                if not getattr(s, 'confirmed', True) or s.direction != want_dir:
+                    continue
+                try:
+                    first_idx = self._bi_index[id(s.bis[0])]
+                except KeyError:
+                    continue
+                if first_idx >= after_idx:
+                    return s
+            return None
+        if direction == 'down':
+            rebound = first_reversal_seg('up')
+            if rebound is None:
+                rebound = None
+                for b in self.bis[after_idx:]:
+                    if b.direction == 'up':
+                        rebound = b; break
+            if rebound is None:
+                return {'evolution': 'unknown', 'reason': '无反弹笔'}
+            if rebound.high < last_piv.zd:
+                return {'evolution': 'case1_extend',
+                        'reason': f'反弹高{rebound.high:.3f}<最后中枢ZD{last_piv.zd:.3f} → 第29课情况①未回中枢(最弱,宜尽快撤)'}
+            if rebound.high >= last_piv.zd:
+                return {'evolution': 'case2_3_turn',
+                        'reason': f'反弹回到中枢(高{rebound.high:.3f}≥ZD{last_piv.zd:.3f}) → 第29课情况②③转折(可持有等三买)'}
+            return {'evolution': 'case1_extend',
+                    'reason': f'反弹未回中枢(高{rebound.high:.3f}<ZD{last_piv.zd:.3f}) → 偏向中枢扩展'}
+        else:
+            pullback = first_reversal_seg('down')
+            if pullback is None:
+                pullback = None
+                for b in self.bis[after_idx:]:
+                    if b.direction == 'down':
+                        pullback = b; break
+            if pullback is None:
+                return {'evolution': 'unknown', 'reason': '无回落笔'}
+            if pullback.low > last_piv.zg:
+                return {'evolution': 'case1_extend',
+                        'reason': f'回落低{pullback.low:.3f}>最后中枢ZG{last_piv.zg:.3f} → 第29课情况①未回中枢(最弱)'}
+            if pullback.low <= last_piv.zg:
+                return {'evolution': 'case2_3_turn',
+                        'reason': f'回落回到中枢(低{pullback.low:.3f}≤ZG{last_piv.zg:.3f}) → 第29课情况②③转折'}
+            return {'evolution': 'case1_extend',
+                    'reason': f'回落未回中枢 → 偏向中枢扩展'}
+
+    def macd_wrap_zero(self, window: int = 15) -> bool:
+        """L88-90: 中阴阶段的MACD特征 —— 黄白线(DIF/DEA)绕0轴缠绕。
+        近window根K线中, DIF与DEA的绝对值大多压在历史摆幅的25%以内即视为缠绕。"""
+        n = len(self.dif)
+        if n < window + 5:
+            return False
+        dif = self.dif.iloc[-window:]
+        dea = self.dea.iloc[-window:]
+        scale = max(float(self.dif.abs().tail(120).max()),
+                    float(self.dea.abs().tail(120).max()), 1e-9)
+        near = scale * 0.25
+        frac = float(((dif.abs() <= near) & (dea.abs() <= near)).mean())
+        return frac >= 0.6
+
+    def macd_clarity(self, window: int = 60) -> dict:
+        """L50: 本级别MACD的"清晰度" —— 柱子面积幅度 + 黄白线分离度, 归一化打分。
+        清晰度高的级别其背驰判定更可靠; 多级别联立时应优先采信清晰级别的MACD结论。"""
+        n = len(self.dif)
+        if n < 10:
+            return {'score': 0.0, 'label': '数据不足'}
+        w = min(window, n)
+        dif = self.dif.iloc[-w:]
+        dea = self.dea.iloc[-w:]
+        hist = self.macd_bar.iloc[-w:]
+        px = max(float(self.close.iloc[-1]), 1e-9)
+        bar_amp = float(hist.abs().mean()) / px          # 柱子相对幅度
+        sep     = float((dif - dea).abs().mean()) / px   # 黄白线分离度
+        # 黄白线贴着0轴乱绕 → 不清晰
+        wrap_penalty = 0.5 if self.macd_wrap_zero() else 1.0
+        score = (bar_amp * 0.6 + sep * 0.4) * 1e3 * wrap_penalty
+        label = '清晰' if score >= 1.0 else ('一般' if score >= 0.4 else '模糊(黄白线/柱子贴0轴)')
+        return {'score': round(score, 3), 'label': label,
+                'bar_amp': round(bar_amp * 1e3, 3), 'sep': round(sep * 1e3, 3)}
+
+    def in_zhongyin(self) -> dict:
+        n = len(self.close)
+        if n < 20 or not self.pivots:
+            return {'in_zhongyin': False, 'boll_squeeze': False, 'reason': '数据不足'}
+        ma = self.close.rolling(20).mean()
+        sd = self.close.rolling(20).std()
+        if ma.iloc[-1] and ma.iloc[-1] > 0:
+            width = float((4 * sd.iloc[-1]) / ma.iloc[-1])
+        else:
+            width = 0.0
+        wseries = (4 * sd / ma).dropna().tail(60)
+        squeeze = bool(len(wseries) >= 20 and width <= wseries.quantile(0.30))
+        osc = self.zhongshu_oscillation_monitor()
+        macd_wrap = self.macd_wrap_zero()
+        dbl_pull = self.detect_double_pullback_to_zero()
+        mode = self.CFG.get('zhongyin_macd_mode', 'off')
+        if mode == 'and':
+            in_zy = (not osc.get('alert', False)) and squeeze and macd_wrap
+        elif mode == 'or':
+            in_zy = (not osc.get('alert', False)) and (squeeze or macd_wrap)
+        else:
+            in_zy = (not osc.get('alert', False)) and squeeze
+        reason = (f"BOLL带宽{width:.3f}{'(收口→中阴)' if squeeze else '(开口)'}; "
+                  f"MACD黄白线{'绕0轴缠绕(L88-90中阴特征)' if macd_wrap else '已展开'}"
+                  f"{'; 双回拉0轴(L89: 中阴结束转折预备)' if dbl_pull else ''}; {osc.get('reason','')}")
+        return {'in_zhongyin': in_zy, 'boll_squeeze': squeeze,
+                'macd_wrap_zero': macd_wrap, 'double_pullback_zero': dbl_pull,
+                'reason': reason}
+
+    def zhongshu_oscillation_monitor(self) -> dict:
+        if not self.pivots or self.n_bis < 1:
+            return {'alert': False, 'direction': '', 'reason': '无中枢'}
+        last_piv = self.pivots[-1]
+        cur = self.bis[-1]
+        if cur.low > last_piv.zg:
+            return {'alert': True, 'direction': 'up',
+                    'reason': f'第92课: 末笔({cur.low:.3f}~{cur.high:.3f})已离开中枢上沿ZG{last_piv.zg:.3f} → 向上变盘预警'}
+        if cur.high < last_piv.zd:
+            return {'alert': True, 'direction': 'down',
+                    'reason': f'第92课: 末笔({cur.low:.3f}~{cur.high:.3f})已离开中枢下沿ZD{last_piv.zd:.3f} → 向下变盘预警'}
+        return {'alert': False, 'direction': '', 'reason': '末笔仍在中枢区间内, 中枢震荡延续'}
+
+    def bottom_construction_state(self) -> str:
+        has_b1 = self.detect_b1() is not None
+        has_b3 = self.detect_b3() is not None
+        has_s3 = self.detect_s3() is not None
+        if has_s3:
+            return 'failed'
+        if has_b3:
+            return 'completed'
+        if has_b1:
+            return 'constructing'
+        return 'none'
+
+    def _seg_index_range(self, seg):
+        m = self._bi_index
+        try:
+            return m[id(seg.bis[0])], m[id(seg.bis[-1])]
+        except KeyError:
+            return None
+
+    def _bi_exit_pullback_fallback(self, pivot, exit_dir: str, pull_dir: str):
+        pe = pivot.bis[-1]
+        leave = pull = None
+        for k in range(pe + 1, self.n_bis):
+            b = self.bis[k]
+            if leave is None:
+                if b.direction == exit_dir:
+                    leave = b
+                continue
+            if b.direction == pull_dir:
+                pull = b
+                break
+        if leave is None or pull is None:
+            return None
+        return leave, pull
+
+    def _last_exit_pullback_segments(self, pivot, exit_dir: str, pull_dir: str):
+        pivot_end = pivot.bis[-1]
+        seq = []
+        for s in (self.segs or []):
+            if not getattr(s, 'confirmed', True):
+                continue
+            rng = self._seg_index_range(s)
+            if rng is None:
+                continue
+            first_idx, last_idx = rng
+            if last_idx < pivot_end:
+                continue
+            seq.append((s, first_idx, last_idx))
+        first_only = self.CFG.get('b3s3_first_pullback_only')
+        if first_only:
+            for i in range(len(seq) - 1):
+                leave, lf, _ = seq[i]
+                pull = seq[i + 1][0]
+                if leave.direction == exit_dir and pull.direction == pull_dir and lf >= pivot_end:
+                    return leave, pull
+        else:
+            for i in range(len(seq) - 1, 0, -1):
+                pull, _, _ = seq[i]
+                leave, _, _ = seq[i - 1]
+                if leave.direction == exit_dir and pull.direction == pull_dir:
+                    return leave, pull
+        return self._bi_exit_pullback_fallback(pivot, exit_dir, pull_dir)
+
+    def assess_divergence(self, a_start, a_end, c_start, c_end, direction: str) -> DivergenceGrade:
+        dates = self.df_raw['date']
+        n_tp = self.n_trend_pivots
+        is_trend_div = n_tp >= 2
+        a_area = macd_area_between(a_start, a_end, self.macd_bar, dates, direction)
+        c_area = macd_area_between(c_start, c_end, self.macd_bar, dates, direction)
+        if a_area <= 1e-9:
+            return DivergenceGrade('NONE', False, False, 0.0, a_area, c_area, 0.0, 0.0,
+                                   direction, 'A段MACD面积为0,无可比基准',
+                                   is_trend_divergence=is_trend_div, n_trend_pivots=n_tp)
+        ratio = c_area / a_area
+        area_ok = ratio < self.DIVERGE_RATIO
+        TOL = self.DIF_TOLERANCE
+        if direction == 'up':
+            a_dif = dif_extreme_in(a_start, a_end, self.dif, dates, 'peak')
+            c_dif = dif_extreme_in(c_start, c_end, self.dif, dates, 'peak')
+            dif_ok = c_dif < a_dif * (1 - TOL)
+        else:
+            a_dif = dif_extreme_in(a_start, a_end, self.dif, dates, 'trough')
+            c_dif = dif_extreme_in(c_start, c_end, self.dif, dates, 'trough')
+            dif_ok = c_dif > a_dif * (1 - TOL)
+        ext_label = 'DIF峰' if direction == 'up' else 'DIF谷'
+        div_kind = '趋势背驰' if is_trend_div else '盘整背驰'
+        if area_ok and dif_ok:
+            grade = 'STRONG'
+            reason = f'���准{div_kind}(面积+DIF均满足)|A面积:{a_area:.4f} C面积:{c_area:.4f}(比值{ratio:.1%}<{self.DIVERGE_RATIO:.0%})|{ext_label} A:{a_dif:.4f} C:{c_dif:.4f}|{n_tp}中枢'
+        elif area_ok and not dif_ok:
+            grade = 'WEAK'
+            reason = f'{div_kind}信号(面积触发)|A面积:{a_area:.4f} C面积:{c_area:.4f}(比值{ratio:.1%}<{self.DIVERGE_RATIO:.0%})|{n_tp}中枢'
+        elif dif_ok and not area_ok:
+            grade = 'WEAK'
+            reason = f'{div_kind}信号(DIF触发)|{ext_label} A:{a_dif:.4f} C:{c_dif:.4f}|{n_tp}中枢'
+        else:
+            grade = 'NONE'
+            reason = f'无背驰(两判据均不满足)|面积比{ratio:.1%}>={self.DIVERGE_RATIO:.0%}|{ext_label} A:{a_dif:.4f} C:{c_dif:.4f}'
+        return DivergenceGrade(grade, area_ok, dif_ok, ratio, a_area, c_area, a_dif, c_dif,
+                               direction, reason, is_trend_divergence=is_trend_div, n_trend_pivots=n_tp)
+
+    def _find_prev_b1(self) -> tuple:
+        if not self.pivots:
+            return (None, '')
+        last_piv = self.pivots[-1]
+        pivot_first_bi_idx = last_piv.bis[0]
+        if pivot_first_bi_idx <= 0:
+            return (None, '')
+        downs = []
+        for k in range(pivot_first_bi_idx - 1, -1, -1):
+            b = self.bis[k]
+            downs.append(b)
+            if b.direction == 'up' and k - 1 >= 0 and self.bis[k-1].direction == 'down':
+                if len(downs) >= 4:
+                    break
+        down_bis = [b for b in downs if b.direction == 'down']
+        if not down_bis:
+            return (None, '')
+        b1 = min(down_bis, key=lambda b: b.end.price)
+        return (b1.end.price, self._ds(b1.end.date))
+
+    def _find_prev_b2(self) -> tuple:
+        b1_price, b1_date_str = self._find_prev_b1()
+        if b1_price is None or not self.pivots:
+            return (None, '')
+        b1_date = pd.Timestamp(b1_date_str)
+        last_piv = self.pivots[-1]
+        right_bi_idx = last_piv.bis[-1] + 1
+        for b in self.bis[:right_bi_idx]:
+            if b.direction != 'down':
+                continue
+            if b.end.date <= b1_date:
+                continue
+            if b.end.price > b1_price + 1e-9:
+                return (b.end.price, self._ds(b.end.date))
+        return (None, '')
+
+    def _find_prev_s1(self) -> tuple:
+        if not self.pivots:
+            return (None, '')
+        last_piv = self.pivots[-1]
+        pivot_first_bi_idx = last_piv.bis[0]
+        if pivot_first_bi_idx <= 0:
+            return (None, '')
+        ups = []
+        for k in range(pivot_first_bi_idx - 1, -1, -1):
+            b = self.bis[k]
+            ups.append(b)
+            if b.direction == 'down' and k - 1 >= 0 and self.bis[k-1].direction == 'up':
+                if len(ups) >= 4:
+                    break
+        up_bis = [b for b in ups if b.direction == 'up']
+        if not up_bis:
+            return (None, '')
+        s1 = max(up_bis, key=lambda b: b.end.price)
+        return (s1.end.price, self._ds(s1.end.date))
+
+    def _find_prev_s2(self) -> tuple:
+        s1_price, s1_date_str = self._find_prev_s1()
+        if s1_price is None or not self.pivots:
+            return (None, '')
+        s1_date = pd.Timestamp(s1_date_str)
+        last_piv = self.pivots[-1]
+        right_bi_idx = last_piv.bis[-1] + 1
+        for b in self.bis[:right_bi_idx]:
+            if b.direction != 'up':
+                continue
+            if b.end.date <= s1_date:
+                continue
+            if b.end.price < s1_price - 1e-9:
+                return (b.end.price, self._ds(b.end.date))
+        return (None, '')
+
+    def detect_b1(self) -> Optional[Signal]:
+        if self.n_bis < 5:
+            return None
+        cur = self.bis[-1]
+        if cur.direction != 'down':
+            return None
+        dif_now = float(self.dif.iloc[-1])
+        if dif_now >= 0:
+            return None
+        trend_ok = (self.n_pivots >= 2 and self.trend == 'down_trend')
+        consol_ok = (self.CFG.get('b1_allow_consol_diverge') and self.n_pivots >= 1)
+        if not (trend_ok or consol_ok):
+            return None
+        abc = self._validate_abc('down')
+        if abc is None and consol_ok:
+            abc = self._validate_abc_consol('down')
+        if abc is None:
+            return None
+        c_ok, c_low = self._check_c_new_extreme(abc['c_start_idx'], 'down')
+        if not c_ok:
+            return None
+        last_piv = self.pivots[-1]
+        a_down = [self.bis[k] for k in range(abc['a_start_idx'], abc['a_end_idx'])
+                  if self.bis[k].direction == 'down']
+        c_down = [self.bis[k] for k in range(abc['c_start_idx'], self.n_bis)
+                  if self.bis[k].direction == 'down']
+        if not a_down or not c_down:
+            return None
+        dg = self.assess_divergence(a_down[0].start.date, a_down[-1].end.date,
+                                    c_down[0].start.date, c_down[-1].end.date, 'down')
+        if dg.grade == 'NONE':
+            return None
+        div_kind = '趋势底背驰' if dg.is_trend_divergence else '盘整底背驰(第27课)'
+        b_zero = self._b_returns_to_zero(last_piv)
+        dbl_pull = self.detect_double_pullback_to_zero()
+        pos_strength = self.divergence_strength_by_position()
+        post_evo = self.classify_post_divergence('down')
+        a_low_bi = min(a_down, key=lambda b: b.end.price)
+        c_low_bi = min(c_down, key=lambda b: b.end.price)
+        return Signal(kind='B1', date=self.df_raw['date'].iloc[-1], price=float(self.close.iloc[-1]),
+                      reason=f'{div_kind}一买|{self.n_pivots}中枢|ABC三段{"+B回0轴" if b_zero else ""}|{dg.reason}|DIF={dif_now:.4f}<0',
+                      pivot_zg=last_piv.zg, pivot_zd=last_piv.zd, macd_ratio=dg.area_ratio, dif_value=dif_now,
+                      n_pivots=self.n_pivots, trend=self.trend,
+                      extras={'a_seg': (a_down[0].start.date, a_down[-1].end.date, a_down[0].start.price, a_down[-1].end.price),
+                              'diverge_grade': dg.grade,
+                              'a_low': float(a_low_bi.end.price),
+                              'a_low_date': self._ds(a_low_bi.end.date),
+                              'b1_price': float(cur.end.price),
+                              'b1_date': self._ds(cur.end.date),
+                              'macd_grade': dg.grade,
+                              'macd_area_ratio': dg.area_ratio,
+                              'dif_ok': dg.dif_ok,
+                              'area_ok': dg.area_ok,
+                              'b_returns_zero': b_zero,
+                              'double_pullback': dbl_pull,
+                              'pos_strength': pos_strength,
+                              'post_evolution': post_evo['evolution'],
+                              'c_new_low': c_low,
+                              'c_new_low_date': self._ds(c_low_bi.end.date),
+                              'n_trend_pivots': self.n_trend_pivots,
+                              'price_date': self._ds(cur.end.date),
+                              'pivot_zg_date': self._ds(last_piv.zg_date) if last_piv.zg_date else '',
+                              'pivot_zd_date': self._ds(last_piv.zd_date) if last_piv.zd_date else '',
+                              'pivot_start_date': self._ds(last_piv.start_date),
+                              'pivot_end_date': self._ds(last_piv.end_date)},
+                      diverge_grade=dg)
+
+    def detect_b2(self) -> Optional[Signal]:
+        if self.n_bis < 4:
+            return None
+        cur = self.bis[-1]
+        if cur.direction != 'down':
+            return None
+        prev_downs = [b for b in self.bis[:-1] if b.direction == 'down']
+        if not prev_downs:
+            return None
+        prev = prev_downs[-1]
+        if not (cur.low >= prev.low and cur.end.price > prev.end.price):
+            return None
+        cur_price = float(self.close.iloc[-1])
+        if cur_price < cur.end.price * (1 - self.PIVOT_TOLERANCE):
+            return None
+        if self.CFG.get('b2s2_anchor_to_first'):
+            b1_anchor, _ = self._find_prev_b1()
+            if b1_anchor is None:
+                return None
+            if cur.end.price < b1_anchor - 1e-9:
+                return None
+        dif_now = float(self.dif.iloc[-1])
+        if self.CFG.get('b2_macd_zero_pullback'):
+            look = self.dif.tail(12)
+            crossed_up = bool((look > 0).any())
+            if not crossed_up:
+                return None
+            if dif_now < -self.DIF_TOLERANCE:
+                return None
+        last_piv = self.pivots[-1] if self.pivots else None
+        b1_price, b1_date = prev.end.price, self._ds(prev.end.date)
+        return Signal(kind='B2', date=self.df_raw['date'].iloc[-1], price=cur_price,
+                      reason=f'二买:一买后回踩不破|当前低{cur.end.price:.3f}>一买{b1_price:.3f}|二买不以背驰为成立条件(第21课)',
+                      pivot_zg=None, pivot_zd=None,
+                      macd_ratio=None, dif_value=dif_now, n_pivots=self.n_pivots, trend=self.trend,
+                      extras={'prev_low': prev.end.price, 'cur_low': cur.end.price,
+                              'cur_low_date': self._ds(cur.end.date),
+                              'prev_low_date': self._ds(prev.end.date),
+                              'b1_price': b1_price,
+                              'b1_date': b1_date,
+                              'price_date': self._ds(cur.end.date),
+                              'context_pivot_zg': last_piv.zg if last_piv else None,
+                              'context_pivot_zd': last_piv.zd if last_piv else None,
+                              'context_pivot_zg_date': self._ds(last_piv.zg_date) if last_piv and last_piv.zg_date else '',
+                              'context_pivot_zd_date': self._ds(last_piv.zd_date) if last_piv and last_piv.zd_date else '',
+                              'context_pivot_start_date': self._ds(last_piv.start_date) if last_piv else '',
+                              'context_pivot_end_date': self._ds(last_piv.end_date) if last_piv else ''},
+                      diverge_grade=None)
+
+    def detect_b3(self) -> Optional[Signal]:
+        if self.n_bis < 5 or self.n_pivots < 1:
+            return None
+        late_trend_b3 = self.n_trend_pivots >= 2
+        last_piv = self.pivots[-1]
+        zg, zd = last_piv.zg, last_piv.zd
+        piv_height = zg - zd
+        cur = self.bis[-1]
+        if cur.direction != 'up':
+            return None
+        pair = self._last_exit_pullback_segments(last_piv, 'up', 'down')
+        if pair is None:
+            return None
+        exit_seg, pull_seg = pair
+        if not (exit_seg.low <= zg * (1 + self.PIVOT_TOLERANCE) and exit_seg.high > zg):
+            return None
+        if pull_seg.low < zg * (1 - self.PIVOT_TOLERANCE):
+            return None
+        leaves_pivot = pull_seg.low >= zg
+        cur_price = float(self.close.iloc[-1])
+        if cur_price <= zg:
+            return None
+        ex_amp = exit_seg.high - exit_seg.low
+        if piv_height > 0 and ex_amp < piv_height * 0.5:
+            return None
+        if len(last_piv.bis) < 3:
+            return None
+        confirm_txt = '回踩离枢确认(新中枢生成)' if leaves_pivot else '回踩贴ZG(容差内,新中枢待确认)'
+        b1_price, b1_date = self._find_prev_b1()
+        b2_price, b2_date = self._find_prev_b2()
+        warn_txt = '|第二个以上同向中枢,实盘宜改用低级别一买' if late_trend_b3 else ''
+        return Signal(kind='B3', date=self.df_raw['date'].iloc[-1], price=cur_price,
+                      reason=f'标准三买|ZG={zg:.3f},ZD={zd:.3f}|线段离枢:{exit_seg.low:.3f}→{exit_seg.high:.3f}(幅度{ex_amp:.3f})|线段回试低{pull_seg.low:.3f}|{confirm_txt}|当前{cur_price:.3f}>ZG{warn_txt}',
+                      pivot_zg=zg, pivot_zd=zd, macd_ratio=None, dif_value=float(self.dif.iloc[-1]),
+                      n_pivots=self.n_pivots, trend=self.trend,
+                      extras={'exit_seg': (exit_seg.low, exit_seg.high),
+                              'pull_low': pull_seg.low,
+                              'pull_low_date': self._ds(pull_seg.end.date),
+                              'exit_start_date': self._ds(exit_seg.start.date),
+                              'exit_end_date': self._ds(exit_seg.end.date),
+                              'b1_price': b1_price,
+                              'b1_date': b1_date,
+                              'b2_price': b2_price,
+                              'b2_date': b2_date,
+                              'piv_bi_count': len(last_piv.bis), 'leaves_pivot': leaves_pivot,
+                              'late_trend_b3': late_trend_b3,
+                              'price_date': self._ds(self.df_raw['date'].iloc[-1]),
+                              'pivot_zg_date': self._ds(last_piv.zg_date) if last_piv.zg_date else '',
+                              'pivot_zd_date': self._ds(last_piv.zd_date) if last_piv.zd_date else '',
+                              'pivot_start_date': self._ds(last_piv.start_date),
+                              'pivot_end_date': self._ds(last_piv.end_date)},
+                      diverge_grade=None)
+
+    def detect_s1(self) -> Optional[Signal]:
+        if self.n_bis < 5:
+            return None
+        cur = self.bis[-1]
+        if cur.direction != 'up':
+            return None
+        trend_ok = (self.n_pivots >= 2 and self.trend == 'up_trend')
+        consol_ok = (self.CFG.get('b1_allow_consol_diverge') and self.n_pivots >= 1)
+        if not (trend_ok or consol_ok):
+            return None
+        abc = self._validate_abc('up')
+        if abc is None and consol_ok:
+            abc = self._validate_abc_consol('up')
+        if abc is None:
+            return None
+        last_piv = self.pivots[-1]
+        a_start_idx = abc['a_start_idx']; a_end_idx = abc['a_end_idx']
+        if a_end_idx <= a_start_idx:
+            return None
+        a_up_bis = [self.bis[k] for k in range(a_start_idx, a_end_idx) if self.bis[k].direction == 'up']
+        if not a_up_bis:
+            return None
+        a_high = max(b.end.price for b in a_up_bis)
+        c_start_idx = last_piv.bis[-1] + 1
+        c_up_bis = [self.bis[k] for k in range(c_start_idx, self.n_bis) if self.bis[k].direction == 'up']
+        if not c_up_bis:
+            return None
+        c_high = max(b.end.price for b in c_up_bis)
+        if c_high <= a_high:
+            return None
+        a_high_bi = max(a_up_bis, key=lambda b: b.end.price)
+        dg = self.assess_divergence(a_up_bis[0].start.date, a_up_bis[-1].end.date,
+                                    c_up_bis[0].start.date, c_up_bis[-1].end.date, 'up')
+        if dg.grade == 'NONE':
+            return None
+        b_zero = self._b_returns_to_zero(last_piv)
+        dbl_pull = self.detect_double_pullback_to_zero()
+        pos_strength = self.divergence_strength_by_position()
+        post_evo = self.classify_post_divergence('up')
+        dif_now = float(self.dif.iloc[-1])
+        c_high_bi = max(c_up_bis, key=lambda b: b.end.price)
+        return Signal(kind='S1', date=self.df_raw['date'].iloc[-1], price=float(self.close.iloc[-1]),
+                      reason=f'一卖|上涨趋势{self.n_pivots}中枢|价创新高C{c_high:.3f}>A段高{a_high:.3f}{"+B回0轴" if b_zero else ""}|{dg.reason}',
+                      pivot_zg=last_piv.zg, pivot_zd=last_piv.zd, macd_ratio=dg.area_ratio, dif_value=dif_now,
+                      n_pivots=self.n_pivots, trend=self.trend,
+                      extras={'a_high': a_high, 'c_high': c_high, 'a_area': dg.a_area, 'c_area': dg.c_area,
+                              'diverge_grade': dg.grade,
+                              'a_high_date': self._ds(a_high_bi.end.date),
+                              'b_returns_zero': b_zero,
+                              'double_pullback': dbl_pull,
+                              'pos_strength': pos_strength,
+                              'post_evolution': post_evo['evolution'],
+                              'c_high_date': self._ds(c_high_bi.end.date),
+                              'price_date': self._ds(cur.end.date),
+                              'pivot_zg_date': self._ds(last_piv.zg_date) if last_piv.zg_date else '',
+                              'pivot_zd_date': self._ds(last_piv.zd_date) if last_piv.zd_date else '',
+                              'pivot_start_date': self._ds(last_piv.start_date),
+                              'pivot_end_date': self._ds(last_piv.end_date)},
+                      diverge_grade=dg)
+
+    def detect_s2(self) -> Optional[Signal]:
+        if self.n_bis < 4:
+            return None
+        cur = self.bis[-1]
+        if cur.direction != 'up':
+            return None
+        prev_ups = [b for b in self.bis[:-1] if b.direction == 'up']
+        if not prev_ups:
+            return None
+        prev = prev_ups[-1]
+        if cur.high < prev.high and cur.end.price < prev.end.price:
+            cur_price = float(self.close.iloc[-1])
+            if cur_price > cur.end.price * (1 + self.PIVOT_TOLERANCE):
+                return None
+            if self.CFG.get('b2s2_anchor_to_first'):
+                s1_anchor, _ = self._find_prev_s1()
+                if s1_anchor is None:
+                    return None
+                if cur.end.price > s1_anchor + 1e-9:
+                    return None
+            dif_now = float(self.dif.iloc[-1])
+            last_piv = self.pivots[-1] if self.pivots else None
+            s1_price, s1_date = prev.end.price, self._ds(prev.end.date)
+            return Signal(kind='S2', date=self.df_raw['date'].iloc[-1], price=cur_price,
+                          reason=f'二卖:一卖后反弹不破|当前高{cur.end.price:.3f}<一卖{s1_price:.3f}|二卖不以背驰为成立条件(第21课)',
+                          pivot_zg=None, pivot_zd=None,
+                          dif_value=dif_now, n_pivots=self.n_pivots, trend=self.trend,
+                          extras={'prev_high': prev.end.price, 'cur_high': cur.end.price,
+                                  'cur_high_date': self._ds(cur.end.date),
+                                  'prev_high_date': self._ds(prev.end.date),
+                                  's1_price': s1_price, 's1_date': s1_date,
+                                  'price_date': self._ds(cur.end.date),
+                                  'context_pivot_zg': last_piv.zg if last_piv else None,
+                                  'context_pivot_zd': last_piv.zd if last_piv else None,
+                                  'context_pivot_zg_date': self._ds(last_piv.zg_date) if last_piv and last_piv.zg_date else '',
+                                  'context_pivot_zd_date': self._ds(last_piv.zd_date) if last_piv and last_piv.zd_date else '',
+                                  'context_pivot_start_date': self._ds(last_piv.start_date) if last_piv else '',
+                                  'context_pivot_end_date': self._ds(last_piv.end_date) if last_piv else ''},
+                          diverge_grade=None)
+        return None
+
+    def detect_s3(self) -> Optional[Signal]:
+        if self.n_bis < 5 or self.n_pivots < 1:
+            return None
+        last_piv = self.pivots[-1]
+        zg, zd = last_piv.zg, last_piv.zd
+        if len(self.bis) < 3:
+            return None
+        cur = self.bis[-1]
+        if cur.direction != 'down':
+            return None
+        s1_price, s1_date = self._find_prev_s1()
+        s2_price, s2_date = self._find_prev_s2()
+        base_dates = {'price_date': self._ds(self.df_raw['date'].iloc[-1]),
+                      's1_price': s1_price, 's1_date': s1_date,
+                      's2_price': s2_price, 's2_date': s2_date,
+                      'pivot_zg_date': self._ds(last_piv.zg_date) if last_piv.zg_date else '',
+                      'pivot_zd_date': self._ds(last_piv.zd_date) if last_piv.zd_date else '',
+                      'pivot_start_date': self._ds(last_piv.start_date),
+                      'pivot_end_date': self._ds(last_piv.end_date)}
+        pair = self._last_exit_pullback_segments(last_piv, 'down', 'up')
+        if pair is None:
+            return None
+        exit_seg, pull_seg = pair
+        if not (exit_seg.high >= zd * (1 - self.PIVOT_TOLERANCE) and exit_seg.low < zd):
+            return None
+        if pull_seg.high > zd * (1 + self.PIVOT_TOLERANCE):
+            return None
+        if float(self.close.iloc[-1]) >= zd:
+            return None
+        return Signal(kind='S3', date=self.df_raw['date'].iloc[-1], price=float(self.close.iloc[-1]),
+                      reason=f'标准三卖|ZD={zd:.3f}|线段离枢低{exit_seg.low:.3f}<ZD|线段回抽高{pull_seg.high:.3f}未过ZD',
+                      pivot_zg=zg, pivot_zd=zd, dif_value=float(self.dif.iloc[-1]),
+                      n_pivots=self.n_pivots, trend=self.trend, extras=base_dates, diverge_grade=None)
+
+    def get_signal(self) -> Optional[Signal]:
+        for fn in [self.detect_s1, self.detect_s2, self.detect_s3]:
+            sig = fn()
+            if sig is not None:
+                return sig
+        for fn in [self.detect_b3, self.detect_b2, self.detect_b1]:
+            sig = fn()
+            if sig is not None:
+                return sig
+        return None
+
+    def get_all_signals(self) -> list:
+        all_sigs = []
+        for fn in [self.detect_b1, self.detect_b2, self.detect_b3,
+                   self.detect_s1, self.detect_s2, self.detect_s3]:
+            sig = fn()
+            if sig is not None:
+                all_sigs.append(sig)
+        return all_sigs
+
+    def l36_segment_note(self) -> str:
+        """L36 结合律: 走势分解的唯一性靠结合律保证 —— a+A+b+B+c 的划分中, 同一段
+        K线不能既归前段又归后段。本引擎线段划分采用特征序列分型(标准缠论)处理
+        包含关系, 分型一旦确认即锁定段的归属, 等价于结合律的程序化执行。
+        该函数对当前末端给出"是否存在划分歧义"的提示。"""
+        if len(self.segs) < 2:
+            return '第36课: 线段不足2段, 无划分歧义问题'
+        last = self.segs[-1]
+        n_last = len(getattr(last, 'bis', []) or [])
+        if n_last < 3:
+            return (f'第36课: 末段仅{n_last}笔(<3), 末端划分尚未唯一确认 —— '
+                    f'当下操作应按两种归属做完全分类预案, 等待特征序列分型锁定')
+        return '第36课: 末段≥3笔且特征序列分型已锁定, 当前划分唯一, 无歧义'
+
+    def diagnose(self) -> dict:
+        cur_price = float(self.close.iloc[-1]) if len(self.close) else 0.0
+        last = self.bis[-1] if self.bis else None
+        out = {k: [] for k in ('B1', 'B2', 'B3', 'S1', 'S2', 'S3')}
+        def add(k, ok, msg):
+            out[k].append(('✓' if ok else '✗') + ' ' + msg)
+        add('B1', self.n_bis >= 5, f'笔数 {self.n_bis} >= 5')
+        add('B1', self.n_pivots >= 2, f'中枢数 {self.n_pivots} >= 2')
+        add('B1', self.trend == 'down_trend', f'当前走势={self.trend}, B1要求下跌趋势')
+        add('B1', bool(last and last.direction == 'down'), f'最后一笔方向={last.direction if last else ""}, B1要求向下')
+        add('B1', float(self.dif.iloc[-1]) < 0 if len(self.dif) else False, f'DIF={float(self.dif.iloc[-1]):.4f}, B1要求DIF<0')
+        abc_down = self._validate_abc('down')
+        add('B1', abc_down is not None, 'A/B/C三段背驰结构成立')
+        if abc_down is not None:
+            c_ok, c_low = self._check_c_new_extreme(abc_down['c_start_idx'], 'down')
+            add('B1', c_ok, f'C段创新低{"" if c_low is None else f"({c_low:.3f})"}')
+        add('B2', self.n_bis >= 4, f'笔数 {self.n_bis} >= 4')
+        add('B2', bool(last and last.direction == 'down'), f'最后一笔方向={last.direction if last else ""}, B2要求回踩向下')
+        prev_downs = [b for b in self.bis[:-1] if b.direction == 'down'] if last else []
+        add('B2', bool(prev_downs), '存在同一轮前一个下跌低点作为一买锚')
+        if last and prev_downs:
+            prev = prev_downs[-1]
+            add('B2', last.low >= prev.low and last.end.price > prev.end.price,
+                f'回踩不创新低: 本次低{last.end.price:.3f} > 一买/前低{prev.end.price:.3f}')
+            add('B2', cur_price >= last.end.price * (1 - self.PIVOT_TOLERANCE),
+                f'现价{cur_price:.3f}未跌破B2回踩锚{last.end.price:.3f}; 跌破则二买失效')
+        add('B3', self.n_pivots >= 1, f'中枢数 {self.n_pivots} >= 1')
+        add('B3', bool(last and last.direction == 'up'), f'最后一笔方向={last.direction if last else ""}, B3要求向上确认')
+        if self.pivots:
+            p = self.pivots[-1]
+            pair = self._last_exit_pullback_segments(p, 'up', 'down')
+            add('B3', pair is not None, '存在已确认线段级别的向上离枢 + 向下回试')
+            if pair is not None:
+                exit_seg, pull_seg = pair
+                add('B3', exit_seg.low <= p.zg * (1 + self.PIVOT_TOLERANCE) and exit_seg.high > p.zg,
+                    f'离枢线段突破ZG: {exit_seg.low:.3f}~{exit_seg.high:.3f}, ZG={p.zg:.3f}')
+                add('B3', pull_seg.low >= p.zg * (1 - self.PIVOT_TOLERANCE),
+                    f'回试低点{pull_seg.low:.3f}不破ZG={p.zg:.3f}')
+                add('B3', cur_price > p.zg, f'现价{cur_price:.3f}站上ZG={p.zg:.3f}')
+        add('S1', self.n_bis >= 5, f'笔数 {self.n_bis} >= 5')
+        add('S1', self.n_pivots >= 2, f'中枢数 {self.n_pivots} >= 2')
+        add('S1', self.trend == 'up_trend', f'当前走势={self.trend}, S1要求上涨趋势')
+        add('S1', bool(last and last.direction == 'up'), f'最后一笔方向={last.direction if last else ""}, S1要求向上')
+        abc_up = self._validate_abc('up')
+        add('S1', abc_up is not None, 'A/B/C三段顶背驰结构成立')
+        if abc_up is not None:
+            c_ok, c_high = self._check_c_new_extreme(abc_up['c_start_idx'], 'up')
+            add('S1', c_ok, f'C段创新高{"" if c_high is None else f"({c_high:.3f})"}')
+        add('S2', self.n_bis >= 4, f'笔数 {self.n_bis} >= 4')
+        add('S2', bool(last and last.direction == 'up'), f'最后一笔方向={last.direction if last else ""}, S2要求反弹向上')
+        prev_ups = [b for b in self.bis[:-1] if b.direction == 'up'] if last else []
+        add('S2', bool(prev_ups), '存在同一轮前一个上涨高点作为一卖锚')
+        if last and prev_ups:
+            prev = prev_ups[-1]
+            add('S2', last.high < prev.high and last.end.price < prev.end.price,
+                f'反弹不创新高: 本次高{last.end.price:.3f} < 一卖/前高{prev.end.price:.3f}')
+            add('S2', cur_price <= last.end.price * (1 + self.PIVOT_TOLERANCE),
+                f'现价{cur_price:.3f}未重新升破S2反弹锚{last.end.price:.3f}; 升破则二卖失效')
+        add('S3', self.n_pivots >= 1, f'中枢数 {self.n_pivots} >= 1')
+        add('S3', bool(last and last.direction == 'down'), f'最后一笔方向={last.direction if last else ""}, S3要求向下确认')
+        if self.pivots:
+            p = self.pivots[-1]
+            pair = self._last_exit_pullback_segments(p, 'down', 'up')
+            add('S3', pair is not None, '存在已确认线段级别的向下离枢 + 向上回抽')
+            if pair is not None:
+                exit_seg, pull_seg = pair
+                add('S3', exit_seg.high >= p.zd * (1 - self.PIVOT_TOLERANCE) and exit_seg.low < p.zd,
+                    f'离枢线段跌破ZD: {exit_seg.low:.3f}~{exit_seg.high:.3f}, ZD={p.zd:.3f}')
+                add('S3', pull_seg.high <= p.zd * (1 + self.PIVOT_TOLERANCE),
+                    f'回抽高点{pull_seg.high:.3f}不破ZD={p.zd:.3f}')
+                add('S3', cur_price < p.zd, f'现价{cur_price:.3f}跌破ZD={p.zd:.3f}')
+        return out
+
+
+class SameLevelDecomposition:
+    def __init__(self, analyzer: 'ChanAnalyzer'):
+        self.an = analyzer
+        self.segs = analyzer.segs
+
+    def current_phase(self) -> dict:
+        if len(self.segs) < 2:
+            return {'seg_dir': '', 'stage': 'unknown', 'action': 'WATCH',
+                    'reason': '线段不足, 无法做同级别分解'}
+        last = self.segs[-1]
+        prev = self.segs[-2]
+        seg_dir = last.direction
+        if seg_dir == 'up':
+            stage = 'up_run'
+            prev_up = None
+            for s in reversed(self.segs[:-1]):
+                if s.direction == 'up':
+                    prev_up = s; break
+            if prev_up is None:
+                return {'seg_dir': seg_dir, 'stage': stage, 'action': 'HOLD',
+                        'reason': '向上段运作中(无前向上段可比), 持有'}
+            if last.high <= prev_up.high:
+                return {'seg_dir': seg_dir, 'stage': stage, 'action': 'SELL',
+                        'reason': f'向上段不创新高({last.high:.3f}≤前高{prev_up.high:.3f}) → 先卖(第38课)'}
+            dg = self.an.assess_divergence(prev_up.start.date, prev_up.end.date,
+                                           last.start.date, last.end.date, 'up')
+            if dg.grade != 'NONE':
+                return {'seg_dir': seg_dir, 'stage': stage, 'action': 'SELL',
+                        'reason': f'向上段创新高但盘整背驰({dg.grade}) → 卖(第38课)'}
+            return {'seg_dir': seg_dir, 'stage': stage, 'action': 'HOLD',
+                    'reason': '向上段创新高且不背驰 → 持有(第38课)'}
+        else:
+            stage = 'down_run'
+            prev_down = None
+            for s in reversed(self.segs[:-1]):
+                if s.direction == 'down':
+                    prev_down = s; break
+            if prev_down is None:
+                return {'seg_dir': seg_dir, 'stage': stage, 'action': 'WATCH',
+                        'reason': '向下段运作中(无前向下段可比), 观望等买点'}
+            if last.low >= prev_down.low:
+                return {'seg_dir': seg_dir, 'stage': stage, 'action': 'BUY',
+                        'reason': f'向下段不创新低({last.low:.3f}≥前低{prev_down.low:.3f}) → 买入(第38课)'}
+            dg = self.an.assess_divergence(prev_down.start.date, prev_down.end.date,
+                                           last.start.date, last.end.date, 'down')
+            if dg.grade != 'NONE':
+                return {'seg_dir': seg_dir, 'stage': stage, 'action': 'BUY',
+                        'reason': f'向下段创新低但盘整背驰({dg.grade}) → 买入(第38课)'}
+            return {'seg_dir': seg_dir, 'stage': stage, 'action': 'WATCH',
+                    'reason': '向下段创新低且不背驰 → 观望等下跌背驰(第38课)'}
+
+
+class BottomTracker:
+    def __init__(self):
+        self.state = 'none'
+
+    def update(self, analyzer: 'ChanAnalyzer') -> str:
+        snap = analyzer.bottom_construction_state()
+        if self.state in ('none', 'failed', 'completed'):
+            if snap == 'constructing':
+                self.state = 'constructing'
+            elif snap == 'completed':
+                self.state = 'completed'
+            elif snap == 'failed':
+                self.state = 'failed'
+            else:
+                self.state = 'none'
+        elif self.state == 'constructing':
+            if snap == 'completed':
+                self.state = 'completed'
+            elif snap == 'failed':
+                self.state = 'failed'
+        return self.state

chan_enhance.py

@@ -0,0 +1,123 @@
+"""
+chan_enhance.py —— 缠论系统增强(查漏补缺) · 纯函数版(非Hook)
+"""
+from __future__ import annotations
+
+
+W_REVERSAL = 1.0
+W_TRAP     = 0.85
+W_RELAY    = 0.6
+W_UNKNOWN  = 0.7
+
+# 第16课 六种基本走势 → 买法分类的中文名(配合英文 method 一起展示)
+METHOD_CN = {
+    'reversal': '反转式(下跌+盘整+上涨 / 趋势底背驰一买, 力度最强, 权重最高)',
+    'trap':     '陷阱式(下跌+上涨, 空头陷阱式二买, 中等力度)',
+    'relay':    '中继式(上涨+盘整+上涨, 三买, 趋势中继)',
+    'unknown':  '未分类',
+}
+
+WEAK_ARM_GAIN = 0.04
+WEAK_GIVEBACK = 0.22
+
+L92_EXIT_ENABLE      = False
+L92_EXIT_FLOATING_MAX = 0.015
+L92_ZD_BREAK_BUF      = 0.0
+
+
+def classify_buy_method(sig_kind, ml) -> str:
+    sig = ml.daily.signal if (ml and ml.daily) else None
+    dg = getattr(sig, 'diverge_grade', None) if sig is not None else None
+    if sig_kind == 'B1':
+        return 'reversal'
+    if sig_kind == 'B3':
+        return 'relay'
+    if sig_kind == 'B2':
+        # L37 背驰分辨: 只有"趋势背驰"(≥2个同向中枢后的背驰)才是标准的趋势转折,
+        # 对应第16课"下跌+盘整+上涨"反转式买法; 盘整背驰力度弱, 仍按陷阱式处理。
+        if (dg is not None and getattr(dg, 'grade', '') == 'STRONG'
+                and getattr(dg, 'is_trend_divergence', False)):
+            return 'reversal'
+        return 'trap'
+    return 'unknown'
+
+
+def l37_divergence_note(ml) -> str:
+    """L37 背驰分辨(区分背驰段构成): 趋势背驰=至少两个同向中枢后的背驰, 转折级别高;
+    盘整背驰=单中枢内的力度衰竭, 只保证回拉中枢, 不保证反转。"""
+    sig = ml.daily.signal if (ml and ml.daily) else None
+    dg = getattr(sig, 'diverge_grade', None) if sig is not None else None
+    if dg is None or getattr(dg, 'grade', 'NONE') == 'NONE':
+        return ''
+    if getattr(dg, 'is_trend_divergence', False):
+        return (f'第37课: 趋势背驰({getattr(dg, "n_trend_pivots", "?")}个同向中枢), '
+                f'转折至少回拉至最后一个中枢, 大概率反转 → 可按反转式买法重仓')
+    return ('第37课: 盘整背驰(背驰段内仅1个中枢), 只保证回拉中枢一次, '
+            '不保证趋势反转 → 轻仓短打, 回拉到中枢即考虑兑现')
+
+
+def buy_method_weight(sig_kind, ml):
+    method = classify_buy_method(sig_kind, ml)
+    wmap = {'reversal': W_REVERSAL, 'trap': W_TRAP, 'relay': W_RELAY, 'unknown': W_UNKNOWN}
+    return method, wmap.get(method, W_UNKNOWN)
+
+
+def recompute_evo(ml) -> str:
+    sig = ml.daily.signal if (ml and ml.daily) else None
+    if sig is not None:
+        evo = (sig.extras or {}).get('post_evolution', '')
+        if evo:
+            return evo
+    dv = ml.daily if ml else None
+    if dv is not None and dv.zd is not None and dv.zg is not None:
+        if ml.cur_price < dv.zd:
+            return 'case1_extend'
+    return ''
+
+
+def weak_evo_giveback(pos, ml, default_giveback):
+    evo = recompute_evo(ml) if ml is not None else (pos.get('post_evo') or '')
+    if evo == 'case1_extend':
+        return WEAK_ARM_GAIN, WEAK_GIVEBACK
+    return None, default_giveback
+
+
+def l92_should_exit(pos, ml, close_p, floating):
+    if not L92_EXIT_ENABLE or ml is None or ml.daily is None:
+        return None
+    if floating > L92_EXIT_FLOATING_MAX:
+        return None
+    zd = ml.daily.zd
+    if zd is None:
+        return None
+    if close_p < zd * (1 - L92_ZD_BREAK_BUF) and close_p > pos.get('stop_px', 0):
+        return ('L92_EXIT',
+                f'第92课中枢震荡监视器: 现价{close_p:.3f}已破日线中枢下沿ZD{zd:.3f}'
+                f'(向下变盘) 且浮盈仅{floating:+.1%} → 提前减仓, 不等磨到结构止损')
+    return None
+
+
+def predict_enhance(ml) -> dict:
+    out = {}
+    if ml is None or ml.daily is None:
+        return out
+    sig_kind = ml.final_kind or ''
+    if sig_kind in ('B1', 'B2', 'B3'):
+        method, weight = buy_method_weight(sig_kind, ml)
+        out['buy_method'] = method
+        out['buy_method_cn'] = METHOD_CN.get(method, method)
+        out['suggest_weight'] = weight
+        out['l16_note'] = f'第16课: 买法分类={method}〔{METHOD_CN.get(method, method)}〕, 建议仓位权重{weight:.2f}'
+    l37 = l37_divergence_note(ml)
+    if l37:
+        out['l37_note'] = l37
+    evo = recompute_evo(ml)
+    if evo:
+        out['post_evolution'] = evo
+        out['evo_hint'] = ('第29课: 最弱形态(反弹/回落未回中枢), 持有宜收紧移动止盈, 尽快兑现'
+                           if evo == 'case1_extend'
+                           else '第29课: 形态较强(回到中枢), 可持有等三买/趋势延续')
+    zd = ml.daily.zd
+    if zd is not None and ml.cur_price < zd:
+        out['l92_warn'] = f'第92课: 现价{ml.cur_price:.3f}已在日线中枢下沿ZD{zd:.3f}下方 → 向下变盘预警'
+    return out

chan_glue.py

@@ -0,0 +1,69 @@
+"""
+chan_glue.py — wires the user's notebook-style modules together at runtime.
+
+The original chan_engine.py / chan_multilevel.py were written as notebook cells:
+chan_multilevel references `ChanAnalyzer` / `Signal` via a commented-out import.
+Because both files use `from __future__ import annotations` and resolve names at
+call time, we can simply inject the symbols into the module namespace — the Chan
+analysis logic itself is left 100% untouched.
+
+Also provides a small LRU-cached analyzer factory (the original chan_common.py
+was A-share specific and is not used in the US version).
+"""
+from __future__ import annotations
+
+import hashlib
+from collections import OrderedDict
+
+import pandas as pd
+
+import chan_engine
+import chan_multilevel
+
+# ── inject cross-module symbols (replaces the commented `from chan_engine import …`) ──
+chan_multilevel.ChanAnalyzer = chan_engine.ChanAnalyzer
+chan_multilevel.Signal = chan_engine.Signal
+
+# Re-exports for app code
+ChanAnalyzer = chan_engine.ChanAnalyzer
+Signal = chan_engine.Signal
+MultiLevelChan = chan_multilevel.MultiLevelChan
+MultiLevelSignal = chan_multilevel.MultiLevelSignal
+resample_weekly = chan_multilevel.resample_weekly
+resample_monthly = chan_multilevel.resample_monthly
+set_analyzer_factory = chan_multilevel.set_analyzer_factory
+
+# ── cached analyzer factory ──────────────────────────────────────────────
+_CACHE: "OrderedDict[str, chan_engine.ChanAnalyzer]" = OrderedDict()
+_CACHE_MAX = 64
+
+
+def _df_key(level: str, df: pd.DataFrame) -> str:
+    n = len(df)
+    if n == 0:
+        return f"{level}-empty"
+    last = str(df['date'].iloc[-1])
+    first = str(df['date'].iloc[0])
+    tail_close = float(df['close'].iloc[-1])
+    raw = f"{level}|{n}|{first}|{last}|{tail_close:.6f}"
+    return hashlib.md5(raw.encode()).hexdigest()
+
+
+def cached_analyzer(level: str, df: pd.DataFrame):
+    key = _df_key(level, df)
+    if key in _CACHE:
+        _CACHE.move_to_end(key)
+        return _CACHE[key]
+    an = chan_engine.ChanAnalyzer(df.reset_index(drop=True))
+    _CACHE[key] = an
+    while len(_CACHE) > _CACHE_MAX:
+        _CACHE.popitem(last=False)
+    return an
+
+
+def install():
+    """Install the cached analyzer factory into MultiLevelChan."""
+    set_analyzer_factory(cached_analyzer)
+
+
+install()

chan_multilevel.py

@@ -0,0 +1,884 @@
+"""缠论多级别联立分析
+
+【本版改动 · 卖点区间套修复 (第24/44课)】
+
+旧逻辑的两个病根(对应回测中"卖在低位"与"提前卖飞"):
+  ① 卖在低位: 严格模式要求"30分钟出现三类卖点S3"才印证日线卖点。但S3是
+     次级别已经跌破其中枢、反抽不回的【转折确认点】—— 它出现时价格早已
+     离开顶部一大截。拿S3当卖出闸门, 等于规定"必须先跌下来才准卖", 结构上
+     注定卖不到一卖的高位, 最后落在二卖/三卖的低位。
+  ② 提前卖飞: 宽松模式下"30m最后一笔向下"即印证。第24课明示: 小级别背驰
+     (更别说仅仅一笔向下)未必引发大级别转折。任何一次30m级别的正常回调都
+     可能把日线WEAK级别的卖点"确认"掉 → 还没到顶就出局。
+     而且旧代码对次级别卖点【不做时间嵌套检查】: 30m在日线C段开始之前的
+     旧背驰也会被当作印证 —— "区间套"三个字里的"区间"丢了。
+
+新逻辑 (CFG['sell_nested_interval']=True):
+  第44课区间套的本义: 大级别进入背驰段后, 在该背驰段【时间区间内】找次级别
+  的背驰段, 再在其中找次次级别的背驰段, 逐级收敛到精确转折点。
+  对日线S1/S2, 次级别印证按优先级:
+    ① 嵌套顶背驰: 30m出现S1, 且其C段顶部落在日线背驰段(最后中枢之后→当下)
+       的时间窗口内、顶部价位贴近日线C段高点 → 精确卖点, 卖在高位区。
+    ② 次级别转折确认: 30m出现S3, 或30m末笔已跌破其最近中枢下沿ZD(第92课
+       向下变盘) → 转折已确认, 偏晚但必须卖。
+    ③ 两者皆无 → 次级别动能未竭, 第24课: 顶未到 → 【不卖】(防卖飞),
+       返回 action=HOLD + sell_armed=True 进入"区间套布防"状态:
+       回测端持仓转入布防, 之后任一条件触发(嵌套背驰出现/破30m中枢ZD/
+       较布防峰值回落超阈值)即离场 —— 既不提前卖飞, 也不一路坐滑梯到三卖。
+  S3(日线三卖)不走嵌套背驰: 三卖本身就是转折确认型卖点, 维持原确认逻辑。
+"""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Optional
+import numpy as np
+import pandas as pd
+
+# from chan_engine import ChanAnalyzer, Signal
+
+
+# ── 卖点区间套参数 (第24/44课) ──
+NESTED_TOP_PRICE_TOL   = 0.03   # 嵌套顶背驰的顶部须贴近父级C段高点(3%以内), 否则属上一波动能
+NESTED_WINDOW_PAD_DAYS = 3      # 时间嵌套窗口的左侧容差(日)
+SELL_ARM_PEAK_DROP     = 0.04   # 布防后较峰值价回落≥4% → 顶部确认离场(回测端使用)
+SELL_ARM_DISARM_BREAK  = 0.03   # 布防后强势创新高超3%且卖点消失 → 背驰被消化, 撤防(第26课)
+
+
+def _default_make_analyzer(level, df):
+    return ChanAnalyzer(df.reset_index(drop=True))
+
+_MAKE_ANALYZER = _default_make_analyzer
+
+def set_analyzer_factory(fn):
+    global _MAKE_ANALYZER
+    _MAKE_ANALYZER = fn or _default_make_analyzer
+
+
+def resample_weekly(df_daily: pd.DataFrame) -> pd.DataFrame:
+    if df_daily.empty:
+        return df_daily.copy()
+    d = df_daily.copy()
+    d['date'] = pd.to_datetime(d['date'])
+    d = d.sort_values('date').reset_index(drop=True)
+    wk_period = d['date'].dt.to_period('W-FRI')
+    agg = {'open': 'first', 'high': 'max', 'low': 'min', 'close': 'last'}
+    if 'volume' in d.columns: agg['volume'] = 'sum'
+    if 'amount' in d.columns: agg['amount'] = 'sum'
+    g = d.groupby(wk_period, sort=True)
+    wk = g.agg(agg)
+    last_real = g['date'].max()
+    wk = wk.dropna(subset=['open', 'high', 'low', 'close']).reset_index(drop=True)
+    wk['date'] = list(last_real.values)
+    return wk
+
+
+def resample_monthly(df_daily: pd.DataFrame) -> pd.DataFrame:
+    if df_daily.empty:
+        return df_daily.copy()
+    d = df_daily.copy()
+    d['date'] = pd.to_datetime(d['date'])
+    d = d.sort_values('date').reset_index(drop=True)
+    mp = d['date'].dt.to_period('M')
+    agg = {'open': 'first', 'high': 'max', 'low': 'min', 'close': 'last'}
+    if 'volume' in d.columns: agg['volume'] = 'sum'
+    if 'amount' in d.columns: agg['amount'] = 'sum'
+    g = d.groupby(mp, sort=True)
+    mo = g.agg(agg)
+    last_real = g['date'].max()
+    mo = mo.dropna(subset=['open', 'high', 'low', 'close']).reset_index(drop=True)
+    mo['date'] = list(last_real.values)
+    return mo
+
+
+@dataclass
+class LevelView:
+    level: str
+    trend: str
+    n_pivots: int
+    n_bis: int
+    last_bi_dir: str
+    signal: Optional[Signal]
+    zg: Optional[float]
+    zd: Optional[float]
+    dif: Optional[float]
+    last_date: Optional[pd.Timestamp]
+    diagnostics: dict = field(default_factory=dict)
+
+
+@dataclass
+class MultiLevelSignal:
+    code: str
+    analysis_date: pd.Timestamp
+    weekly: LevelView
+    daily: LevelView
+    m30: Optional[LevelView]
+    action: str
+    confidence: str
+    final_kind: str
+    cur_price: float
+    chain: list = field(default_factory=list)
+    blocked_reason: str = ''
+    note: str = ''
+    confidence_reasons: list = field(default_factory=list)
+    diagnostics: dict = field(default_factory=dict)
+    monthly: Optional[LevelView] = None
+    # ── 卖点区间套布防 (第44课) ──
+    sell_armed: bool = False              # 日线S1/S2背驰已现、次级别动能未竭 → 持仓布防
+    arm_zd: Optional[float] = None        # 布防线①: 30m最近中枢下沿ZD(跌破即次级别转折确认)
+    arm_high: Optional[float] = None      # 父级背驰段C段高点(用于"新高消化背驰"撤防判定)
+
+    def explain(self) -> str:
+        lines = [f'  [{self.code}] {self.analysis_date.strftime("%Y-%m-%d")}  ¥{self.cur_price:.3f}']
+        lines.append(f'  最终: {self.action}  置信度={self.confidence}'
+                     + (f'  信号={self.final_kind}' if self.final_kind else ''))
+        lines.append('  ── 逐级裁决链 ──')
+        for lvl, concl, src in self.chain:
+            lines.append(f'    [{lvl:<7s}] {concl}')
+            if src:
+                lines.append(f'              └ 依据: {src}')
+        if self.blocked_reason:
+            lines.append(f'  ⚠ 拦截: {self.blocked_reason}')
+        if self.note:
+            lines.append(f'  说明: {self.note}')
+        if self.confidence_reasons:
+            lines.append('  置信度降档明细:')
+            for i, r in enumerate(self.confidence_reasons, 1):
+                lines.append(f'    {i}. {r}')
+        if self.diagnostics:
+            lines.append('  日线买卖点逐项诊断:')
+            for k in ('B1', 'B2', 'B3', 'S1', 'S2', 'S3'):
+                rows = self.diagnostics.get(k) or []
+                if not rows:
+                    continue
+                ok = all(str(x).startswith('✓') for x in rows)
+                lines.append(f'    {k} {"满足" if ok else "不满足"}')
+                for row in rows:
+                    lines.append(f'      {row}')
+        else:
+            lines.append('  日线买卖点逐项诊断: 未生成')
+        return '\n'.join(lines)
+
+
+class MultiLevelChan:
+    CFG = {
+        'use_monthly_gate': True,
+        'monthly_ma_filter': False,
+        'require_sublevel_sell_confirm': False,
+        'mode': 'short',
+        'zhongyin_block_buy': False,
+        'expose_m30_nosignal': False,
+        'require_60m_buy_confirm': False,  # L44区间套: 60m为日线直接次级别, 买点须经其印证
+        # L50 MACD级别选择: 看MACD要选"黄白线和柱子清晰"的级别。30m判据模糊而60m
+        # 清晰且60m已印证时, 采信60m的印证结论(避免被模糊级别的噪声误杀好买点)。
+        'l50_macd_level_select': False,
+        # ── 卖点区间套(第24/44课): 嵌套顶背驰精确定位 + 布防防卖飞 ──
+        #   True  = S1/S2用"时间嵌套的次级别顶背驰"定位高点; 未嵌套确认时不卖而布防
+        #   False = 维持旧逻辑(30m要S3 / 宽松末笔向下即卖)
+        'sell_nested_interval': True,
+        # L24: 周线上涨+日线盘整背驰的S1/S2 → 不全清, 转布防短差(撤防可骑回趋势)
+        'l24_weekly_uptrend_arm': False,  # 实测净亏(好卖点也被转布防), 默认关
+    }
+
+    # ── 速度优化: 次级别K线只取最近N根做缠论分解 ──
+    # 第17/44课: 次级别(60m/30m/15m/5m/1m)的职责是"印证当下转折", 其买卖点
+    # 只取决于最近的笔/线段/中枢结构; 几年前的分钟级历史对当下印证毫无贡献,
+    # 却让每个回测日都对上万根分钟K线重做合并/分型/笔/段, 是最大的耗时点。
+    # 截断只作用于次级别印证, 日/周/月线仍用全history(年线、月线大方向不受影响)。
+    SUB_TAIL = {'15m': 4000, '5m': 4800, '1m': 2000}
+
+    def __init__(self, df_daily, df_weekly=None, df_monthly=None, df_30m=None, df_60m=None,
+                 df_15m=None, df_5m=None, df_1m=None, code='', strict=True):
+        self.code = code
+        self.strict = strict
+        self.df_daily = df_daily.reset_index(drop=True) if not df_daily.empty else df_daily
+        self.df_30m = df_30m.reset_index(drop=True) if df_30m is not None and not df_30m.empty else None
+        self.df_60m = df_60m.reset_index(drop=True) if df_60m is not None and not df_60m.empty else None
+        self.df_15m = df_15m.reset_index(drop=True) if df_15m is not None and not df_15m.empty else None
+        self.df_5m = df_5m.reset_index(drop=True) if df_5m is not None and not df_5m.empty else None
+        self.df_1m = df_1m.reset_index(drop=True) if df_1m is not None and not df_1m.empty else None
+        self.df_weekly = df_weekly.reset_index(drop=True) if df_weekly is not None and not df_weekly.empty else None
+        self.df_monthly = df_monthly.reset_index(drop=True) if df_monthly is not None and not df_monthly.empty else None
+
+    @staticmethod
+    def _make_view(level, df, an=None, diagnose=True):
+        if an is None:
+            if df is None or len(df) < 30:
+                return None
+            try:
+                an = _MAKE_ANALYZER(level, df)
+            except Exception:
+                return None
+            if an is None:
+                return None
+        sig = an.get_signal()
+        zg = an.pivots[-1].zg if an.n_pivots > 0 else None
+        zd = an.pivots[-1].zd if an.n_pivots > 0 else None
+        return LevelView(level=level, trend=an.trend, n_pivots=an.n_pivots, n_bis=an.n_bis,
+                         last_bi_dir=an.bis[-1].direction if an.n_bis else '', signal=sig,
+                         zg=zg, zd=zd, dif=float(an.dif.iloc[-1]) if len(an.dif) else None,
+                         last_date=pd.Timestamp(df['date'].iloc[-1]),
+                         diagnostics=(an.diagnose() if diagnose else {}))
+
+    # ──────────────────────────────────────────────────────────────────
+    #  卖点区间套核心: 时间嵌套的次级别顶背驰 (第44课)
+    # ──────────────────────────────────────────────────────────────────
+    @staticmethod
+    def _parent_sell_window(parent_sig):
+        """父级(日线)背驰段的时间窗口与顶部价。
+        S1: 背驰段C段 = 最后中枢结束 → 当下; 顶 = C段高点 c_high。
+        S2: 窗口 = 一卖出现 → 当下(反抽段); 顶 = 一卖高点 prev_high。"""
+        ex = (parent_sig.extras or {}) if parent_sig is not None else {}
+        if parent_sig is None:
+            return '', '', None
+        if parent_sig.kind == 'S1':
+            w_start = ex.get('pivot_end_date') or ex.get('a_high_date') or ''
+            top = ex.get('c_high')
+        else:  # S2
+            w_start = ex.get('s1_date') or ex.get('prev_high_date') or ''
+            top = ex.get('prev_high')
+        w_end = ex.get('price_date') or ''
+        return w_start, w_end, top
+
+    def _nested_sell_check(self, sub_an, parent_sig, lvl_name, parent_kind):
+        """第44课区间套(卖点版): 在父级背驰段时间窗口内找次级别的嵌套顶背驰。
+        优先级: ①嵌套S1(精确高点, 卖在高位)
+               ②S3 / 末笔破次级别中枢ZD(转折已确认, 偏晚但必卖)
+               ③都没有 → 第24课: 次级别动能未竭, 顶未到 → 不卖(防卖飞), 转布防。
+        返回 (confirmed: bool, note: str)。"""
+        w_start, w_end, parent_top = self._parent_sell_window(parent_sig)
+
+        def in_window(dstr):
+            if not w_start or not dstr:
+                return True   # 信息不足时不因窗口否决(保守放行, 由价位贴近度把关)
+            try:
+                d = pd.Timestamp(dstr)
+                lo = pd.Timestamp(w_start) - pd.Timedelta(days=NESTED_WINDOW_PAD_DAYS)
+                hi = (pd.Timestamp(w_end) if w_end else d) + pd.Timedelta(days=1)
+                return lo <= d <= hi
+            except Exception:
+                return True
+
+        rejected = ''
+        # ① 嵌套顶背驰 S1 —— 区间套的本体: 背驰段中套背驰段
+        s1 = sub_an.detect_s1()
+        if s1 is not None:
+            ex2 = s1.extras or {}
+            td = ex2.get('c_high_date', '')
+            tp = ex2.get('c_high')
+            near_top = (parent_top is None or tp is None
+                        or tp >= parent_top * (1 - NESTED_TOP_PRICE_TOL))
+            if in_window(td) and near_top:
+                ptxt = f'(顶¥{tp:.3f}@{td})' if tp else ''
+                return True, (f'{lvl_name}嵌套顶背驰S1{ptxt}落在日线{parent_kind}背驰段窗口内 '
+                              f'—— 第44课区间套: 背驰段中套背驰段, 精确定位顶部, 卖在高位区')
+            rejected = (f'{lvl_name}虽有S1但【不嵌套】(顶@{td or "?"}不在父级背驰段'
+                        f'[{w_start}~{w_end}]窗口内, 或低于父级顶{NESTED_TOP_PRICE_TOL:.0%}以上)'
+                        f' → 属上一波的动能衰竭, 不作本次印证(防卖飞); ')
+        # ①b 父级为S2时, 次级别S2(一卖后反抽确认)也可嵌套印证
+        if parent_kind == 'S2':
+            s2 = sub_an.detect_s2()
+            if s2 is not None:
+                ex2 = s2.extras or {}
+                td = ex2.get('cur_high_date', '')
+                if in_window(td):
+                    return True, (f'{lvl_name}嵌套二卖S2(反抽顶@{td})落在日线S2窗口内 '
+                                  f'—— 第14课: 大级别二卖由次级别相应卖点定位')
+        # ② 转折已确认型: S3 / 末笔已破次级别中枢下沿
+        s3 = sub_an.detect_s3()
+        if s3 is not None:
+            return True, (f'{lvl_name}出现三类卖点S3 —— 第44课: 最后一个次级别中枢出现三卖, '
+                          f'转折已确认(偏晚, 但必须卖)')
+        try:
+            osc = sub_an.zhongshu_oscillation_monitor()
+            if osc.get('alert') and osc.get('direction') == 'down':
+                return True, (f'{lvl_name}末笔已离开其最近中枢下沿(第92课向下变盘) '
+                              f'—— 次级别转折确认, 高位区兑现')
+        except Exception:
+            pass
+        # ③ 次级别上冲动能已竭的当下确认: 末笔向下 + MACD柱已翻负(黄白线收敛下行)。
+        #    第24/44课: 区间套要的是"次级别走势的当下转折"; 末笔转下且红柱消失,
+        #    说明次级别这一冲已经结束 —— 此时日线背驰卖点立即执行, 不再等更深的破位
+        #    (这正是旧版"等30m三卖"卖在低位的病根)。只有次级别仍在上冲(末笔向上/
+        #    红柱未消)时才转入布防, 防的才是真正的"卖飞"。
+        try:
+            last_bi = sub_an.bis[-1] if sub_an.n_bis else None
+            bar_now = float(sub_an.macd_bar.iloc[-1]) if len(sub_an.macd_bar) else 0.0
+            if last_bi is not None and last_bi.direction == 'down' and bar_now < 0:
+                return True, (f'{lvl_name}末笔向下且MACD柱已翻负 —— 第24课: 次级别上冲动能已竭, '
+                              f'当下转折确认, 日线背驰卖点立即执行(不等{lvl_name}跌出三卖)')
+        except Exception:
+            pass
+        return False, (rejected + f'{lvl_name}动能未竭(末笔仍向上/MACD红柱未消): 无嵌套顶背驰/无S3 '
+                       f'→ 第24课: 次级别未转折, 大级别顶未到 → 暂不卖(防卖飞), 转入区间套布防')
+
+    def _confirm_30m_for_buy(self, m30, parent_kind=''):
+        if m30 is None or m30.n_bis < 5:
+            return False, '30分钟笔数不足(<5), 无法做次级别精确印证'
+        if parent_kind == 'B2':
+            if m30.detect_b1() is not None:
+                return True, '30分钟出现一类买点B1 —— 第14课: 大级别第二类买点由次一级别相应走势的一类买点构成'
+            if m30.detect_b2() is not None:
+                return True, '30分钟出现二类买点B2 —— 次级别一买后的回试确认, 属延后确认, 精度低于B1'
+            return False, '30分钟未出现B1/B2 —— 大级别二买缺少次级别买点确认'
+        for fn, name in ((m30.detect_b1,'B1'),(m30.detect_b3,'B3'),(m30.detect_b2,'B2')):
+            if fn() is not None:
+                return True, f'30分钟出现标准买点{name} —— 第44课: 次级别走势确认转折, 日线买点成立'
+        if self.strict:
+            return False, '30分钟未出现任何标准买点(B1/B2/B3) —— 严格模式: 第44课次级别印证未满足, 日线买点暂不成立'
+        if m30.bis[-1].direction == 'up':
+            return True, '30分钟最后一笔向上, 次级别已启动(宽松确认)'
+        return False, '30分钟最后一笔仍向下且无买点, 次级别未确认转折'
+
+    def _confirm_30m_for_sell(self, m30, parent_kind='', parent_sig=None):
+        if m30 is None or m30.n_bis < 5:
+            return False, '30分钟笔数不足(<5), 无法做次级别精确印证'
+        # ── 新: 卖点区间套(第24/44课) —— S1/S2用嵌套顶背驰定位高点 ──
+        if (self.CFG.get('sell_nested_interval') and parent_sig is not None
+                and parent_kind in ('S1', 'S2')):
+            return self._nested_sell_check(m30, parent_sig, '30分钟', parent_kind)
+        # ── 旧逻辑(S3父级 / 开关关闭时) ──
+        if parent_kind == 'S2':
+            if m30.detect_s1() is not None:
+                return True, '30分钟出现一类卖点S1 —— 大级别第二类卖点由次一级别相应走势的一类卖点精确定位'
+            if m30.detect_s2() is not None:
+                return True, '30分钟出现二类卖点S2 —— 次级别一卖后的反抽确认, 属延后确认, 精度低于S1'
+            return False, '30分钟未出现S1/S2 —— 大级别二卖缺少次级别卖点确认'
+        if m30.detect_s3() is not None:
+            return True, '30分钟出现三类卖点S3 —— 严格满足第44课"小背驰-大转折定理"的必要条件(最后一个次级别中枢出现三卖)'
+        if self.strict:
+            return False, '30分钟未出现三类卖点S3 —— 严格模式: 第44课明确要求"最后一个次级别中枢出现三卖", 必要条件未满足, 日线卖点不构成大级别转折'
+        if m30.detect_s1() is not None:
+            return True, '30分钟出现一类卖点(顶背驰), 次级别转折确认(宽松)'
+        if m30.bis[-1].direction == 'down':
+            return True, '30分钟最后一笔向下, 次级别已转弱(宽松确认)'
+        return False, '30分钟未出现卖点且最后一笔仍向上, 次级别未确认转折'
+
+    def _confirm_finer(self, an, is_buy, lvl_name, parent_name, parent_kind='', parent_sig=None):
+        if an is None or an.n_bis < 5:
+            return False, f'{lvl_name}笔数不足(<5), 无法做次级别精确印证'
+        if is_buy:
+            if parent_kind == 'B2':
+                if an.detect_b1() is not None:
+                    return True, f'{lvl_name}出现B1 —— 第14课: {parent_name}二买由次一级别一买构成'
+                if an.detect_b2() is not None:
+                    return True, f'{lvl_name}出现B2 —— 次级别一买后的回试确认, 属延后确认, 精度低于B1'
+                return False, f'{lvl_name}未出现B1/B2 —— {parent_name}二买缺少次级别买点确认'
+            for fn, name in ((an.detect_b1,'B1'),(an.detect_b3,'B3'),(an.detect_b2,'B2')):
+                if fn() is not None:
+                    return True, f'{lvl_name}出现标准买点{name} —— 第44课逐级处理: {lvl_name}走势确认{parent_name}的转折'
+            if self.strict:
+                return False, f'{lvl_name}未出现标准买点(B1/B2/B3) —— 严格模式: 末级印证未满足, 信号降级'
+            if an.bis[-1].direction == 'up':
+                return True, f'{lvl_name}最后一笔向上, 次级别已启动(宽松确认)'
+            return False, f'{lvl_name}最后一笔仍向下且无买点, 末级未确认, 信号降级'
+        else:
+            # ── 新: 卖点区间套向更细级别逐级传递(同一父级背驰段窗口) ──
+            if (self.CFG.get('sell_nested_interval') and parent_sig is not None
+                    and parent_kind in ('S1', 'S2')):
+                ok, note = self._nested_sell_check(an, parent_sig, lvl_name, parent_kind)
+                if ok:
+                    return True, note + f' —— 第44课逐级处理: {lvl_name}确认{parent_name}的转折'
+                return False, note
+            if parent_kind == 'S2':
+                if an.detect_s1() is not None:
+                    return True, f'{lvl_name}出现S1 —— {parent_name}二卖由次一级别一卖精确定位'
+                if an.detect_s2() is not None:
+                    return True, f'{lvl_name}出现S2 —— 次级别一卖后的反抽确认, 属延后确认, 精度低于S1'
+                return False, f'{lvl_name}未出现S1/S2 —— {parent_name}二卖缺少次级别卖点确认'
+            if an.detect_s3() is not None:
+                return True, f'{lvl_name}出现三类卖点S3 —— 第44课逐级处理: {lvl_name}走势确认{parent_name}的转折'
+            if self.strict:
+                return False, f'{lvl_name}未出现三类卖点S3 —— 严格模式: 末级印证未满足, 信号降级'
+            if an.detect_s1() is not None:
+                return True, f'{lvl_name}出现一类卖点(顶背驰), 次级别转折确认(宽松)'
+            if an.bis[-1].direction == 'down':
+                return True, f'{lvl_name}最后一笔向下, 次级别已转弱(宽松确认)'
+            return False, f'{lvl_name}未出现卖点且最后一笔仍向上, 末级未确认, 信号降级'
+
+    def _confirm_5m(self, m5, is_buy, parent_kind='', parent_sig=None):
+        return self._confirm_finer(m5, is_buy, '5分钟', '30分钟', parent_kind, parent_sig)
+
+    def _confirm_1m(self, m1, is_buy, parent_kind='', parent_sig=None):
+        return self._confirm_finer(m1, is_buy, '1分钟', '5分钟', parent_kind, parent_sig)
+
+    def analyze(self, analysis_date=None, positions=None):
+        if self.df_daily.empty or len(self.df_daily) < 30:
+            return None
+        df_d = self.df_daily
+        if analysis_date is not None:
+            analysis_date = pd.Timestamp(analysis_date)
+            df_d = df_d[df_d['date'] <= analysis_date].reset_index(drop=True)
+        if len(df_d) < 30:
+            return None
+        last_date = pd.Timestamp(df_d['date'].iloc[-1])
+        cur_price = float(df_d['close'].iloc[-1])
+
+        if self.df_weekly is not None:
+            df_w = self.df_weekly[self.df_weekly['date'] <= last_date].reset_index(drop=True)
+        else:
+            df_w = resample_weekly(df_d)
+        if self.df_monthly is not None:
+            df_mo = self.df_monthly[self.df_monthly['date'] <= last_date].reset_index(drop=True)
+        else:
+            df_mo = resample_monthly(df_d)
+        _tail = self.SUB_TAIL or {}
+        def _cut_sub(df, lvl):
+            if df is None:
+                return None
+            sub = df[df['date'] <= last_date + pd.Timedelta(days=1)]
+            n = _tail.get(lvl, 0)
+            if n and len(sub) > n:
+                sub = sub.tail(n)
+            return sub.reset_index(drop=True)
+        df_6  = _cut_sub(self.df_60m, '60m')
+        df_m  = _cut_sub(self.df_30m, '30m')
+        df_15 = _cut_sub(self.df_15m, '15m')
+        df_5  = _cut_sub(self.df_5m, '5m')
+        df_1  = _cut_sub(self.df_1m, '1m')
+
+        wv = self._make_view('weekly', df_w, diagnose=False)
+        mov = self._make_view('monthly', df_mo, diagnose=False) if self.CFG.get('use_monthly_gate') else None
+        daily_an = None
+        try:
+            if len(df_d) >= 30:
+                daily_an = _MAKE_ANALYZER('daily', df_d)
+        except Exception:
+            daily_an = None
+        dv = self._make_view('daily', df_d, an=daily_an, diagnose=False) if daily_an is not None \
+            else self._make_view('daily', df_d, diagnose=False)
+
+        m60_an = None
+        m60_built = False
+        def _get_m60():
+            nonlocal m60_an, m60_built
+            if not m60_built:
+                m60_built = True
+                if df_6 is not None and len(df_6) >= 30:
+                    try: m60_an = _MAKE_ANALYZER('60m', df_6)
+                    except Exception: m60_an = None
+            return m60_an
+
+        m30_an = None
+        m30_built = False
+        def _get_m30():
+            nonlocal m30_an, m30_built
+            if not m30_built:
+                m30_built = True
+                if df_m is not None and len(df_m) >= 30:
+                    try: m30_an = _MAKE_ANALYZER('30m', df_m)
+                    except Exception: m30_an = None
+            return m30_an
+
+        def _mv():
+            an = _get_m30()
+            if an is None:
+                return None
+            return self._make_view('30m', df_m, an=an, diagnose=False)
+
+        diagnostics = daily_an.diagnose() if daily_an is not None else {}
+
+        chain = []
+        yearline_dir = 'unknown'; yearline_val = None
+        if len(df_d) >= 60:
+            _n = min(250, len(df_d))
+            yearline_val = float(df_d['close'].tail(_n).mean()) if _n >= 20 else None
+            _ma = df_d['close'].rolling(min(250, len(df_d)), min_periods=20).mean()
+            if len(_ma) and not pd.isna(_ma.iloc[-1]):
+                yearline_val = float(_ma.iloc[-1])
+        if yearline_val is not None:
+            above = cur_price >= yearline_val
+            yearline_dir = 'above' if above else 'below'
+            ytxt = (f'现价¥{cur_price:.3f} {"≥" if above else "<"} 年线MA250 ¥{yearline_val:.3f} '
+                    f'→ {"站上年线, 长线可做多" if above else "年线下方, 第106课不做多(只看反弹/卖点)"}')
+            chain.append(('年线', ytxt,
+                          '第7/106课: 年线(MA250)是长线生命线; 站上才考虑做多, 跌破年线长线转空'))
+        else:
+            chain.append(('年线', '日线历史不足, 年线MA250 暂不可用', '第7/106课'))
+
+        monthly_dir = 'unknown'
+        if mov is not None:
+            monthly_dir = mov.trend
+            chain.append(('monthly', f'{monthly_dir}  (月线定大方向: L69 月线看最实质大方向)',
+                          '第69/108课: 月线分型/笔/线段确定中期大方向; 底部=第一类买点到中枢首次走出三买前'))
+            if self.CFG.get('monthly_ma_filter') and len(df_mo) >= 5:
+                ma5_m = float(df_mo['close'].tail(5).mean())
+                if cur_price < ma5_m and monthly_dir != 'down_trend':
+                    monthly_dir = 'down_trend'
+                    chain.append(('monthly', f'价({cur_price:.2f})在5月线({ma5_m:.2f})下 → 大方向按偏空处理',
+                                  '第106课: 5月线是长线的关键, 牛市第一轮调整不跌破5月线'))
+
+        if wv is None:
+            chain.append(('weekly', '周线数据不足(<30根), 方向未知', ''))
+            weekly_dir = 'unknown'
+        else:
+            weekly_dir = wv.trend
+            dir_txt = {'up_trend':'上涨趋势 → 日线只接受【买点】','down_trend':'下跌趋势 → 日线只接受【卖点】/观望',
+                       'consolidation':'盘整 → 日线买卖点都看,但降级'}.get(weekly_dir, weekly_dir)
+            chain.append(('weekly', f'{weekly_dir}  {dir_txt}',
+                          '第43课: 大级别走势类型限定小级别的操作方向; 不允许"上涨+上涨""下跌+下跌"'))
+
+        if dv is None:
+            return None
+        daily_sig = dv.signal
+        if daily_sig is None:
+            chain.append(('daily', f'{dv.trend}, 无买卖点信号', ''))
+        else:
+            chain.append(('daily', f'出现 {daily_sig.kind}: {daily_sig.reason[:400]}', '第21课: 买卖点完备性定理'))
+
+        if daily_sig is None:
+            action, conf, note = self._no_signal_decision(wv, dv, cur_price)
+            m30_ns = _mv() if self.CFG.get('expose_m30_nosignal') else None
+            return MultiLevelSignal(code=self.code, analysis_date=last_date, weekly=wv, daily=dv, m30=m30_ns,
+                                    action=action, confidence=conf, final_kind='', cur_price=cur_price, chain=chain, note=note,
+                                    diagnostics=diagnostics, monthly=mov)
+
+        is_buy = daily_sig.kind in ('B1','B2','B3')
+        is_sell = daily_sig.kind in ('S1','S2','S3')
+
+        if self.CFG.get('zhongyin_block_buy') and is_buy and daily_sig.kind != 'B3' and daily_an is not None:
+            zy = daily_an.in_zhongyin()
+            if zy.get('in_zhongyin'):
+                chain.append(('中阴', f'第88-90课: 当前处中阴(方向未定+BOLL收口) → 暂不开新仓: {zy["reason"][:120]}', '第89课: ��阴阶段方向未定, 不宜开新仓'))
+                return MultiLevelSignal(code=self.code, analysis_date=last_date, weekly=wv, daily=dv, m30=None,
+                                        action='WATCH', confidence='LOW', final_kind=daily_sig.kind, cur_price=cur_price,
+                                        chain=chain, blocked_reason='中阴方向未定', note='中阴阶段暂不开仓(L88-90)',
+                                        diagnostics=diagnostics, monthly=mov)
+
+        if positions:
+            fail_kinds = []
+            for bk, pos in positions.items():
+                stop = pos.get('stop_px')
+                if stop is not None and cur_price < stop:
+                    fail_kinds.append(bk)
+            if fail_kinds:
+                chain.append(('证伪', f'持仓{"/".join(fail_kinds)}跌破建仓日锁定止损线 → 清仓', '第13/20课: 买点结构被破坏即证伪'))
+                return MultiLevelSignal(code=self.code, analysis_date=last_date, weekly=wv, daily=dv, m30=_mv(),
+                                        action='SELL', confidence='HIGH', final_kind='STOP', cur_price=cur_price,
+                                        chain=chain, note='结构证伪止损, 次日清仓',
+                                        diagnostics=diagnostics, monthly=mov)
+
+        blocked = ''
+        downgrade = False
+        if weekly_dir == 'up_trend' and is_sell:
+            downgrade = True
+            chain.append(('联立','周线上涨 + 日线卖点 → 第44课: 小级别(日线)顶背驰未必引发大级别(周线)转折, 卖点降级为"减仓/短差"',
+                          '第24课: 日线背驰除非周线同时背驰,否则不制造周线大顶'))
+        elif weekly_dir == 'down_trend' and is_buy:
+            if daily_sig.kind in ('B1','B2'):
+                chain.append(('联立','周线下跌 + 日线一/二买 → 下跌趋势的转折尝试, 必须由30分钟严格印证','第29课: 下跌的转折=上涨或盘整, 由背驰导致'))
+            else:
+                blocked = '周线下跌趋势中出现日线三买 —— 第43课: 三买属上涨结构, 与周线下跌矛盾, 大概率是下跌中继的假三买'
+        elif monthly_dir == 'down_trend' and is_buy and daily_sig.kind == 'B3' and not blocked:
+            blocked = '月线下跌大方向中出现日线三买 —— 第43/69课: 三买属上涨结构, 与月线大方向矛盾, 大概率假三买'
+        elif weekly_dir == 'up_trend' and is_buy:
+            chain.append(('联立','周线上涨 + 日线买点 → 方向一致, 进入30分钟精确定位','第43课: 大小级别同向, 操作最顺'))
+        elif weekly_dir == 'down_trend' and is_sell:
+            chain.append(('联立','周线下跌 + 日线卖点 → 方向一致, 趋势性卖出','第43课: 大小级别同向'))
+        elif weekly_dir == 'consolidation':
+            downgrade = True
+            chain.append(('联立','周线盘整 → 日线信号有效但降级(盘整中买卖点力度弱)','第29课: 盘整中的转折力度弱于趋势'))
+
+        # ── 周线二买 → 日线一买精确定位锚 (第14/17课) ──
+        if is_buy and wv is not None and wv.signal is not None \
+                and getattr(wv.signal, 'kind', '') == 'B2':
+            _dex = (daily_sig.extras or {}) if daily_sig is not None else {}
+            _anchor = _dex.get('b1_price') or _dex.get('cur_low')
+            if _anchor:
+                daily_sig.extras = dict(_dex)
+                daily_sig.extras['weekly_b2_daily_b1_anchor'] = float(_anchor)
+                chain.append(('联立',
+                              f'✓ 周线二买 + 日线买点共振: 周线B2由日线一买构成(第14课), '
+                              f'定位锚=日线一买位¥{float(_anchor):.3f}, 跌破该锚则周线二买证伪',
+                              '第17课: 大级别买点的精确定位要落到次级别的具体买点价位'))
+            else:
+                chain.append(('联立',
+                              '周线二买成立但日线尚无可定位的一买锚 → 等日线给出一买价位再重仓',
+                              '第14课'))
+
+        if blocked:
+            return MultiLevelSignal(code=self.code, analysis_date=last_date, weekly=wv, daily=dv, m30=_mv(),
+                                    action='WATCH', confidence='NONE', final_kind=daily_sig.kind, cur_price=cur_price,
+                                    chain=chain, blocked_reason=blocked, note='周线方向闸门拦截, 不操作',
+                                    diagnostics=diagnostics, monthly=mov)
+
+        m60_an = _get_m60()
+        ok60 = False
+        if m60_an is not None:
+            if is_buy:
+                ok60, note60 = self._confirm_finer(m60_an, True, '60分钟', '日线', daily_sig.kind)
+            else:
+                ok60, note60 = self._confirm_finer(m60_an, False, '60分钟', '日线', daily_sig.kind,
+                                                   parent_sig=daily_sig)
+            chain.append(('60m', ('✓ 次级别确认: ' if ok60 else '✗ 次级别未确认(降级): ')+note60,
+                          '第44课: 区间套 —— 日线的转折先由直接次级别60分钟走势确认'))
+            if not ok60:
+                downgrade = True
+                if self.CFG.get('require_60m_buy_confirm') and is_buy and daily_sig.kind in ('B1', 'B2'):
+                    return MultiLevelSignal(code=self.code, analysis_date=last_date, weekly=wv, daily=dv, m30=_mv(),
+                                            action='WATCH', confidence='LOW', final_kind=daily_sig.kind, cur_price=cur_price,
+                                            chain=chain, blocked_reason='60分钟直接次级别未印证买点(L44区间套)',
+                                            note=f'日线{daily_sig.kind}买点但60m未现B1/B2 → 等直接次级别印证再动手',
+                                            diagnostics=diagnostics, monthly=mov)
+        else:
+            if df_6 is not None:
+                chain.append(('60m', '60分钟数据不足(<30根) → 跳过该级印证', '第44课: 区间套逐级确认'))
+
+        m30_an = _get_m30()
+        if m30_an is None:
+            chain.append(('30m','无30分钟数据 → 缺少次级别精确印证, 信号降级','第44课: 操作级别的买卖点需次级别走势确认'))
+            confirmed = False; confirm_note = '缺30分钟数据'; downgrade = True
+        else:
+            if is_buy:
+                confirmed, confirm_note = self._confirm_30m_for_buy(m30_an, daily_sig.kind)
+            else:
+                confirmed, confirm_note = self._confirm_30m_for_sell(m30_an, daily_sig.kind,
+                                                                     parent_sig=daily_sig)
+            chain.append(('30m', ('✓ 次级别确认: ' if confirmed else '✗ 次级别未确认: ')+confirm_note, '第44课: 小背驰-大转折定理(必要条件)'))
+
+        # ── 60m嵌套印证补位 (第44课区间套, 卖点版) ──
+        # 30m动能未竭但60m(日线的直接次级别)已给出嵌套顶背驰/转折确认 → 采信60m。
+        # 日线的"次级别"本就是60m; 30m是60m的次级别, 不应让更细级别一票否决直接次级别。
+        if (self.CFG.get('sell_nested_interval') and is_sell and not confirmed
+                and ok60 and daily_sig.kind in ('S1', 'S2')):
+            confirmed = True
+            confirm_note = '30m动能未竭, 但60m(日线直接次级别)已嵌套印证 → 采信60m(第44课: 逐级处理, 直接次级别优先)'
+            chain.append(('联立', '✓ ' + confirm_note, '第44课区间套'))
+
+        # ── L50 MACD级别选择: 选黄白线和柱子清晰的级别看MACD ──
+        if (self.CFG.get('l50_macd_level_select') and is_buy and not confirmed
+                and ok60 and m60_an is not None and m30_an is not None):
+            try:
+                c60 = m60_an.macd_clarity(); c30 = m30_an.macd_clarity()
+                if c30['score'] < 0.4 and c60['score'] >= max(0.4, c30['score'] * 1.5):
+                    confirmed = True
+                    chain.append(('联立',
+                                  f"✓ L50 MACD级别选择: 30m MACD{c30['label']}(清晰度{c30['score']}) 判据不可靠; "
+                                  f"60m MACD{c60['label']}(清晰度{c60['score']})且60m已印证买点 → 采信60m结论",
+                                  '第50课: 看MACD要选黄白线和柱子走势清晰的级别'))
+            except Exception:
+                pass
+
+        m15_an = None; m15_confirmed = None
+        if confirmed and df_15 is not None and len(df_15) >= 30:
+            try: m15_an = _MAKE_ANALYZER('15m', df_15)
+            except Exception: m15_an = None
+        if not confirmed:
+            pass
+        elif df_15 is None:
+            pass
+        elif m15_an is None:
+            chain.append(('15m','15分钟数据不足(<30根) → 跳过该级印证','第44课: 区间套逐级确认'))
+        else:
+            ok15, note15 = self._confirm_finer(m15_an, is_buy, '15分钟', '30分钟', daily_sig.kind,
+                                               parent_sig=(daily_sig if is_sell else None))
+            m15_confirmed = ok15
+            chain.append(('15m', ('✓ 次级别确认: ' if ok15 else '✗ 次级别未确认(降级,不拦截): ')+note15,
+                          '第44课: 逐级处理 —— 30分钟的转折由15分钟走势确认'))
+            if not ok15: downgrade = True
+
+        m5_an = None; m5_confirmed = None
+        if confirmed and df_5 is not None and len(df_5) >= 30:
+            try: m5_an = _MAKE_ANALYZER('5m', df_5)
+            except Exception: m5_an = None
+        if not confirmed:
+            pass
+        elif df_5 is None:
+            chain.append(('5m','无5分钟数据 → 缺该级逐级印证, 信号降级','第44课: 15分钟的转折需5分钟走势逐级确认')); downgrade = True
+        elif m5_an is None:
+            chain.append(('5m','5分钟数据��足(<30根) → 缺该级印证, 信号降级','第44课: 15分钟的转折需5分钟走势逐级确认')); downgrade = True
+        else:
+            ok5, note5 = self._confirm_5m(m5_an, is_buy, daily_sig.kind,
+                                          parent_sig=(daily_sig if is_sell else None))
+            m5_confirmed = ok5
+            chain.append(('5m', ('✓ 次级别确认: ' if ok5 else '✗ 次级别未确认(降级,不拦截): ')+note5, '第44课: 逐级处理 —— 15分钟的转折由5分钟走势确认'))
+            if not ok5: downgrade = True
+
+        m1_an = None; m1_confirmed = None
+        do_1m = confirmed and (m5_confirmed is True)
+        if do_1m and df_1 is not None and len(df_1) >= 30:
+            try: m1_an = _MAKE_ANALYZER('1m', df_1)
+            except Exception: m1_an = None
+        if not do_1m:
+            pass
+        elif df_1 is None:
+            chain.append(('1m','无1分钟数据 → 缺区间套最末级印证, 信号降级','第44课: 区间套 —— 5分钟的转折需1分钟走势逐级确认')); downgrade = True
+        elif m1_an is None:
+            chain.append(('1m','1分钟数据不足(<30根) → 缺最末级印证, 信号降级','第44课: 区间套 —— 5分钟的转折需1分钟走势逐级确认')); downgrade = True
+        else:
+            ok1, note1 = self._confirm_1m(m1_an, is_buy, daily_sig.kind,
+                                          parent_sig=(daily_sig if is_sell else None))
+            m1_confirmed = ok1
+            chain.append(('1m', ('✓ 末级确认: ' if ok1 else '✗ 末级未确认(降级,不拦截): ')+note1, '第44课: 区间套 —— 5分钟的转折由1分钟走势确认'))
+            if not ok1: downgrade = True
+
+        # ── L24规则: 周线上涨 + 日线【盘整背驰】(非趋势背驰)的S1/S2 ──
+        # 第24课: 某级别的背驰导致该级别的转折; 日线背驰若周线未同步背驰,
+        # 只构成日线级别的调整, 不是大顶 → 不全清仓, 转入区间套布防做短差:
+        # 真转折由布防线(嵌套背驰/破30m中枢ZD/峰值回落)兜底, 趋势延续则由
+        # 撤防机制(强势新高消化背驰, 第26课)继续骑中枢上移(第91课①)。
+        if (self.CFG.get('sell_nested_interval') and self.CFG.get('l24_weekly_uptrend_arm')
+                and is_sell and daily_sig.kind in ('S1', 'S2') and weekly_dir == 'up_trend'):
+            _dg = getattr(daily_sig, 'diverge_grade', None)
+            if _dg is not None and not getattr(_dg, 'is_trend_divergence', False):
+                _arm_zd = (m30_an.pivots[-1].zd if (m30_an is not None and m30_an.n_pivots) else None)
+                _ex = daily_sig.extras or {}
+                _arm_high = _ex.get('c_high') or _ex.get('prev_high') or cur_price
+                chain.append(('L24', f'周线上涨 + 日线{daily_sig.kind}仅为盘整背驰(非趋势背驰) '
+                              f'→ 第24课: 不构成周线级别大顶, 不全清 → 转区间套布防短差'
+                              f'(布防线: 30m中枢ZD{f"¥{_arm_zd:.3f}" if _arm_zd else "暂无"}/'
+                              f'峰值回落{SELL_ARM_PEAK_DROP:.0%}; 强势新高则撤防骑趋势)',
+                              '第24课: 日线背驰除非周线同步背驰, 否则只造成日线级别调整'))
+                return MultiLevelSignal(code=self.code, analysis_date=last_date, weekly=wv, daily=dv, m30=_mv(),
+                                        action='HOLD', confidence='MEDIUM', final_kind=daily_sig.kind,
+                                        cur_price=cur_price, chain=chain,
+                                        note=f'L24: 周线上涨中的日线盘整背驰{daily_sig.kind}, 布防短差不全清',
+                                        sell_armed=True, arm_zd=_arm_zd,
+                                        arm_high=float(_arm_high) if _arm_high else None,
+                                        diagnostics=diagnostics, monthly=mov)
+
+        action = 'BUY' if is_buy else 'SELL'
+        if self.CFG.get('mode') == 'long' and is_sell and daily_sig.kind in ('S1', 'S2'):
+            big_up_long = ((wv is not None and wv.trend == 'up_trend') or
+                           (mov is not None and monthly_dir == 'up_trend'))
+            ma5m_ok = True
+            if len(df_mo) >= 5:
+                ma5m = float(df_mo['close'].tail(5).mean())
+                ma5m_ok = cur_price >= ma5m
+            if big_up_long and ma5m_ok:
+                chain.append(('mode', f'长线模式: 日线{daily_sig.kind}非周线级别转折且大方向上涨 → 持有(操作级别=周线)', '第72课: 看周线则日线调整不构成卖段; 第61课大级别不因小级别震荡卖'))
+                # 长线模式持有也挂上布防线(第44课): 真转折时不至于全程坐滑梯
+                _arm_zd = (m30_an.pivots[-1].zd if (m30_an is not None and m30_an.n_pivots) else None)
+                _ex = daily_sig.extras or {}
+                _arm_high = _ex.get('c_high') or _ex.get('prev_high') or cur_price
+                return MultiLevelSignal(code=self.code, analysis_date=last_date, weekly=wv, daily=dv, m30=_mv(),
+                                        action='HOLD', confidence='MEDIUM', final_kind=daily_sig.kind, cur_price=cur_price,
+                                        chain=chain, note=f'长线模式持有: 日线{daily_sig.kind}属次级别调整, 周线方向未转',
+                                        sell_armed=bool(self.CFG.get('sell_nested_interval')),
+                                        arm_zd=_arm_zd, arm_high=float(_arm_high) if _arm_high else None,
+                                        diagnostics=diagnostics, monthly=mov)
+        if not confirmed:
+            if is_sell:
+                # ── 卖点区间套布防 (第24/44课): 背驰已现但次级别动能未竭 ──
+                # 不立即卖(防卖飞), 也绝不傻等到三卖(防坐滑梯): 持仓转入布防,
+                # 由回测端的布防线(嵌套背驰出现/破30m中枢ZD/峰值回落阈值)收割。
+                # 布防仅用于S1的精确定顶。S2是一卖后的【反抽】卖点(第15课):
+                # 上方空间被一卖高点封死, 反抽本身就是用来卖的, "等次级别动能衰竭"
+                # 与其性质矛盾 → S2未印证时维持"先卖再说"(走下方LOW置信卖出)。
+                if (self.CFG.get('sell_nested_interval') and daily_sig.kind == 'S1'):
+                    arm_zd = (m30_an.pivots[-1].zd if (m30_an is not None and m30_an.n_pivots) else None)
+                    ex = daily_sig.extras or {}
+                    arm_high = ex.get('c_high') or ex.get('prev_high') or cur_price
+                    chain.append(('卖点布防',
+                                  f'日线{daily_sig.kind}背驰已现但次级别动能未竭 → 不立即卖(防卖飞), '
+                                  f'转入区间套布防: ①次级别出现嵌套顶背驰即卖 '
+                                  f'②跌破30m最近中枢下沿ZD{f"¥{arm_zd:.3f}" if arm_zd else "(暂无30m中枢)"}即卖 '
+                                  f'③较布防后峰值回落{SELL_ARM_PEAK_DROP:.0%}即卖',
+                                  '第44课区间套: 背驰段中套背驰段定精确高点; 第24课: 次级别未背驰, 大级别顶未到'))
+                    return MultiLevelSignal(code=self.code, analysis_date=last_date, weekly=wv, daily=dv, m30=_mv(),
+                                            action='HOLD', confidence='MEDIUM', final_kind=daily_sig.kind,
+                                            cur_price=cur_price, chain=chain,
+                                            note=f'区间套布防中: 日线{daily_sig.kind}背驰段内, 等次级别嵌套背驰收敛后高位兑现(第44课)',
+                                            sell_armed=True, arm_zd=arm_zd,
+                                            arm_high=float(arm_high) if arm_high else None,
+                                            confidence_reasons=[f'布防原因: {confirm_note}'],
+                                            diagnostics=diagnostics, monthly=mov)
+                big_up_sell = ((wv is not None and wv.trend == 'up_trend') or
+                               (mov is not None and monthly_dir == 'up_trend'))
+                if self.CFG.get('require_sublevel_sell_confirm') and big_up_sell:
+                    chain.append(('sell_gate', f'日线{daily_sig.kind}卖点但次级别未印证, 且大方向上涨 → 持有(L61: 大级别不因小级别震荡卖)', '第61课: 区间套确认; 大级别操作不因小级别震荡清仓'))
+                    return MultiLevelSignal(code=self.code, analysis_date=last_date, weekly=wv, daily=dv, m30=_mv(),
+                                            action='HOLD', confidence='LOW', final_kind=daily_sig.kind, cur_price=cur_price,
+                                            chain=chain, note=f'日线{daily_sig.kind}卖点次级别未印证+大方向上涨, 持有等确认: {confirm_note}',
+                                            confidence_reasons=[f'次级别未印证持有: {confirm_note}'],
+                                            diagnostics=diagnostics, monthly=mov)
+                chain.append(('sell_gate',f'日线{daily_sig.kind}卖点已成立, 次级别未印证只降级不拦截','第14/15/21课: 买点买、卖点卖; 区间套用于精确定位, 不是否决卖点'))
+                return MultiLevelSignal(code=self.code, analysis_date=last_date, weekly=wv, daily=dv, m30=_mv(),
+                                        action='SELL', confidence='LOW', final_kind=daily_sig.kind, cur_price=cur_price,
+                                        chain=chain, note=f'日线{daily_sig.kind}卖点先执行; 次级别未印证仅降级: {confirm_note}',
+                                        confidence_reasons=[f'次级别未印证: {confirm_note}'],
+                                        diagnostics=diagnostics, monthly=mov)
+            return MultiLevelSignal(code=self.code, analysis_date=last_date, weekly=wv, daily=dv, m30=_mv(),
+                                    action='WATCH', confidence='LOW', final_kind=daily_sig.kind, cur_price=cur_price,
+                                    chain=chain, blocked_reason=f'次级别未印证({confirm_note})',
+                                    note='日线有买/非S1卖信号但次级别未确认 -- 等次级别出信号再动手',
+                                    diagnostics=diagnostics, monthly=mov)
+
+        score = 100; conf_reasons = []
+        def _penalty(pts, reason):
+            nonlocal score
+            score -= pts; conf_reasons.append(f'(-{pts}) {reason}')
+        if mov is not None and monthly_dir == 'down_trend' and is_buy:
+            _penalty(25, '第69课: 月线大方向下跌, 日线买点属逆大方向的转折尝试')
+        trend_piv_lt2 = (daily_an is not None and daily_an.n_trend_pivots < 2)
+        if trend_piv_lt2 and daily_sig.kind in ('B1', 'S1'):
+            _penalty(20, f'第27课: 背驰段前仅{daily_an.n_trend_pivots}个中枢(<2), 盘整背驰非趋势背驰')
+        if daily_an is not None and daily_an.trend == 'consolidation':
+            _penalty(15, '第29课: 日线处盘整结构, 盘整中转折力度弱')
+        daily_dg = getattr(daily_sig, 'diverge_grade', None)
+        if daily_dg is not None and daily_dg.grade == 'WEAK':
+            trig = '面积' if daily_dg.area_ok else 'DIF极值'
+            _penalty(15, f'第27课: 背驰仅满足{trig}单一判据(WEAK), 非标准背驰')
+        if (daily_dg is not None and daily_dg.grade in ('STRONG', 'WEAK')
+                and not daily_dg.is_trend_divergence and not trend_piv_lt2
+                and daily_sig.kind in ('B1', 'S1')):
+            _penalty(10, '第27课: 背驰段为盘整背驰(非趋势背驰), 力度偏弱')
+        if downgrade:
+            _penalty(12, '第44课: 区间套次级别未完全印证(精度降级, 非证伪)')
+        if daily_sig.kind in ('B2', 'S2'):
+            has_delayed = any(lvl in ('30m', '15m', '5m', '1m') and '延后确认' in concl
+                              for lvl, concl, _ in chain)
+            if has_delayed:
+                _penalty(8, '二/二卖由次级别延后确认(非次级别一买/一卖精确定位), 精度略降')
+        ex = daily_sig.extras or {}
+        if daily_sig.kind == 'B3':
+            missing = []
+            if ex.get('b1_price') is None:
+                missing.append('一买')
+            if ex.get('b2_price') is None:
+                missing.append('二买')
+            if missing:
+                _penalty(6, '第20/21课: 三买未能定位对应' + '/'.join(missing) + ', 质量略降')
+            if ex.get('late_trend_b3'):
+                _penalty(12, '第20/92课: 第二个以上同向中枢后的三买, 操作意义下降')
+        if daily_sig.kind == 'S3':
+            missing = []
+            if ex.get('s1_price') is None:
+                missing.append('一卖')
+            if ex.get('s2_price') is None:
+                missing.append('二卖')
+            if missing:
+                _penalty(6, '第20/21课: 三卖未能定位对应' + '/'.join(missing) + ', 质量略降')
+        if daily_dg is not None and daily_dg.grade == 'STRONG' and daily_dg.is_trend_divergence:
+            score += 10; conf_reasons.append('(+10) 第27课: 标准趋势背驰(>=2中枢+面积+DIF), 高质量')
+        # ── 卖点区间套加分: 30m嵌套顶背驰精确定位(卖在高位区) ──
+        if is_sell and any(lvl == '30m' and '嵌套顶背驰' in concl for lvl, concl, _ in chain):
+            score += 8; conf_reasons.append('(+8) 第44课: 30m嵌套顶背驰精确定位, 卖点落在高位区')
+        score = max(0, min(110, score))
+        confidence = 'HIGH' if score >= 70 else ('MEDIUM' if score >= 45 else 'LOW')
+        if conf_reasons:
+            chain.append(('置信度', f'{confidence}(评分{score}) ← ' + '; '.join(conf_reasons),
+                          '第21课: 一二三类买卖点是位置分类非质量排序; 置信度按原著力度条件评分'))
+        else:
+            chain.append(('置信度', f'HIGH(评分{score}) ← 力度条件全部满足',
+                          '第27/29/43课: 方向一致+趋势背驰+趋势结构'))
+        note_parts = []
+        if conf_reasons:
+            note_parts.append(f'置信评分明细: ' + '; '.join(conf_reasons))
+        n_lvl = 3 + (self.df_60m is not None) + (self.df_15m is not None) + (self.df_5m is not None) + (self.df_1m is not None)
+        lvl_txt = {3:'三级别',4:'四级别',5:'五级别',6:'六级别',7:'七级别'}.get(n_lvl, f'{n_lvl}级别')
+        m5_txt = ('/5m已印证' if m5_confirmed is True else '/5m未印证(已降级)' if m5_confirmed is False else '')
+        m1_txt = ('/1m已印证' if m1_confirmed is True else '/1m未印证(已降级)' if m1_confirmed is False else '')
+        note_parts.append(f'{lvl_txt}联立通过: 周线{weekly_dir}/日线{daily_sig.kind}/30m已印证{m5_txt}{m1_txt}')
+        note = ' | '.join(note_parts)
+        return MultiLevelSignal(code=self.code, analysis_date=last_date, weekly=wv, daily=dv, m30=_mv(),
+                                action=action, confidence=confidence, final_kind=daily_sig.kind, cur_price=cur_price,
+                                chain=chain, note=note, confidence_reasons=conf_reasons, diagnostics=diagnostics, monthly=mov)
+
+    @staticmethod
+    def _no_signal_decision(wv, dv, cur_price):
+        if wv is not None and wv.trend == 'up_trend' and dv.trend == 'up_trend':
+            if dv.zg is not None and cur_price > dv.zg:
+                return ('HOLD','NONE', f'周线+日线均上涨且价({cur_price:.2f})在日线ZG({dv.zg:.2f})上, 继续持有等卖点(第108课: 买点入,持有等卖点)')
+            return ('HOLD','NONE','周线日线均上涨, 趋势中持有')
+        if wv is not None and wv.trend == 'down_trend':
+            return ('WATCH','NONE','周线下跌趋势, 无日线买点 → 空仓观望, 不抄底')
+        return ('WATCH','NONE', f'无明确信号(周线{wv.trend if wv else "?"}/日线{dv.trend}), 观望')

data_us.py

@@ -0,0 +1,115 @@
+"""
+data_us.py — US market data layer (yfinance), replacing baostock/pytdx.
+
+Levels & history limits (Yahoo Finance API constraints):
+    daily   : 10 years          (weekly / monthly are resampled from daily
+                                 by chan_multilevel.resample_weekly/_monthly)
+    60m     : last 730 days
+    30m/15m : last 60 days
+    5m      : last 60 days
+    1m      : last 7 days only → too short for Chan decomposition, NOT used.
+              MultiLevelChan handles a missing 1m level gracefully (skips it).
+
+Output schema (identical to the original A-share loaders):
+    date, open, close, high, low, volume, amount
+`amount` (turnover) is approximated as close × volume (Yahoo has no turnover field).
+
+All downloads are cached to parquet under ./_cache_us/<TICKER>/<level>.parquet
+and refreshed when stale (daily: >12h old, intraday: >2h old) or on force=True.
+"""
+from __future__ import annotations
+
+import os
+import time
+import traceback
+
+import pandas as pd
+
+CACHE_DIR = os.environ.get("CHAN_CACHE_DIR", "./_cache_us")
+
+LEVELS = {
+    # level: (yfinance interval, period)
+    "d":   ("1d",  "10y"),
+    "60m": ("60m", "730d"),
+    "30m": ("30m", "60d"),
+    "15m": ("15m", "60d"),
+    "5m":  ("5m",  "60d"),
+}
+
+_STALE_SECONDS = {"d": 12 * 3600, "60m": 2 * 3600, "30m": 2 * 3600,
+                  "15m": 2 * 3600, "5m": 2 * 3600}
+
+
+def _cache_path(ticker: str, level: str) -> str:
+    d = os.path.join(CACHE_DIR, ticker.upper().replace("/", "_"))
+    os.makedirs(d, exist_ok=True)
+    return os.path.join(d, f"{level}.parquet")
+
+
+def _normalize(df: pd.DataFrame) -> pd.DataFrame:
+    """yfinance frame → engine schema (date/open/close/high/low/volume/amount)."""
+    if df is None or len(df) == 0:
+        return pd.DataFrame(columns=["date", "open", "close", "high", "low", "volume", "amount"])
+    d = df.copy()
+    if isinstance(d.columns, pd.MultiIndex):           # yf>=0.2 returns MultiIndex sometimes
+        d.columns = [c[0] if isinstance(c, tuple) else c for c in d.columns]
+    d = d.reset_index()
+    # index column may be 'Date' or 'Datetime'
+    for cand in ("Datetime", "Date", "index"):
+        if cand in d.columns:
+            d = d.rename(columns={cand: "date"})
+            break
+    d.columns = [str(c).lower() for c in d.columns]
+    keep = {"date", "open", "high", "low", "close", "volume"}
+    d = d[[c for c in d.columns if c in keep]]
+    d["date"] = pd.to_datetime(d["date"])
+    # strip timezone so comparisons with naive Timestamps in the engine work
+    try:
+        d["date"] = d["date"].dt.tz_localize(None)
+    except (TypeError, AttributeError):
+        pass
+    d = d.dropna(subset=["open", "high", "low", "close"])
+    d = d.sort_values("date").reset_index(drop=True)
+    d["amount"] = d["close"] * d.get("volume", 0)
+    return d[["date", "open", "close", "high", "low", "volume", "amount"]]
+
+
+def load_level(ticker: str, level: str, force: bool = False) -> pd.DataFrame:
+    """Load one level for a ticker, using parquet cache when fresh."""
+    assert level in LEVELS, f"unknown level {level}"
+    path = _cache_path(ticker, level)
+    if not force and os.path.exists(path):
+        age = time.time() - os.path.getmtime(path)
+        if age < _STALE_SECONDS[level]:
+            try:
+                return pd.read_parquet(path)
+            except Exception:
+                pass
+    try:
+        import yfinance as yf
+        interval, period = LEVELS[level]
+        raw = yf.Ticker(ticker).history(period=period, interval=interval,
+                                        auto_adjust=True, actions=False)
+        df = _normalize(raw)
+        if len(df):
+            df.to_parquet(path, index=False)
+            return df
+    except Exception:
+        traceback.print_exc()
+    # network failed → fall back to stale cache if any
+    if os.path.exists(path):
+        try:
+            return pd.read_parquet(path)
+        except Exception:
+            pass
+    return pd.DataFrame(columns=["date", "open", "close", "high", "low", "volume", "amount"])
+
+
+def load_all_levels(ticker: str, force: bool = False) -> dict:
+    """Return {'d':…, '60m':…, '30m':…, '15m':…, '5m':…} (1m intentionally absent)."""
+    return {lvl: load_level(ticker, lvl, force=force) for lvl in LEVELS}
+
+
+def last_daily_date(ticker: str):
+    df = load_level(ticker, "d")
+    return None if df.empty else pd.Timestamp(df["date"].iloc[-1])

llm_local.py

@@ -0,0 +1,107 @@
+"""
+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.
+"""
+import os
+import re
+import threading
+
+from huggingface_hub import hf_hub_download
+
+# name -> (HF repo, gguf filename, note)
+MODEL_ZOO = {
+    "Qwen3-4B  · fastest, fine on 2-vCPU Space": (
+        "Qwen/Qwen3-4B-GGUF", "Qwen3-4B-Q4_K_M.gguf"),
+    "Qwen3-8B  · recommended balance": (
+        "Qwen/Qwen3-8B-GGUF", "Qwen3-8B-Q4_K_M.gguf"),
+    "Qwen3-14B · best quality (needs ~12 GB RAM / GPU Space)": (
+        "Qwen/Qwen3-14B-GGUF", "Qwen3-14B-Q4_K_M.gguf"),
+}
+DEFAULT_MODEL = "Qwen3-4B  · fastest, fine on 2-vCPU Space"
+
+_lock = threading.Lock()
+_llm = None
+_loaded_name = None
+
+_THINK_RE = re.compile(r"<think>.*?</think>", re.S)
+
+
+def status() -> str:
+    if _llm is None:
+        return "No model loaded — AI features are off. Pick a model and press Load."
+    return f"Loaded: {_loaded_name}  (llama.cpp, local inference)"
+
+
+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."""
+    global _llm, _loaded_name
+    repo, fname = MODEL_ZOO[name]
+    with _lock:
+        if _loaded_name == name and _llm is not None:
+            return f"Already loaded: {name}"
+        try:
+            from llama_cpp import Llama
+        except Exception as e:  # llama-cpp-python missing / failed to build
+            return f"llama-cpp-python is not available: {e}"
+        try:
+            path = hf_hub_download(repo_id=repo, filename=fname)
+        except Exception as e:
+            return f"Could not download {repo}/{fname}: {e}"
+        try:
+            _llm = None
+            _llm = Llama(
+                model_path=path,
+                n_ctx=8192,
+                n_threads=max(2, (os.cpu_count() or 4)),
+                verbose=False,
+            )
+            _loaded_name = name
+            return f"Loaded: {name}"
+        except Exception as e:
+            _llm = None
+            _loaded_name = None
+            return f"Failed to load model: {e}"
+
+
+DEFAULT_SYSTEM = ("You are the analysis brain of Chan Compass, a US-equity "
+                  "dashboard. Answer in clear, concise English.")
+
+
+def is_loaded() -> bool:
+    return _llm is not None
+
+
+def chat(user: str, max_tokens: int = 900, temperature: float = 0.3,
+         system: str = DEFAULT_SYSTEM) -> str:
+    """One chat turn. Qwen3 thinking mode is disabled with /no_think
+    (we want fast, deterministic summaries, not long reasoning traces)."""
+    if _llm is None:
+        return ""
+    with _lock:
+        try:
+            out = _llm.create_chat_completion(
+                messages=[
+                    {"role": "system", "content": system + " /no_think"},
+                    {"role": "user", "content": user},
+                ],
+                max_tokens=max_tokens,
+                temperature=temperature,
+            )
+            txt = out["choices"][0]["message"]["content"] or ""
+            return _THINK_RE.sub("", txt).strip()
+        except Exception as e:
+            return f"(model error: {e})"

news_watch.py

@@ -0,0 +1,123 @@
+"""
+news_watch.py — daily news check for held tickers (US version, yfinance.news).
+
+Rule requested by the user: for each holding, look only at TODAY's news.
+If there is news → push a short AI brief. If there is none → ignore (the
+ticker is listed under "Quiet today" so you know it was checked).
+"""
+from __future__ import annotations
+
+import datetime as dt
+import os
+import traceback
+
+HOLDINGS_FILE = "./_app_output/holdings.txt"
+os.makedirs(os.path.dirname(HOLDINGS_FILE), exist_ok=True)
+
+
+# ── holdings persistence ─────────────────────────────────────────────────
+def load_holdings() -> list:
+    try:
+        with open(HOLDINGS_FILE, encoding="utf-8") as f:
+            return [x.strip().upper() for x in f if x.strip()]
+    except FileNotFoundError:
+        return []
+
+
+def save_holdings(tickers: list):
+    seen, out = set(), []
+    for t in tickers:
+        t = t.strip().upper()
+        if t and t not in seen:
+            seen.add(t)
+            out.append(t)
+    with open(HOLDINGS_FILE, "w", encoding="utf-8") as f:
+        f.write("\n".join(out))
+    return out
+
+
+# ── news fetch ───────────────────────────────────────────────────────────
+def _today_utc() -> dt.date:
+    return dt.datetime.now(dt.timezone.utc).date()
+
+
+def fetch_today_news(ticker: str) -> list:
+    """Return today's news items: [{'title','publisher','time','link'}…]."""
+    try:
+        import yfinance as yf
+        items = yf.Ticker(ticker).news or []
+    except Exception:
+        traceback.print_exc()
+        return []
+    today = _today_utc()
+    out = []
+    for it in items:
+        # yfinance has two schemas: legacy flat dict, or {'content': {...}}
+        c = it.get("content", it)
+        title = c.get("title") or ""
+        ts = it.get("providerPublishTime")
+        when = None
+        if ts:
+            when = dt.datetime.fromtimestamp(ts, dt.timezone.utc)
+        else:
+            pub = c.get("pubDate") or c.get("displayTime")
+            if pub:
+                try:
+                    when = dt.datetime.fromisoformat(str(pub).replace("Z", "+00:00"))
+                except ValueError:
+                    when = None
+        if when is None or when.date() != today:
+            continue
+        pubr = c.get("publisher") or (c.get("provider") or {}).get("displayName") or ""
+        link = c.get("link") or (c.get("canonicalUrl") or {}).get("url") or ""
+        if title:
+            out.append({"title": title, "publisher": pubr,
+                        "time": when.strftime("%H:%M UTC"), "link": link})
+    return out
+
+
+def _llm_brief(ticker: str, items: list) -> str:
+    heads = "\n".join(f"- [{x['time']}] {x['title']} ({x['publisher']})" for x in items)
+    try:
+        import llm_local
+        if not llm_local.is_loaded():
+            return ""
+        prompt = (
+            f"You are an equity news analyst. Today's headlines for {ticker} "
+            f"(a stock the user currently HOLDS):\n{heads}\n\n"
+            "In English, ≤90 words: 1) one-line summary; 2) tag the net read as "
+            "POSITIVE / NEGATIVE / NEUTRAL for the holding; 3) one suggested "
+            "action (e.g. 'no action', 'review stop level', 'watch earnings'). "
+            "Be specific, no disclaimers."
+        )
+        return llm_local.chat(prompt, max_tokens=240)
+    except Exception:
+        return ""
+
+
+def check_holdings_news(tickers=None) -> str:
+    """Markdown report: AI brief per holding with today-news; quiet list otherwise."""
+    tickers = tickers if tickers is not None else load_holdings()
+    if not tickers:
+        return ("**No holdings configured.** Add tickers above (e.g. `AAPL, NVDA`) "
+                "and save — they'll be checked for news every day.")
+    blocks, quiet = [], []
+    for t in tickers:
+        items = fetch_today_news(t)
+        if not items:
+            quiet.append(t)
+            continue
+        lines = [f"### 📰 {t} — {len(items)} item(s) today"]
+        for x in items[:6]:
+            link = f" · [link]({x['link']})" if x["link"] else ""
+            lines.append(f"- **{x['time']}** {x['title']} — *{x['publisher']}*{link}")
+        brief = _llm_brief(t, items)
+        if brief:
+            lines.append(f"\n> 🤖 **AI brief:** {brief}")
+        else:
+            lines.append("\n> _Load a model in the Model tab for an AI brief._")
+        blocks.append("\n".join(lines))
+    if quiet:
+        blocks.append(f"**Quiet today (no news, ignored):** {', '.join(quiet)}")
+    stamp = dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
+    return f"_Checked {stamp}_\n\n" + ("\n\n---\n\n".join(blocks) if blocks else "No output.")

requirements.txt

@@ -0,0 +1,8 @@
+gradio>=4.44
+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

research.py

@@ -0,0 +1,121 @@
+"""
+research.py — Research Note (beta): a first slice of "Auto Research / auto report".
+
+V1 scope (what this file does today):
+    input ticker → pull fundamentals via yfinance .info + recent headlines
+    → local LLM writes a structured English research note covering
+      valuation, moat / supply-chain position, bull vs bear case, key risks.
+
+V2 (not built yet, see Automation tab description):
+    multi-step agentic research (filings, peers, news crawl) and an automatic
+    trigger that generates a report whenever a NEW ticker enters the pool.
+"""
+from __future__ import annotations
+
+import traceback
+
+
+_FIELDS = [
+    ("longName", "Name"), ("sector", "Sector"), ("industry", "Industry"),
+    ("marketCap", "Market cap"), ("trailingPE", "P/E (ttm)"),
+    ("forwardPE", "P/E (fwd)"), ("priceToSalesTrailing12Months", "P/S (ttm)"),
+    ("priceToBook", "P/B"), ("enterpriseToEbitda", "EV/EBITDA"),
+    ("profitMargins", "Net margin"), ("grossMargins", "Gross margin"),
+    ("operatingMargins", "Operating margin"), ("returnOnEquity", "ROE"),
+    ("revenueGrowth", "Revenue growth (yoy)"), ("earningsGrowth", "Earnings growth (yoy)"),
+    ("freeCashflow", "Free cash flow"), ("totalCash", "Total cash"),
+    ("totalDebt", "Total debt"), ("dividendYield", "Dividend yield"),
+    ("beta", "Beta"), ("fiftyTwoWeekHigh", "52w high"), ("fiftyTwoWeekLow", "52w low"),
+    ("currentPrice", "Price"), ("targetMeanPrice", "Analyst mean target"),
+    ("recommendationKey", "Street view"),
+]
+
+
+def _fmt(key: str, v):
+    if v is None:
+        return None
+    try:
+        if key in ("marketCap", "freeCashflow", "totalCash", "totalDebt"):
+            v = float(v)
+            return f"${v/1e9:,.1f}B" if abs(v) >= 1e9 else f"${v/1e6:,.0f}M"
+        if key in ("profitMargins", "grossMargins", "operatingMargins", "returnOnEquity",
+                   "revenueGrowth", "earningsGrowth", "dividendYield"):
+            return f"{float(v):.1%}"
+        if isinstance(v, float):
+            return f"{v:,.2f}"
+    except (TypeError, ValueError):
+        pass
+    return str(v)
+
+
+def gather_facts(ticker: str) -> tuple:
+    """Return (facts_markdown, facts_plain, error)."""
+    try:
+        import yfinance as yf
+        tk = yf.Ticker(ticker)
+        info = tk.info or {}
+    except Exception as e:
+        traceback.print_exc()
+        return "", "", f"Could not fetch fundamentals for {ticker}: {e}"
+    if not info or info.get("regularMarketPrice") is None and info.get("currentPrice") is None \
+            and not info.get("longName"):
+        return "", "", f"No fundamentals returned for {ticker} — check the symbol."
+    rows, plain = [], []
+    for key, label in _FIELDS:
+        val = _fmt(key, info.get(key))
+        if val is None:
+            continue
+        rows.append(f"| {label} | {val} |")
+        plain.append(f"{label}: {val}")
+    summary = (info.get("longBusinessSummary") or "")[:900]
+    heads = []
+    try:
+        import news_watch
+        for x in (tk.news or [])[:6]:
+            c = x.get("content", x)
+            t = c.get("title")
+            if t:
+                heads.append(t)
+    except Exception:
+        pass
+    md = f"**{info.get('longName', ticker)}** ({ticker})\n\n"
+    md += "| Metric | Value |\n|---|---|\n" + "\n".join(rows)
+    if heads:
+        md += "\n\n**Recent headlines:** " + " · ".join(heads[:5])
+    plain_txt = "\n".join(plain)
+    if summary:
+        plain_txt += f"\nBusiness: {summary}"
+    if heads:
+        plain_txt += "\nRecent headlines: " + " | ".join(heads)
+    return md, plain_txt, ""
+
+
+def research_note(ticker: str) -> str:
+    """Generate the beta research note (markdown)."""
+    ticker = (ticker or "").strip().upper()
+    if not ticker:
+        return "Enter a ticker symbol first."
+    facts_md, facts_plain, err = gather_facts(ticker)
+    if err:
+        return f"⚠️ {err}"
+    note = ""
+    try:
+        import llm_local
+        if llm_local.is_loaded():
+            prompt = (
+                f"You are a buy-side equity analyst. Using ONLY the facts below, write a "
+                f"concise English research note on {ticker} (≤400 words) with EXACTLY these "
+                f"sections:\n"
+                f"## Snapshot\n## Valuation\n## Moat & supply-chain position\n"
+                f"## Bull case\n## Bear case\n## Key risks & verdict\n"
+                f"In Valuation, judge whether multiples look cheap/fair/rich vs the growth "
+                f"and margins shown. In Moat, infer the company's position in its industry "
+                f"value chain. Be specific; if a fact is missing, say 'n/a' rather than "
+                f"inventing it. No investment-advice disclaimers.\n\nFACTS:\n{facts_plain}"
+            )
+            note = llm_local.chat(prompt, max_tokens=900)
+    except Exception as e:
+        note = f"_(LLM error: {e})_"
+    if not note:
+        note = "_Load a model in the **Model** tab to generate the written analysis._"
+    return f"{facts_md}\n\n---\n\n{note}\n\n_Research Note (beta) · data: Yahoo Finance · model: local GGUF_"

rotation.py

@@ -0,0 +1,155 @@
+"""
+rotation.py — US sector capital-rotation monitor.
+
+True money-flow data for US equities (e.g. tick-rule buy/sell imbalance per
+sector) is a paid dataset. The standard free proxy — used here — is the family
+of 11 SPDR sector ETFs, which together cover the entire S&P 500:
+
+    flow_proxy($) = price_change% × dollar volume (close × volume)
+
+A sector whose ETF rises on heavy dollar volume is absorbing capital; one that
+falls on heavy dollar volume is shedding it. We also compute relative strength
+vs SPY so "everything up / everything down" days don't mask rotation.
+
+Windows: 1-day (today's rotation), 5-day (week trend), 20-day (month trend).
+"""
+from __future__ import annotations
+
+import pandas as pd
+
+import data_us
+
+SECTOR_ETFS = {
+    "XLK": "Technology",
+    "XLF": "Financials",
+    "XLE": "Energy",
+    "XLV": "Health Care",
+    "XLY": "Consumer Discretionary",
+    "XLP": "Consumer Staples",
+    "XLI": "Industrials",
+    "XLB": "Materials",
+    "XLU": "Utilities",
+    "XLRE": "Real Estate",
+    "XLC": "Communication Services",
+}
+BENCH = "SPY"
+
+
+def _window_stats(df: pd.DataFrame, n: int):
+    """Return (pct_change, avg dollar volume, flow proxy $) over last n bars."""
+    if df is None or len(df) < n + 1:
+        return None
+    closes = df["close"].iloc[-(n + 1):]
+    pct = float(closes.iloc[-1] / closes.iloc[0] - 1.0)
+    dvol = float((df["close"].iloc[-n:] * df["volume"].iloc[-n:]).mean())
+    return pct, dvol, pct * dvol
+
+
+def build_rotation(force: bool = False):
+    """Compute the rotation table. Returns (df_1d, df_5d, df_20d, asof_str)."""
+    frames = {}
+    for tk in list(SECTOR_ETFS) + [BENCH]:
+        frames[tk] = data_us.load_level(tk, "d", force=force)
+
+    spy = frames[BENCH]
+    asof = "—"
+    if spy is not None and len(spy):
+        asof = pd.Timestamp(spy["date"].iloc[-1]).strftime("%Y-%m-%d")
+
+    out = {}
+    for n, label in ((1, "1D"), (5, "5D"), (20, "20D")):
+        rows = []
+        spy_stats = _window_stats(spy, n)
+        spy_pct = spy_stats[0] if spy_stats else 0.0
+        for tk, name in SECTOR_ETFS.items():
+            st = _window_stats(frames[tk], n)
+            if st is None:
+                continue
+            pct, dvol, flow = st
+            rows.append({
+                "Sector": name,
+                "ETF": tk,
+                "Change": pct,
+                "Avg $ Volume": dvol,
+                "Flow proxy": flow,
+                "RS vs SPY": pct - spy_pct,
+            })
+        if not rows:
+            out[label] = pd.DataFrame()
+            continue
+        df = pd.DataFrame(rows).sort_values("Flow proxy", ascending=False).reset_index(drop=True)
+        out[label] = df
+    return out.get("1D"), out.get("5D"), out.get("20D"), asof
+
+
+def fmt_table(df: pd.DataFrame) -> pd.DataFrame:
+    """Human-readable formatting for the UI."""
+    if df is None or df.empty:
+        return pd.DataFrame(columns=["Sector", "ETF", "Change", "$ Volume (avg)",
+                                     "Flow proxy", "RS vs SPY", "Read"])
+    d = df.copy()
+
+    def _money(x):
+        ax = abs(x)
+        if ax >= 1e9:
+            return f"${x/1e9:,.2f}B"
+        if ax >= 1e6:
+            return f"${x/1e6:,.1f}M"
+        return f"${x:,.0f}"
+
+    def _read(row):
+        if row["Flow proxy"] > 0 and row["RS vs SPY"] > 0:
+            return "🟢 Inflow + leading"
+        if row["Flow proxy"] > 0:
+            return "🟩 Inflow"
+        if row["Flow proxy"] < 0 and row["RS vs SPY"] < 0:
+            return "🔴 Outflow + lagging"
+        if row["Flow proxy"] < 0:
+            return "🟥 Outflow"
+        return "—"
+
+    d["Read"] = d.apply(_read, axis=1)
+    d["$ Volume (avg)"] = d["Avg $ Volume"].map(_money)
+    d["Flow proxy"] = d["Flow proxy"].map(_money)
+    d["Change"] = d["Change"].map(lambda x: f"{x:+.2%}")
+    d["RS vs SPY"] = d["RS vs SPY"].map(lambda x: f"{x:+.2%}")
+    return d[["Sector", "ETF", "Change", "$ Volume (avg)", "Flow proxy", "RS vs SPY", "Read"]]
+
+
+def rotation_brief(df_1d, df_5d, df_20d) -> str:
+    """Plain-text summary fed to the local LLM (and shown as fallback)."""
+    def top_bottom(df, label):
+        if df is None or df.empty:
+            return f"{label}: no data."
+        top = df.head(3)
+        bot = df.tail(3)
+        t = ", ".join(f"{r.Sector} ({r.Change:+.2%}, RS {r['RS vs SPY']:+.2%})"
+                      for _, r in top.iterrows())
+        b = ", ".join(f"{r.Sector} ({r.Change:+.2%}, RS {r['RS vs SPY']:+.2%})"
+                      for _, r in bot.iterrows())
+        return f"{label} — capital flowing INTO: {t}. Flowing OUT OF: {b}."
+    return "\n".join([top_bottom(df_1d, "1-day"),
+                      top_bottom(df_5d, "5-day"),
+                      top_bottom(df_20d, "20-day")])
+
+
+def llm_narrative(df_1d, df_5d, df_20d) -> str:
+    """Ask the local model for a short rotation read; graceful fallback."""
+    brief = rotation_brief(df_1d, df_5d, df_20d)
+    try:
+        import llm_local
+        if not llm_local.is_loaded():
+            return ("_Load a model in the **Model** tab to get an AI rotation "
+                    "narrative._\n\n**Raw read:**\n" + brief)
+        prompt = (
+            "You are a US equity market strategist. Based only on the sector "
+            "flow data below (SPDR sector ETF proxy: change% × dollar volume, "
+            "plus relative strength vs SPY), write a crisp English brief "
+            "(<180 words) with three parts: 1) Where capital is rotating INTO "
+            "and OUT OF right now; 2) whether 1-day moves agree with the 5/20-day "
+            "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)
+    except Exception as e:
+        return f"**Raw read:**\n{brief}\n\n_(LLM unavailable: {e})_"

signal_runner.py

@@ -0,0 +1,124 @@
+"""
+signal_runner.py — run the (unchanged) Chan multi-level engine over a US ticker pool.
+
+Levels per ticker:  monthly / weekly  (resampled from 10y daily)
+                    daily             (yfinance 1d)
+                    60m / 30m / 15m / 5m  (yfinance intraday)
+                    1m                (not available beyond 7 days on Yahoo → skipped;
+                                       MultiLevelChan degrades gracefully)
+"""
+from __future__ import annotations
+
+import os
+import traceback
+
+import pandas as pd
+
+import chan_glue  # noqa: F401  (wires engine into chan_multilevel, installs cached factory)
+from chan_glue import MultiLevelChan, resample_weekly, resample_monthly
+import chan_enhance
+import data_us
+
+DEFAULT_POOL = ["AAPL", "MSFT", "NVDA", "TSLA", "AMZN", "GOOGL", "META", "AMD", "NFLX", "JPM"]
+
+OUT_DIR = "./_app_output"
+os.makedirs(OUT_DIR, exist_ok=True)
+
+ACTION_BADGE = {"BUY": "🟢 BUY", "SELL": "🔴 SELL", "HOLD": "🟡 HOLD", "WATCH": "⚪ WATCH"}
+KIND_EN = {
+    "B1": "B1 · 1st buy (trend-end divergence)",
+    "B2": "B2 · 2nd buy (higher-low retest)",
+    "B3": "B3 · 3rd buy (pivot breakout retest)",
+    "S1": "S1 · 1st sell (top divergence)",
+    "S2": "S2 · 2nd sell (lower-high rebound)",
+    "S3": "S3 · 3rd sell (pivot breakdown)",
+    "STOP": "STOP · structural stop-loss",
+    "": "—",
+}
+TREND_EN = {"up_trend": "Up", "down_trend": "Down", "consolidation": "Range",
+            "expanding": "Expanding", "unknown": "?", "": "?"}
+
+
+def analyze_one(ticker: str, force: bool = False):
+    """Run multi-level Chan analysis for one ticker. Returns (row_dict, detail_text)."""
+    dfs = data_us.load_all_levels(ticker, force=force)
+    d = dfs["d"]
+    if d is None or len(d) < 60:
+        return None, f"{ticker}: not enough daily history ({0 if d is None else len(d)} bars)."
+    w = resample_weekly(d)
+    m = resample_monthly(d)
+
+    ml = MultiLevelChan(
+        df_daily=d, df_weekly=w, df_monthly=m,
+        df_60m=dfs.get("60m"), df_30m=dfs.get("30m"),
+        df_15m=dfs.get("15m"), df_5m=dfs.get("5m"),
+        df_1m=None,  # Yahoo 1m history (7 days) is too short for Chan decomposition
+        code=ticker, strict=True,
+    )
+    res = ml.analyze()
+    if res is None:
+        return None, f"{ticker}: analysis returned no result (insufficient structure)."
+
+    enh = chan_enhance.predict_enhance(res)
+    weight = enh.get("suggest_weight")
+    row = {
+        "Ticker": ticker,
+        "Action": ACTION_BADGE.get(res.action, res.action),
+        "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],
+        "_action_raw": res.action,
+        "_kind_raw": res.final_kind,
+        "_date": res.analysis_date.strftime("%Y-%m-%d"),
+    }
+    detail = res.explain()
+    extra_lines = []
+    for k in ("l16_note", "l37_note", "evo_hint", "l92_warn"):
+        if enh.get(k):
+            extra_lines.append("  " + enh[k])
+    if extra_lines:
+        detail += "\n  ── 增强提示 (chan_enhance) ──\n" + "\n".join(extra_lines)
+    return row, detail
+
+
+def run_signals(tickers=None, force: bool = False):
+    """Run the whole pool. Returns (DataFrame, {ticker: detail}, summary_str)."""
+    tickers = [t.strip().upper() for t in (tickers or DEFAULT_POOL) if t.strip()]
+    rows, details, errors = [], {}, []
+    for t in tickers:
+        try:
+            row, detail = analyze_one(t, force=force)
+            if row is None:
+                errors.append(detail)
+                continue
+            rows.append(row)
+            details[t] = detail
+        except Exception as e:
+            traceback.print_exc()
+            errors.append(f"{t}: {e}")
+    if rows:
+        df = pd.DataFrame(rows)
+        order = {"BUY": 0, "SELL": 1, "HOLD": 2, "WATCH": 3}
+        df["_o"] = df["_action_raw"].map(order).fillna(9)
+        df = df.sort_values(["_o", "Ticker"]).drop(columns=["_o"]).reset_index(drop=True)
+        show = df.drop(columns=[c for c in df.columns if c.startswith("_")])
+        try:
+            df.to_csv(os.path.join(OUT_DIR, "signals_latest.csv"), index=False)
+        except Exception:
+            pass
+    else:
+        show = pd.DataFrame(columns=["Ticker", "Action", "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 "—"
+    summary = (f"Analyzed {len(rows)}/{len(tickers)} tickers · as of {asof} · "
+               f"{n_buy} BUY · {n_sell} SELL")
+    if errors:
+        summary += f" · {len(errors)} skipped"
+    return show, details, summary, errors