aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/apps/cli/handlers/market_handlers.py

@@ -0,0 +1,2570 @@
+"""Market data handlers extracted from aria_cli.py.
+
+Handles market data prefetching, snapshot rows, and full snapshot analysis.
+Imports market detection helpers from apps.cli.utils.market_detect.
+_HAS_MDC and _get_mdc are resolved via lazy import to avoid circular deps.
+"""
+from __future__ import annotations
+import json
+import os
+import re
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from aria_code.apps.cli.utils.market_detect import (
+    _re_sym, _STOCK_PATTERN,
+    _CRYPTO_WORDS, _COMPANY_TO_TICKER,
+    _FINANCIAL_TERMS_BLOCKLIST,
+    _extract_market_symbol, _extract_market_symbols, _extract_symbol_from_history,
+    _is_realty_query, _is_market_snapshot_request,
+    _format_compact_market_cap, _market_snapshot_trend,
+    _has_unresolved_company_mention,
+    _detect_market_overview,
+    _PRIVATE_COMPANY_PROFILES,
+)
+from aria_code.apps.cli.market_hours import market_session
+from aria_code.apps.cli.market_metadata import enrich_market_quote, market_display_label
+from aria_code.packages.aria_core.paths import aria_home
+
+_PROVIDERS_FILE = aria_home() / "providers.json"
+
+
+def _detect_lang(text: str) -> str:
+    """Return 'zh' for predominantly Chinese input, 'en' otherwise."""
+    if not text:
+        return "zh"
+    zh_chars = sum(1 for c in text if '一' <= c <= '鿿')
+    return "zh" if zh_chars / max(len(text), 1) > 0.15 else "en"
+
+
+# ── TA session cache (populated during prefetch, read during snapshot) ────────
+_TA_SESSION_CACHE: dict = {}
+_TA_SESSION_CACHE_TTL = 600  # 10 minutes
+_LEVEL_HISTORY_CACHE: dict = {}
+_LEVEL_HISTORY_CACHE_TTL = 300  # 5 minutes
+
+
+def _fmt_int(value) -> str:
+    try:
+        return f"{int(float(value)):,}"
+    except Exception:
+        return "N/A"
+
+
+def _num_or_none(value):
+    try:
+        if value in (None, "", "N/A", "-", "nan"):
+            return None
+        out = float(value)
+        return out if out == out else None
+    except Exception:
+        return None
+
+
+def _fmt_money(currency: str, value) -> str:
+    num = _num_or_none(value)
+    if num is None:
+        return "—"
+    return f"{currency} {num:,.2f}"
+
+
+def _clean_provider_chain(providers) -> list[str]:
+    generic = {
+        "quote",
+        "fundamentals",
+        "technical",
+        "history",
+        "market_data_client",
+        "market_data_client.quote",
+        "market_data_client.fundamentals",
+        "market_data_client.technical_indicators",
+    }
+    out: list[str] = []
+    for provider in providers or []:
+        p = str(provider or "").strip()
+        if not p or p in generic:
+            continue
+        if p not in out:
+            out.append(p)
+    return out
+
+
+def _snapshot_signal(price, change_pct, rsi, macd_hist, ma20, ma60) -> tuple[str, int, float, str]:
+    """Return (signal, score, confidence, label) for a compact market snapshot."""
+    enough = any(v is not None for v in (rsi, macd_hist, ma20, ma60))
+    if not enough:
+        return "—", 0, 0.0, "指标不足"
+    score = 0
+    if ma20 is not None and price is not None:
+        score += 1 if price > ma20 else -1
+    if ma60 is not None and price is not None:
+        score += 1 if price > ma60 else -1
+    if macd_hist is not None:
+        score += 1 if macd_hist > 0 else -1 if macd_hist < 0 else 0
+    if rsi is not None:
+        if rsi <= 30:
+            score += 2
+        elif rsi <= 40:
+            score += 1
+        elif rsi >= 75:
+            score -= 2
+        elif rsi >= 65:
+            score -= 1
+    if change_pct is not None:
+        if change_pct >= 2:
+            score += 1
+        elif change_pct <= -2:
+            score -= 1
+
+    if score >= 4:
+        signal, label = "STRONG_BUY", "强势多头"
+    elif score >= 2:
+        signal, label = "BUY", "偏多"
+    elif score <= -4:
+        signal, label = "STRONG_SELL", "强势空头"
+    elif score <= -2:
+        signal, label = "SELL", "偏空"
+    elif score == 1:
+        signal, label = "HOLD+", "短线偏强"
+    elif score == -1:
+        signal, label = "HOLD-", "短线偏弱"
+    else:
+        signal, label = "NEUTRAL", "震荡观察"
+    confidence = min(0.82, 0.46 + abs(score) * 0.07)
+    return signal, score, confidence, label
+
+
+# _snapshot_signal's labels, for a reply in English.
+_SIGNAL_LABELS_EN = {
+    "强势多头": "strongly bullish", "偏多": "bullish", "短线偏强": "short-term firm",
+    "震荡观察": "range-bound", "短线偏弱": "short-term soft", "偏空": "bearish",
+    "强势空头": "strongly bearish", "指标不足": "insufficient data",
+}
+
+
+def _support_resistance_for_row(currency: str, price, ma20, ma60, bb_lower, bb_upper) -> tuple[str, str]:
+    p = _num_or_none(price)
+    if p is None:
+        return "", ""
+    supports = sorted(
+        {round(v, 2) for v in (_num_or_none(bb_lower), _num_or_none(ma60), _num_or_none(ma20)) if v is not None and v < p},
+        reverse=True,
+    )[:3]
+    resistances = sorted(
+        {round(v, 2) for v in (_num_or_none(ma20), _num_or_none(ma60), _num_or_none(bb_upper)) if v is not None and v > p},
+    )[:3]
+    support_str = ", ".join(f"{currency} {v:,.2f}" for v in supports)
+    resistance_str = ", ".join(f"{currency} {v:,.2f}" for v in resistances)
+    return support_str, resistance_str
+
+
+def _history_records(history_result) -> list[dict]:
+    """Return normalized OHLC records from a market_data_client history result."""
+    if not isinstance(history_result, dict) or not history_result.get("success"):
+        return []
+    records = history_result.get("data") or []
+    out: list[dict] = []
+    for row in records:
+        if not isinstance(row, dict):
+            continue
+        close = _num_or_none(row.get("close") or row.get("Close"))
+        high = _num_or_none(row.get("high") or row.get("High") or close)
+        low = _num_or_none(row.get("low") or row.get("Low") or close)
+        open_ = _num_or_none(row.get("open") or row.get("Open") or close)
+        if close is None or high is None or low is None:
+            continue
+        out.append({
+            "date": row.get("date") or row.get("datetime") or row.get("time") or "",
+            "open": open_ if open_ is not None else close,
+            "high": high,
+            "low": low,
+            "close": close,
+            "volume": _num_or_none(row.get("volume") or row.get("Volume")),
+        })
+    return out
+
+
+def _cached_history_records(mdc, symbol: str, days: int, interval: str) -> list[dict]:
+    if mdc is None or not hasattr(mdc, "history"):
+        return []
+    import time as _time
+    key = (str(symbol).upper(), int(days), str(interval))
+    now = _time.time()
+    cached = _LEVEL_HISTORY_CACHE.get(key)
+    if cached and now - cached.get("ts", 0) < _LEVEL_HISTORY_CACHE_TTL:
+        return cached.get("records", [])[:]
+    try:
+        records = _history_records(mdc.history(symbol, days=days, interval=interval))
+    except Exception:
+        records = []
+    if records:
+        _LEVEL_HISTORY_CACHE[key] = {"ts": now, "records": records}
+    return records
+
+
+def _aggregate_ohlc(records: list[dict], bars: int) -> list[dict]:
+    """Aggregate chronological OHLC records into fixed-size bars."""
+    if bars <= 1 or len(records) < bars:
+        return records[:]
+    out: list[dict] = []
+    for i in range(0, len(records), bars):
+        chunk = records[i:i + bars]
+        if len(chunk) < bars:
+            continue
+        out.append({
+            "date": chunk[-1].get("date") or "",
+            "open": chunk[0]["open"],
+            "high": max(float(r["high"]) for r in chunk),
+            "low": min(float(r["low"]) for r in chunk),
+            "close": chunk[-1]["close"],
+            "volume": sum(float(r.get("volume") or 0) for r in chunk),
+        })
+    return out
+
+
+def _rolling_mean_from_records(records: list[dict], n: int) -> float | None:
+    if len(records) < n:
+        return None
+    vals = [_num_or_none(r.get("close")) for r in records[-n:]]
+    vals = [v for v in vals if v is not None]
+    if len(vals) < n:
+        return None
+    return sum(vals) / len(vals)
+
+
+def _bollinger_from_records(records: list[dict], n: int = 20) -> tuple[float | None, float | None]:
+    if len(records) < n:
+        return None, None
+    vals = [_num_or_none(r.get("close")) for r in records[-n:]]
+    vals = [v for v in vals if v is not None]
+    if len(vals) < n:
+        return None, None
+    mean = sum(vals) / len(vals)
+    if len(vals) < 2:
+        return None, None
+    variance = sum((v - mean) ** 2 for v in vals) / (len(vals) - 1)
+    std = variance ** 0.5
+    return mean + 2 * std, mean - 2 * std
+
+
+def _nearest_levels(
+    records: list[dict],
+    price,
+    *,
+    window: int,
+    extra_levels=(),
+    max_levels: int = 3,
+) -> tuple[list[float], list[float]]:
+    """Find nearest support/resistance using swing points plus dynamic levels."""
+    p = _num_or_none(price)
+    if p is None:
+        return [], []
+    highs = [_num_or_none(r.get("high")) for r in records]
+    lows = [_num_or_none(r.get("low")) for r in records]
+    closes = [_num_or_none(r.get("close")) for r in records]
+    usable = [
+        (h, l, c)
+        for h, l, c in zip(highs, lows, closes)
+        if h is not None and l is not None and c is not None
+    ]
+    candidates: list[float | None]
+    if len(usable) < max(5, window * 2 + 1):
+        candidates = [_num_or_none(v) for v in extra_levels]
+    else:
+        highs = [float(h) for h, _l, _c in usable]
+        lows = [float(l) for _h, l, _c in usable]
+        candidates = []
+        for i in range(window, len(usable) - window):
+            hi_slice = highs[i - window:i + window + 1]
+            lo_slice = lows[i - window:i + window + 1]
+            if highs[i] == max(hi_slice):
+                candidates.append(highs[i])
+            if lows[i] == min(lo_slice):
+                candidates.append(lows[i])
+        candidates.extend(_num_or_none(v) for v in extra_levels)
+
+    support = sorted(
+        {round(float(v), 2) for v in candidates if v is not None and float(v) < p},
+        reverse=True,
+    )[:max_levels]
+    resistance = sorted(
+        {round(float(v), 2) for v in candidates if v is not None and float(v) > p},
+    )[:max_levels]
+    return support, resistance
+
+
+def _compact_levels(currency: str, levels: list[float]) -> str:
+    """"USD 332.54 / 328.35 / 325.81": the currency once."""
+    return f"{currency} " + " / ".join(f"{v:,.2f}" for v in levels) if levels else "—"
+
+
+def _format_levels(currency: str, levels: list[float]) -> str:
+    return ", ".join(f"{currency} {v:,.2f}" for v in levels) if levels else "—"
+
+
+def _level_action_line(
+    name: str,
+    support: list[float],
+    resistance: list[float],
+    currency: str,
+    *,
+    english: bool = False,
+) -> str:
+    sup = f"{currency} {support[0]:,.2f}" if support else ""
+    res = f"{currency} {resistance[0]:,.2f}" if resistance else ""
+    if english:
+        if name.startswith("4H"):
+            if sup and res:
+                return f"Short-term: break {res} to chase strength; lose {sup} to reduce risk."
+            return "Short-term: wait for a cleaner nearby level."
+        if name.startswith("Daily"):
+            if sup and res:
+                return f"Swing: hold {sup}; reclaim {res} for daily repair."
+            return "Swing: level data is incomplete."
+        if sup and res:
+            return f"Position: {sup} is the structural line; {res} is the next supply zone."
+        return "Position: structural levels are incomplete."
+    if name.startswith("4H"):
+        if sup and res:
+            return f"短线：上破 {res} 转强；跌破 {sup} 降风险。"
+        return "短线：近端关键位不足，先等价格走出区间。"
+    if name.startswith("日线"):
+        if sup and res:
+            return f"波段：守住 {sup} 结构未破；站回 {res} 修复。"
+        return "波段：日线关键位不足，需结合成交量确认。"
+    if sup and res:
+        return f"长线：{sup} 是结构防线；{res} 是上方供给/趋势压力。"
+    return "长线：结构位不足，暂不做长期突破判断。"
+
+
+def _timeframe_display_name(name: str, *, english: bool = False) -> str:
+    if not english:
+        return name
+    if name.startswith("4H"):
+        return "4H/Short-term"
+    if name.startswith("日线"):
+        return "Daily/Swing"
+    if name.startswith("周线"):
+        return "Weekly/Position"
+    return name
+
+
+def _timeframe_source_label(source: str, *, english: bool = False) -> str:
+    if english:
+        return {
+            "1h→4h": "1h aggregated to 4H",
+            "near-term daily": "near-term daily fallback",
+            "daily swings + MA/BOLL": "daily swings + MA/BOLL",
+            "daily→weekly swings": "daily aggregated to weekly",
+            "MA/BOLL fallback": "MA/BOLL fallback",
+        }.get(source, source)
+    return {
+        "1h→4h": "1小时线聚合",
+        "near-term daily": "近端日线替代",
+        "daily swings + MA/BOLL": "日线摆动 + 均线/布林",
+        "daily→weekly swings": "日线聚合周线",
+        "MA/BOLL fallback": "均线/布林兜底",
+    }.get(source, source)
+
+
+def _append_timeframe_levels(
+    lines: list[str],
+    timeframe_levels: list[dict],
+    currency: str,
+    *,
+    english: bool = False,
+) -> None:
+    """Append narrow-terminal friendly multi-timeframe levels.
+
+    A Markdown table with five columns truncates the long "Use" text in 80-col
+    terminals. Blocks keep every level visible and let Rich wrap text naturally.
+    """
+    if not timeframe_levels:
+        return
+
+    lines.append("")
+    lines.append(f"**{'Multi-timeframe key levels' if english else '多周期关键位'}**")
+    for row in timeframe_levels[:3]:
+        raw_name = str(row.get("name") or "—")
+        name = _timeframe_display_name(raw_name, english=english)
+        source = _timeframe_source_label(str(row.get("source") or ""), english=english)
+        horizon = _horizon_label(str(row.get("horizon") or "—"), english=english)
+        support = row.get("support") or []
+        resistance = row.get("resistance") or []
+        action = _level_action_line(name, support, resistance, currency, english=english)
+
+        # Two lines a timeframe, not four: the levels on one line, what to do
+        # with them on the next. Every level stays; the data source is in the
+        # header already. The whole snapshot ran to about 48 lines.
+        if english:
+            lines.append(f"- **{name}** ({horizon}) — support {_compact_levels(currency, support)}"
+                         f" · resistance {_compact_levels(currency, resistance)}  ")
+            lines.append(f"  {action}")
+        else:
+            lines.append(f"- **{name}**（{horizon}）— 支撑 {_compact_levels(currency, support)}"
+                         f" · 压力 {_compact_levels(currency, resistance)}  ")
+            lines.append(f"  {action}")
+
+
+_HORIZON_UNITS_EN = {"日": "days", "周": "weeks", "月": "months"}
+
+
+def _horizon_label(horizon: str, *, english: bool) -> str:
+    if not english:
+        return horizon
+    if horizon == "快照":
+        return "snapshot"
+    match = re.fullmatch(r"\s*(\d+\s*-\s*\d+)\s*([日周月])\s*", horizon)
+    return f"{match.group(1)} {_HORIZON_UNITS_EN[match.group(2)]}" if match else horizon
+
+
+def _build_timeframe_levels(
+    mdc,
+    symbol: str,
+    price,
+    currency: str,
+    *,
+    ma20=None,
+    ma60=None,
+    bb_lower=None,
+    bb_upper=None,
+    fallback_supports: list[float] | None = None,
+    fallback_resistances: list[float] | None = None,
+) -> list[dict]:
+    """Build 4H/short, daily, and weekly/position support-resistance levels."""
+    p = _num_or_none(price)
+    if p is None:
+        return []
+    fallback_supports = fallback_supports or []
+    fallback_resistances = fallback_resistances or []
+    rows: list[dict] = []
+
+    daily_records = _cached_history_records(mdc, symbol, 370, "1d")
+    intraday_records = _cached_history_records(mdc, symbol, 30, "1h")
+
+    short_source = "1h→4h" if len(intraday_records) >= 24 else "near-term daily"
+    short_records = _aggregate_ohlc(intraday_records, 4) if len(intraday_records) >= 24 else daily_records[-30:]
+    if short_records:
+        short_ma20 = _rolling_mean_from_records(short_records, 20)
+        short_sup, short_res = _nearest_levels(
+            short_records,
+            p,
+            window=2 if len(short_records) < 60 else 3,
+            extra_levels=(short_ma20, *fallback_supports, *fallback_resistances),
+        )
+        rows.append({
+            "name": "4H/短线",
+            "horizon": "1-5 日",
+            "source": short_source,
+            "support": short_sup,
+            "resistance": short_res,
+        })
+
+    if daily_records:
+        day_bbu, day_bbl = _bollinger_from_records(daily_records, 20)
+        day_sup, day_res = _nearest_levels(
+            daily_records[-180:],
+            p,
+            window=5,
+            extra_levels=(ma20, ma60, bb_lower, bb_upper, day_bbl, day_bbu),
+        )
+        rows.append({
+            "name": "日线/波段",
+            "horizon": "1-8 周",
+            "source": "daily swings + MA/BOLL",
+            "support": day_sup,
+            "resistance": day_res,
+        })
+
+        weekly_records = _aggregate_ohlc(daily_records[-260:], 5)
+        weekly_ma20 = _rolling_mean_from_records(weekly_records, 20)
+        weekly_ma40 = _rolling_mean_from_records(weekly_records, 40)
+        long_high = max((float(r["high"]) for r in daily_records[-260:] if r.get("high") is not None), default=None)
+        long_low = min((float(r["low"]) for r in daily_records[-260:] if r.get("low") is not None), default=None)
+        long_sup, long_res = _nearest_levels(
+            weekly_records,
+            p,
+            window=3,
+            extra_levels=(weekly_ma20, weekly_ma40, long_high, long_low),
+        )
+        rows.append({
+            "name": "周线/长线",
+            "horizon": "2-12 月",
+            "source": "daily→weekly swings",
+            "support": long_sup,
+            "resistance": long_res,
+        })
+
+    if not rows and (fallback_supports or fallback_resistances):
+        rows.append({
+            "name": "近端关键位",
+            "horizon": "快照",
+            "source": "MA/BOLL fallback",
+            "support": fallback_supports[:3],
+            "resistance": fallback_resistances[:3],
+        })
+    return rows
+
+
+def _is_market_share_request(message: str) -> bool:
+    text = (message or "").lower()
+    return any(k in text for k in (
+        "市场份额", "市占率", "份额", "竞争格局", "market share", "share of market",
+    ))
+
+
+def _market_share_note(symbols: list[str], *, english: bool = False) -> list[str]:
+    if english:
+        return [
+            "",
+            "Market Share Follow-up",
+            "- The table above covers stock price and technical trend only.",
+            "- Market share requires business-line research, for example: iPhone vs Android, search, digital ads, cloud, browser, payments, or devices.",
+            "- Run `" + " ".join(["/research", *symbols[:2]]) + "` or `/web <company> market share latest` to fetch source-backed share data.",
+        ]
+    return [
+        "",
+        "市场份额后续",
+        "- 上表只覆盖股价走势、技术指标和市值，不等同于业务市场份额。",
+        "- 市场份额需要按业务线拆开研究，例如：手机、搜索、数字广告、云服务、浏览器、支付、硬件生态。",
+        "- 可继续运行 `" + " ".join(["/research", *symbols[:2]]) + "`，或 `/web <公司> 市场份额 最新` 获取带来源的份额数据。",
+    ]
+
+
+_DATA_KEY_MAP = {
+    "finnhub":   "FINNHUB_API_KEY",
+    "alphavantage": "ALPHAVANTAGE_API_KEY",
+    "polygon":   "POLYGON_API_KEY",
+}
+
+
+def _get_provider_key(provider: str) -> str:
+    """Return configured API key for a provider (env var takes priority over providers.json)."""
+    env_var = _DATA_KEY_MAP.get(provider.lower(), "")
+    if env_var:
+        val = os.getenv(env_var, "")
+        if val:
+            return val
+    try:
+        if _PROVIDERS_FILE.exists():
+            raw = json.loads(_PROVIDERS_FILE.read_text(encoding="utf-8"))
+            for section in ("llm", "data"):
+                entry = raw.get(section, {}).get(provider.lower(), {})
+                if entry.get("api_key"):
+                    return entry["api_key"]
+    except Exception:
+        pass
+    return ""
+
+
+# Lazy MDC accessor (mirrors the pattern in market_tools.py)
+def _get_mdc_lazy():
+    aria_cli = sys.modules.get("aria_cli")
+    injected = getattr(aria_cli, "_get_mdc", None) if aria_cli else None
+    if callable(injected):
+        try:
+            return injected()
+        except Exception:
+            pass
+    try:
+        from market_data_client import get_mdc as _gm
+        return _gm()
+    except Exception:
+        return None
+
+def _has_mdc_lazy() -> bool:
+    aria_cli = sys.modules.get("aria_cli")
+    if aria_cli is not None and hasattr(aria_cli, "_HAS_MDC"):
+        return bool(getattr(aria_cli, "_HAS_MDC"))
+    try:
+        import market_data_client  # noqa
+        return True
+    except ImportError:
+        return False
+
+
+def _try_prefetch_market_data(message: str, history: list = None) -> str:
+    """
+    Pre-fetch real market data and inject it into the system prompt so local
+    models always answer with real numbers instead of hallucinating.
+
+    For technical-analysis queries (support/resistance/RSI/MACD) also fetches
+    technical indicators and computes key price levels from the data.
+
+    跟进问题支持：当前消息无标的但含市场关键词时，从会话历史继承最近标的
+    （如上一轮问"寒武纪趋势"，这一轮问"现在的股票和趋势呢"）。
+
+    Returns "" if no market query detected or fetch fails.
+    """
+    # Real-estate queries must not prefetch stock market data
+    if _is_realty_query(message):
+        return ""
+
+    # Trigger for any market / analysis query
+    _market_kw = (
+        "股票","股价","价格","涨跌","市值","行情","市场","现在多少","现价","今天价格",
+        "分析","走势","技术面","基本面","估值","涨跌幅",
+        "支撑","阻力","支撑位","阻力位","技术指标","技术分析",
+        "stock","price","quote","analyze","analysis","crypto",
+        "btc","eth","比特币","以太坊","rsi","macd","bollinger",
+    )
+    msg_low = message.lower()
+    if not any(k in msg_low for k in _market_kw):
+        return ""
+
+    # Detect if this is a technical analysis request
+    _tech_kw = ("技术面","技术分析","技术指标","支撑","阻力","支撑位","阻力位",
+                 "rsi","macd","bollinger","均线","走势","趋势","technical")
+    _is_tech_query = any(k in msg_low for k in _tech_kw)
+
+    msg_for_lookup = message.lower()  # case-insensitive company name matching
+    _all_syms: list = []
+    _seen_syms: set = set()
+
+    # 1. Known Chinese company / index name → ticker (longest match first, find ALL)
+    for cn, tick in sorted(_COMPANY_TO_TICKER.items(), key=lambda x: -len(x[0])):
+        if cn.lower() in msg_for_lookup and tick not in _seen_syms:
+            _all_syms.append(tick)
+            _seen_syms.add(tick)
+
+    # 2. Crypto names
+    for cn, tick in _CRYPTO_WORDS.items():
+        if cn.lower() in msg_for_lookup and tick not in _seen_syms:
+            _all_syms.append(tick)
+            _seen_syms.add(tick)
+
+    # 3. Uppercase ticker patterns — collect all matches
+    for _tm in _re_sym.finditer(r'\b([A-Z]{2,5}(?:\.(?:HK|SH|SZ))?)\b', message):
+        tick = _tm.group(1)
+        if tick not in _FINANCIAL_TERMS_BLOCKLIST and tick not in _seen_syms:
+            _all_syms.append(tick)
+            _seen_syms.add(tick)
+
+    # 4. History fallback when no symbols found
+    if not _all_syms and history:
+        _hs = _extract_symbol_from_history(history)
+        if _hs:
+            _all_syms = [_hs]
+
+    if not _all_syms:
+        return ""
+
+    symbol = _all_syms[0]   # primary symbol drives tech-analysis fetch
+    _extra_syms = _all_syms[1:3]  # up to 2 additional symbols
+
+    if not _has_mdc_lazy():
+        return (
+            f"\n## 实时行情状态\n"
+            f"- 标的：{symbol}\n"
+            f"- 状态：本地 market_data_client 未加载，无法获取实时行情。\n"
+            f"- 输出要求：明确说明数据不可用，并建议用户执行 `/quote {symbol}`；"
+            "不要输出示例价格、占位符或技术指标。\n"
+        )
+
+    try:
+        mdc = _get_mdc_lazy()
+        r = mdc.quote(symbol)
+        if not r.get("success"):
+            return (
+                f"\n## 实时行情状态\n"
+                f"- 标的：{symbol}\n"
+                f"- 状态：当前数据服务无法获取该标的的实时行情。\n"
+                f"- 可用操作：运行 `/quote {symbol}` 重试。\n"
+                f"- 输出要求：不要输出示例价格、占位符、RSI、MACD 或支撑阻力位。\n"
+            )
+        r = enrich_market_quote(symbol, r)
+        price    = r.get("price", "N/A")
+        chg      = r.get("change_pct", 0)
+        name     = r.get("name", symbol)
+        currency = r.get("currency", "USD")
+        high     = r.get("high", "N/A")
+        low      = r.get("low", "N/A")
+        vol      = r.get("volume", "N/A")
+        mktcap   = r.get("market_cap")
+        cap_str  = ""
+        if mktcap and mktcap == mktcap:  # excludes NaN
+            if mktcap >= 1e12:
+                cap_str = f"{currency} {mktcap/1e12:.2f}T"
+            elif mktcap >= 1e9:
+                cap_str = f"{currency} {mktcap/1e9:.1f}B"
+        sign = "+" if chg >= 0 else ""
+        provider = r.get("provider", "API")
+        display_label = market_display_label(symbol, r)
+        exchange = r.get("exchange")
+
+        block = (
+            f"\n## 📊 {display_label} 实时行情（来源：{provider}）\n"
+            f"- **交易代码**：{symbol}" + (f"（{exchange}）\n" if exchange else "\n") +
+            f"- **名称**：{name}\n"
+            f"- **最新价**：{currency} {price}\n"
+            f"- **涨跌幅**：{sign}{chg:.2f}%\n"
+            f"- **今日高/低**：{high} / {low}\n"
+            f"- **成交量**：{vol}\n"
+            + (f"- **市值**：{cap_str}\n" if cap_str else "")
+        )
+
+        # For technical analysis queries: fetch indicators and compute support/resistance
+        if _is_tech_query:
+            try:
+                import time as _time_ta
+                _raw_ti = mdc.technical_indicators(symbol, days=120)
+                if isinstance(_raw_ti, dict) and _raw_ti.get("success"):
+                    _TA_SESSION_CACHE[symbol] = {"data": _raw_ti, "ts": _time_ta.time()}
+                    ti = _raw_ti
+                else:
+                    # Fall back to session cache
+                    _cached_ta = _TA_SESSION_CACHE.get(symbol)
+                    ti = (_cached_ta["data"] if _cached_ta and
+                          (_time_ta.time() - _cached_ta["ts"]) < _TA_SESSION_CACHE_TTL
+                          else {})
+                if ti.get("success"):
+                    rsi   = ti.get("rsi")
+                    macd  = ti.get("macd")
+                    msig  = ti.get("macd_signal")
+                    mhist = ti.get("macd_hist")
+                    bbu   = ti.get("bb_upper")
+                    bbm   = ti.get("bb_mid")
+                    bbl   = ti.get("bb_lower")
+                    ma20  = ti.get("ma20")
+                    ma60  = ti.get("ma60")
+                    ma5   = ti.get("ma5")
+
+                    # Derive support / resistance from MAs and Bollinger Bands
+                    supports    = sorted([v for v in [ma20, ma60, bbl] if v], reverse=False)
+                    resistances = sorted([v for v in [bbu, bbm] if v], reverse=False)
+                    if isinstance(price, (int, float)):
+                        # Primary support = nearest MA below current price
+                        supports    = [f"{currency} {v:.2f}" for v in supports if v < price]
+                        resistances = [f"{currency} {v:.2f}" for v in resistances if v > price]
+                    else:
+                        supports    = [f"{currency} {v:.2f}" for v in supports]
+                        resistances = [f"{currency} {v:.2f}" for v in resistances]
+
+                    # Pre-compute signal labels so the model doesn't need to interpret
+                    rsi_str = f"{rsi:.1f}" if rsi is not None else "N/A"
+                    if rsi is not None:
+                        if rsi >= 70:
+                            rsi_signal = f"⚠️ 超买 (RSI={rsi:.1f} ≥ 70，回调风险)"
+                        elif rsi <= 30:
+                            rsi_signal = f"⚠️ 超卖 (RSI={rsi:.1f} ≤ 30，反弹机会)"
+                        else:
+                            rsi_signal = f"中性 (RSI={rsi:.1f}，30-70区间，无超买超卖)"
+                    else:
+                        rsi_signal = "N/A"
+
+                    # Show MACD histogram prominently (not the MACD line)
+                    if mhist is not None:
+                        macd_hist_str = f"{mhist:.4f}"
+                        macd_signal = "金叉/多头" if mhist > 0 else "死叉/空头"
+                        macd_label = f"MACD hist={macd_hist_str}，信号：{macd_signal}"
+                    else:
+                        macd_hist_str = "N/A"
+                        macd_signal = "N/A"
+                        macd_label = "N/A"
+
+                    block += (
+                        f"\n## 📈 技术分析数据（基于120日历史，已预计算信号）\n\n"
+                        f"### 技术指标与信号\n"
+                        f"| 指标 | 数值 | 信号判断 |\n"
+                        f"| --- | --- | --- |\n"
+                        f"| RSI(14) | {rsi_str} | {rsi_signal} |\n"
+                        f"| MACD hist(12,26,9) | {macd_hist_str} | {macd_signal}（hist{'>'if mhist and mhist>0 else '<'}0） |\n"
+                        + (f"| MA5 | {currency} {ma5:.2f} | 短期均线 |\n" if ma5 else "")
+                        + (f"| MA20 | {currency} {ma20:.2f} | 中期支撑/压力 |\n" if ma20 else "")
+                        + (f"| MA60 | {currency} {ma60:.2f} | 长期支撑/压力 |\n" if ma60 else "")
+                        + (f"| BB Upper | {currency} {bbu:.2f} | 上轨阻力 |\n" if bbu else "")
+                        + (f"| BB Lower | {currency} {bbl:.2f} | 下轨支撑 |\n" if bbl else "")
+                        + "\n### 关键价位（直接引用这些数字）\n"
+                        + f"- **支撑位**：{', '.join(supports) if supports else '无（当前价已在主要支撑下方）'}\n"
+                        + f"- **阻力位**：{', '.join(resistances) if resistances else '无（当前价已突破布林上轨）'}\n"
+                        + "\n### 技术信号汇总\n"
+                        + f"- RSI：{rsi_signal}\n"
+                        + f"- MACD：{macd_label}\n"
+                    )
+            except Exception:
+                pass  # Technical fetch failure is non-fatal; basic quote still injected
+
+        # Fetch additional symbols detected in the same message
+        for _xs in _extra_syms:
+            try:
+                _xr = mdc.quote(_xs)
+                if _xr.get("success"):
+                    _xr = enrich_market_quote(_xs, _xr)
+                    _xp   = _xr.get("price", "N/A")
+                    _xchg = _xr.get("change_pct", 0)
+                    _xn   = _xr.get("name", _xs)
+                    _xc   = _xr.get("currency", "USD")
+                    _xsign = "+" if _xchg >= 0 else ""
+                    _x_label = market_display_label(_xs, _xr)
+                    _x_exchange = _xr.get("exchange")
+                    block += (
+                        f"\n## 📊 {_x_label} 实时行情（来源：{_xr.get('provider', 'API')}）\n"
+                        f"- **交易代码**：{_xs}" + (f"（{_x_exchange}）\n" if _x_exchange else "\n") +
+                        f"- **名称**：{_xn}\n"
+                        f"- **最新价**：{_xc} {_xp}\n"
+                        f"- **涨跌幅**：{_xsign}{_xchg:.2f}%\n"
+                        f"- **今日高/低**：{_xr.get('high', 'N/A')} / {_xr.get('low', 'N/A')}\n"
+                        f"- **成交量**：{_xr.get('volume', 'N/A')}\n"
+                    )
+            except Exception:
+                pass  # additional symbol failure is non-fatal
+
+        block += f"\n*⚠️ 以上均为真实市场数据。请严格基于这些数字作答，不要修改或编造任何价格/指标数值。货币单位：{currency}。*\n"
+        return block
+
+    except Exception:
+        return ""
+
+
+def _fetch_snapshot_row_for_symbol(symbol: str, mdc) -> dict:
+    quote = {}
+    fundamentals = {}
+    technical = {}
+    warnings: list[str] = []
+    errors: list[str] = []
+    quality: dict = {}
+    stale = False
+    try:
+        from packages.aria_services.data import DataService
+        service = DataService(market_client=mdc, router=False)
+        quote_result = service.quote(symbol)
+        fund_result = service.fundamentals(symbol)
+        tech_result = service.technical_indicators(symbol, days=120)
+        quote = quote_result.data or {}
+        fundamentals = fund_result.data or {}
+        technical = tech_result.data or {}
+        warnings.extend(quote_result.warnings + fund_result.warnings + tech_result.warnings)
+        errors.extend(quote_result.errors + fund_result.errors + tech_result.errors)
+        provider_chain = list(dict.fromkeys(
+            str(p) for p in (
+                quote_result.provider_chain + fund_result.provider_chain + tech_result.provider_chain
+            ) if p
+        ))
+        missing_fields = list(dict.fromkeys(
+            quote_result.missing_fields + fund_result.missing_fields + tech_result.missing_fields
+        ))
+        stale = bool(quote_result.stale or tech_result.stale)
+        quality = {
+            "status": "partial" if missing_fields else "ok",
+            "stale": stale,
+            "providers": provider_chain,
+            "missing_fields": missing_fields,
+            "warnings": warnings[:5],
+            "errors": errors[:5],
+        }
+    except Exception as exc:
+        quote = {"success": False, "error": str(exc)}
+        warnings.append(f"data_service: {exc}")
+        provider_chain = []
+        missing_fields = ["price", "market_cap", "technical"]
+        quality = {
+            "status": "unavailable",
+            "stale": False,
+            "providers": [],
+            "missing_fields": missing_fields,
+            "warnings": warnings[:5],
+            "errors": [str(exc)],
+        }
+
+    quote = enrich_market_quote(symbol, quote)
+    currency = quote.get("currency") or fundamentals.get("currency") or "USD"
+    market_cap = (
+        quote.get("market_cap")
+        or fundamentals.get("market_cap")
+        or fundamentals.get("total_mv")
+    )
+    if not provider_chain:
+        provider_chain = []
+        for source in (quote, fundamentals, technical):
+            chain = source.get("provider_chain")
+            if isinstance(chain, list):
+                provider_chain.extend(chain)
+            elif source.get("provider"):
+                provider_chain.append(source.get("provider"))
+            elif source.get("source"):
+                provider_chain.append(source.get("source"))
+        provider_chain = _clean_provider_chain(provider_chain)
+    else:
+        provider_chain = _clean_provider_chain(provider_chain)
+    if not missing_fields:
+        missing_fields = []
+    # ── yfinance fallback when price is 0 or missing ────────────────────────
+    _price_val = quote.get("price")
+    _price_bad = not quote.get("success") or _price_val in (None, "", 0) or float(_price_val or 0) == 0
+    if _price_bad:
+        try:
+            import yfinance as _yf_snap
+            _sym_yf = symbol.upper()
+            _t = _yf_snap.Ticker(_sym_yf)
+            _fi = _t.fast_info
+            _yf_price = getattr(_fi, "last_price", None) or getattr(_fi, "previous_close", None)
+            if _yf_price and float(_yf_price) > 0:
+                _yf_prev = getattr(_fi, "previous_close", _yf_price)
+                _yf_chg = (float(_yf_price) - float(_yf_prev)) / float(_yf_prev) * 100 if _yf_prev else 0
+                _yf_info = {}
+                try:
+                    _yf_info = _t.info or {}
+                except Exception:
+                    pass
+                quote = {
+                    "success": True,
+                    "symbol": symbol,
+                    "name": _yf_info.get("shortName") or _yf_info.get("longName") or symbol,
+                    "price": round(float(_yf_price), 2),
+                    "change_pct": round(_yf_chg, 2),
+                    "currency": _yf_info.get("currency") or "USD",
+                    "market_cap": _yf_info.get("marketCap") or 0,
+                    "provider": "yfinance",
+                    "provider_chain": ["yfinance"],
+                }
+                if not provider_chain or all("edgar" in p.lower() for p in provider_chain):
+                    provider_chain = ["yfinance"]
+                _price_bad = False
+        except Exception:
+            pass
+    _price_val = quote.get("price")
+    if _price_bad or _price_val in (None, "", 0):
+        missing_fields.append("price")
+    if market_cap in (None, "", 0):
+        market_cap = quote.get("market_cap") or market_cap
+    if market_cap in (None, "", 0):
+        missing_fields.append("market_cap")
+    if not technical.get("success"):
+        missing_fields.append("technical")
+
+    price_num = _num_or_none(quote.get("price"))
+    chg_num = _num_or_none(quote.get("change_pct"))
+    rsi = _num_or_none(technical.get("rsi"))
+    macd_hist = _num_or_none(technical.get("macd_hist"))
+    ma20 = _num_or_none(technical.get("ma20"))
+    ma60 = _num_or_none(technical.get("ma60"))
+    bb_upper = _num_or_none(technical.get("bb_upper"))
+    bb_lower = _num_or_none(technical.get("bb_lower"))
+    support_str, resistance_str = _support_resistance_for_row(
+        currency, price_num, ma20, ma60, bb_lower, bb_upper
+    )
+    signal, signal_score, signal_confidence, signal_label = _snapshot_signal(
+        price_num, chg_num, rsi, macd_hist, ma20, ma60
+    )
+    technical_available = any(v is not None for v in (rsi, macd_hist, ma20, ma60, bb_upper, bb_lower))
+    missing_fields = [
+        field for field in list(dict.fromkeys(missing_fields))
+        if not (
+            (field == "technical" and technical_available)
+            or (field == "macd" and macd_hist is not None)
+        )
+    ]
+
+    return {
+        "symbol": symbol,
+        "name": quote.get("name") or fundamentals.get("name") or symbol,
+        "success": bool(quote.get("success")),
+        "price": price_num if price_num is not None else quote.get("price"),
+        "change_pct": chg_num if chg_num is not None else quote.get("change_pct"),
+        "currency": currency,
+        "market_cap": market_cap,
+        "high": quote.get("high"),
+        "low": quote.get("low"),
+        "volume": quote.get("volume"),
+        "rsi": rsi,
+        "macd_hist": macd_hist,
+        "ma20": ma20,
+        "ma60": ma60,
+        "bb_upper": bb_upper,
+        "bb_lower": bb_lower,
+        "support": support_str,
+        "resistance": resistance_str,
+        "technical_available": technical_available,
+        "technical_provider": technical.get("provider") or technical.get("source") or "",
+        "signal": signal,
+        "signal_score": signal_score,
+        "signal_confidence": signal_confidence,
+        "signal_label": signal_label,
+        "trend": _market_snapshot_trend(
+            quote.get("price"),
+            quote.get("high"),
+            quote.get("low"),
+            quote.get("change_pct"),
+        ),
+        "provider_chain": provider_chain,
+        "missing_fields": missing_fields,
+        "error": quote.get("error") or "",
+        "warnings": warnings,
+        "errors": errors,
+        "quality": quality,
+        "stale": stale,
+    }
+
+
+def _try_handle_multi_market_snapshot(message: str, symbols: list[str]) -> dict:
+    if len(symbols) < 2:
+        return {"success": False, "error": "not_multi_symbol"}
+    _lang = _detect_lang(message)
+    _en = _lang == "en"
+    if not _has_mdc_lazy():
+        return {
+            "success": True,
+            "response": (
+                ("Market Snapshot\n\nLocal market data client is unavailable.\n\n"
+                 f"Run `/quote {' '.join(symbols)}` to retry.")
+                if _en else
+                ("市场快照\n\n当前本地行情客户端未加载，无法获取多标的实时行情。\n\n"
+                 f"可运行 `/quote {' '.join(symbols)}` 重试。")
+            ),
+            "tools_used": ["market_snapshot"],
+            "analysis_complete": True,
+        }
+    mdc = _get_mdc_lazy()
+    rows = [_fetch_snapshot_row_for_symbol(symbol, mdc) for symbol in symbols]
+    now = datetime.now().strftime("%Y-%m-%d")
+    provider_chain = list(dict.fromkeys(
+        provider for row in rows for provider in row.get("provider_chain", [])
+    ))
+    provider_chain = _clean_provider_chain(provider_chain)
+    missing = sorted(set(
+        f"{row['symbol']}:{field}"
+        for row in rows for field in row.get("missing_fields", [])
+    ))
+    stale_symbols = [row["symbol"] for row in rows if row.get("stale")]
+    warnings = [w for row in rows for w in (row.get("warnings") or [])]
+    errors = [e for row in rows for e in (row.get("errors") or [])]
+    ranked = sorted(
+        rows,
+        key=lambda row: (
+            int(row.get("signal_score") or 0),
+            _num_or_none(row.get("change_pct")) or 0,
+        ),
+        reverse=True,
+    )
+    strongest = ranked[0] if ranked else {}
+    weakest = ranked[-1] if ranked else {}
+
+    table = [
+        ("Market Snapshot" if _en else "市场快照") + " · " + now + (" · Multi-symbol comparison" if _en else " · 多标的对比"),
+        "",
+    ]
+    if len(ranked) >= 2:
+        if _en:
+            table.append(
+                f"**Takeaway**: `{strongest.get('symbol')}` is currently stronger than "
+                f"`{weakest.get('symbol')}` by the quantitative snapshot score."
+            )
+        else:
+            table.append(
+                f"**对比结论**：按量化快照分数看，`{strongest.get('symbol')}` "
+                f"当前相对强于 `{weakest.get('symbol')}`。若技术指标缺失，结论仅基于价格/市值快照。"
+            )
+        table.append("")
+
+    if _en:
+        table.extend([
+            "| Symbol | Company | Price | Change | Market Cap | RSI | MACD hist | Signal |",
+            "|---|---|---:|---:|---:|---:|---:|---|",
+        ])
+    else:
+        table.extend([
+            "| 代码 | 公司 | 最新价 | 涨跌幅 | 市值 | RSI | MACD hist | 信号 |",
+            "|---|---|---:|---:|---:|---:|---:|---|",
+        ])
+    for row in rows:
+        currency = row.get("currency") or "USD"
+        if row.get("success") and row.get("price") not in (None, ""):
+            price = _fmt_money(currency, row.get("price"))
+            change = _num_or_none(row.get("change_pct"))
+            change_text = f"{change:+.2f}%" if change is not None else "—"
+        else:
+            price = "—"
+            change_text = "—"
+        rsi_text = f"{row['rsi']:.1f}" if row.get("rsi") is not None else "—"
+        macd_text = f"{row['macd_hist']:.4f}" if row.get("macd_hist") is not None else "—"
+        sig = row.get("signal") or "—"
+        sig_label = row.get("signal_label") or ""
+        if _en:
+            sig_label = _SIGNAL_LABELS_EN.get(sig_label, sig_label)
+        sig_text = f"{sig} / {sig_label}" if sig_label and sig != "—" else sig
+        table.append(
+            f"| {row['symbol']} | {row.get('name') or row['symbol']} | {price} | "
+            f"{change_text} | {_format_compact_market_cap(row.get('market_cap'), currency)} | "
+            f"{rsi_text} | {macd_text} | {sig_text} |"
+        )
+
+    table.append("")
+    table.append("Data" if _en else "数据")
+    table.append(f"- {'sources' if _en else '来源'}: {', '.join(provider_chain) if provider_chain else 'unavailable'}")
+    table.append(f"- stale: {', '.join(stale_symbols) if stale_symbols else 'none'}")
+    if missing:
+        table.append(f"- missing: {', '.join(missing)}")
+    else:
+        table.append("- missing: none")
+    technical_ok = [row["symbol"] for row in rows if row.get("technical_available")]
+    technical_missing = [row["symbol"] for row in rows if not row.get("technical_available")]
+    if _en:
+        table.append(
+            "- technical: "
+            + (f"available for {', '.join(technical_ok)}" if technical_ok else "unavailable")
+            + (f"; unavailable for {', '.join(technical_missing)}" if technical_missing else "")
+        )
+    else:
+        table.append(
+            "- 技术指标: "
+            + (f"{', '.join(technical_ok)} 可用" if technical_ok else "暂不可用")
+            + (f"；{', '.join(technical_missing)} 暂缺" if technical_missing else "")
+        )
+    if warnings:
+        table.append(f"- warnings: {'; '.join(str(w) for w in warnings[:3])}")
+    if errors:
+        table.append(f"- errors: {'; '.join(str(e) for e in errors[:3])}")
+    if _is_market_share_request(message):
+        table.extend(_market_share_note(symbols, english=_en))
+
+    table.append("")
+    table.append("Analysis" if _en else "逐项分析")
+    for row in rows:
+        currency = row.get("currency") or "USD"
+        price_text = _fmt_money(currency, row.get("price"))
+        change = _num_or_none(row.get("change_pct"))
+        change_text = f"{change:+.2f}%" if change is not None else "—"
+        vol = _fmt_int(row.get("volume")) if row.get("volume") else ""
+        sig = row.get("signal") or "—"
+        sig_label = row.get("signal_label") or "指标不足"
+        if _en:
+            sig_label = _SIGNAL_LABELS_EN.get(sig_label, sig_label)
+        score = int(row.get("signal_score") or 0)
+        conf = float(row.get("signal_confidence") or 0)
+        table.append("")
+        if _en:
+            table.append(f"### {row.get('name') or row['symbol']} `{row['symbol']}`")
+            table.append(f"- Price: {price_text}, change {change_text}; trend: {row.get('trend') or '—'}.")
+            if row.get("technical_available"):
+                table.append(
+                    f"- Technicals: RSI {row.get('rsi') if row.get('rsi') is not None else '—'}, "
+                    f"MACD hist {row.get('macd_hist') if row.get('macd_hist') is not None else '—'}; "
+                    f"signal `{sig}` ({sig_label}), score {score:+d}, confidence {conf:.0%}."
+                )
+                if row.get("support") or row.get("resistance"):
+                    table.append(f"- Levels: support {row.get('support') or '—'}; resistance {row.get('resistance') or '—'}.")
+            else:
+                table.append("- Technicals: unavailable from current data providers; do not infer RSI/MACD.")
+            if vol:
+                table.append(f"- Volume: {vol}.")
+        else:
+            table.append(f"### {row.get('name') or row['symbol']} `{row['symbol']}`")
+            table.append(f"- 价格：{price_text}，涨跌幅 {change_text}；趋势：{row.get('trend') or '—'}。")
+            if row.get("technical_available"):
+                table.append(
+                    f"- 技术：RSI {row.get('rsi') if row.get('rsi') is not None else '—'}，"
+                    f"MACD hist {row.get('macd_hist') if row.get('macd_hist') is not None else '—'}；"
+                    f"信号 `{sig}`（{sig_label}），量化分 {score:+d}，置信度 {conf:.0%}。"
+                )
+                if row.get("support") or row.get("resistance"):
+                    table.append(f"- 关键位：支撑 {row.get('support') or '—'}；阻力 {row.get('resistance') or '—'}。")
+            else:
+                table.append("- 技术：当前数据源未返回 RSI/MACD/均线，不据此编造技术指标。")
+            if vol:
+                table.append(f"- 成交量：{vol}。")
+
+    table.append("")
+    table.append("Next" if _en else "下一步")
+    table.append("- " + " · ".join(f"`/ta {symbol}`" for symbol in symbols[:4]) + (" — full technical chart" if _en else " — 完整技术图表"))
+    table.append("- " + " · ".join(f"`/report {symbol}`" for symbol in symbols[:4]) + (" — generate research reports" if _en else " — 生成研究报告"))
+    table.append("")
+    table.append("*Not investment advice*" if _en else "*不构成投资建议*")
+    return {
+        "success": True,
+        "response": "\n".join(table),
+        "tools_used": ["market_snapshot"],
+        "analysis_complete": True,
+    }
+
+
+def _render_private_company_analysis(profile_key: str, message: str) -> dict:
+    """Render a structured analysis for a private company using static profile data."""
+    p = _PRIVATE_COMPANY_PROFILES.get(profile_key, {})
+    if not p:
+        return {"success": False, "error": "no_private_profile"}
+
+    name = p.get("name", profile_key)
+    val = p.get("valuation_usd", "N/A")
+    rev = p.get("rev_est", "N/A")
+    growth = p.get("rev_growth", "N/A")
+    comps = p.get("comparables", [])
+
+    lines = [
+        f"## {name}",
+        "> ⚠️  **私有公司 — 无公开交易数据**  所有数字均来自公开报道与融资文件，非官方财报。",
+        "",
+        "### 估值与规模",
+        "| 指标 | 数据 |",
+        "|------|------|",
+        f"| 最新估值 | **${val}B**（{p.get('last_funding', 'N/A')}）|",
+        f"| 收入估算 | ~${rev}B/年（YoY +{growth}%）|",
+        f"| 员工数量 | ~{p.get('employees', 'N/A')}k |",
+        f"| 创立时间 | {p.get('founded', 'N/A')} — {p.get('founder', 'N/A')} |",
+        f"| 总部 | {p.get('hq', 'N/A')} |",
+        f"| IPO 状态 | {p.get('ipo_status', 'N/A')} |",
+        "",
+    ]
+
+    segs = p.get("segments", [])
+    if segs:
+        lines += ["### 业务板块", ""]
+        for s in segs:
+            lines.append(f"- {s}")
+        lines.append("")
+
+    highlights = p.get("highlights", [])
+    if highlights:
+        lines += ["### 核心亮点", ""]
+        for h in highlights:
+            lines.append(f"✅ {h}")
+        lines.append("")
+
+    risks = p.get("risks", [])
+    if risks:
+        lines += ["### 主要风险", ""]
+        for r in risks:
+            lines.append(f"⚠️  {r}")
+        lines.append("")
+
+    if comps:
+        comp_str = " · ".join(comps)
+        lines += [
+            "### 可比公司（均已上市）",
+            f"> 可对比分析：{comp_str}",
+            f"> 例如：`分析 {comps[0]} 的财务数据` 或 `/ta {comps[0]}` 查看技术面",
+            "",
+        ]
+
+    lines += [
+        "---",
+        "*数据来源：公开融资公告、新闻报道。私有公司无 SEC/证监会披露义务，以上估算存在较大不确定性。*",
+    ]
+
+    return {
+        "success": True,
+        "response": "\n".join(lines),
+        "tools_used": ["private_company_profile"],
+    }
+
+
+def _resolve_etf_snapshot_symbols(message: str) -> list[str]:
+    text = message or ""
+    low = text.lower()
+    if not any(k in low or k in text for k in ("etf", "基金", "交易型开放式")):
+        return []
+    if any(k in low or k in text for k in ("标普500", "标普 500", "s&p 500", "s&p500", "sp500", "spy")):
+        return ["SPY", "VOO", "IVV"]
+    if any(k in low or k in text for k in ("纳斯达克100", "纳斯达克 100", "nasdaq 100", "qqq")):
+        return ["QQQ", "QQQM"]
+    if any(k in low or k in text for k in ("黄金", "gold", "gld")):
+        return ["GLD", "IAU"]
+    return []
+
+
+_MARKET_OVERVIEW_INDICES = {
+    "cn": {
+        "label": "A 股市场",
+        "yf": [("上证综指", "000001.SS"), ("深证成指", "399001.SZ"),
+               ("创业板指", "399006.SZ"), ("沪深300", "000300.SS"),
+               ("科创50", "000688.SS")],
+        "ak_symbol": "沪深重要指数",
+        "extras": ["北向资金", "涨跌家数"],
+    },
+    "us": {
+        "label": "美股市场",
+        "yf": [("道琼斯", "^DJI"), ("纳斯达克", "^IXIC"), ("标普500", "^GSPC"),
+               ("罗素2000", "^RUT"), ("VIX 恐慌指数", "^VIX")],
+        "ak_symbol": None,
+        "extras": ["恐惧贪婪指数"],
+    },
+    "hk": {
+        "label": "港股市场",
+        "yf": [("恒生指数", "^HSI"), ("恒生国企", "^HSCE")],
+        "ak_symbol": None,
+        "extras": [],
+    },
+}
+
+
+def _http_get_json(url: str, params: dict, timeout: int = 8):
+    """GET JSON with a proxy-bypass retry.
+
+    A misconfigured/flaky HTTP(S)_PROXY (corporate or local) is a common cause
+    of "ProxyError / connection aborted" on otherwise-reachable data sources.
+    Try the normal request first (respecting the user's proxy), then retry with
+    proxies disabled so the data still loads when only the proxy is broken.
+    """
+    import requests as _rq
+    headers = {"User-Agent": "Mozilla/5.0"}
+    for proxies in (None, {"http": None, "https": None}):
+        try:
+            r = _rq.get(url, params=params, timeout=timeout,
+                        headers=headers, proxies=proxies)
+            r.raise_for_status()
+            return r.json()
+        except Exception:
+            continue
+    return None
+
+
+# 上证综指/深证成指/创业板指/沪深300/科创50 — eastmoney secids (1=SH, 0=SZ)
+_CN_INDEX_SECIDS = [
+    ("上证综指", "1.000001"), ("深证成指", "0.399001"),
+    ("创业板指", "0.399006"), ("沪深300", "1.000300"),
+    ("科创50", "1.000688"),
+]
+
+
+def _fetch_cn_indices_eastmoney() -> list:
+    """Fetch CN index levels + change% directly from eastmoney ulist endpoint."""
+    secids = ",".join(s for _, s in _CN_INDEX_SECIDS)
+    data = _http_get_json(
+        "https://push2.eastmoney.com/api/qt/ulist.np/get",
+        {"secids": secids, "fields": "f2,f3,f12,f14", "fltt": 2, "invt": 2},
+    )
+    if not data:
+        return []
+    diff = (data.get("data") or {}).get("diff") or []
+    # eastmoney may return a dict keyed by index or a list — normalize to list
+    items = list(diff.values()) if isinstance(diff, dict) else diff
+    disp_by_code = {sid.split(".")[1]: name for name, sid in _CN_INDEX_SECIDS}
+    rows: list = []
+    for it in items:
+        code = str(it.get("f12", ""))
+        name = disp_by_code.get(code) or str(it.get("f14", code))
+        price = it.get("f2")
+        chg = it.get("f3")
+        if price in (None, "-", ""):
+            continue
+        try:
+            rows.append({"name": name, "price": round(float(price), 2),
+                         "change_pct": round(float(chg), 2) if chg not in (None, "-", "") else 0.0,
+                         "ok": True})
+        except (ValueError, TypeError):
+            continue
+    return rows
+
+
+def _fetch_overview_indices(market: str) -> list:
+    """Fetch index levels for a market. Direct eastmoney (CN) / yfinance (US/HK).
+
+    Returns a list of {name, price, change_pct, ok} dicts; entries that could
+    not be fetched are marked ok=False rather than dropped, so the user always
+    sees the full index set and which data is temporarily unavailable.
+    """
+    cfg = _MARKET_OVERVIEW_INDICES.get(market, {})
+    rows: list = []
+
+    # CN: direct eastmoney ulist endpoint — returns price + change% in one call
+    # and is far more reliable than akshare's stock_zh_index_spot_em.
+    if market == "cn":
+        rows = _fetch_cn_indices_eastmoney()
+        if rows:
+            return rows
+        # fall through to yfinance .SS as a last resort
+
+    # US / HK / CN-fallback via yfinance (5d window so change% always computes)
+    try:
+        import yfinance as yf
+        for name, ticker in cfg.get("yf", []):
+            try:
+                h = yf.Ticker(ticker).history(period="5d")
+                closes = [float(c) for c in h["Close"].tolist() if c == c]  # drop NaN
+                if closes:
+                    last = closes[-1]
+                    prev = closes[-2] if len(closes) >= 2 else last
+                    chg = ((last - prev) / prev * 100) if prev else 0.0
+                    rows.append({"name": name, "price": round(last, 2),
+                                 "change_pct": round(chg, 2), "ok": True})
+                else:
+                    rows.append({"name": name, "price": 0, "change_pct": 0, "ok": False})
+            except Exception:
+                rows.append({"name": name, "price": 0, "change_pct": 0, "ok": False})
+    except Exception:
+        pass
+    return rows
+
+
+def _try_handle_market_overview(message: str) -> dict:
+    """Deterministic whole-market overview for '分析A股/港股/美股市场行情'.
+
+    Answers a market-level question with the right index set instead of
+    mis-parsing a market name into a single stock (the 'A股' → Agilent bug).
+    """
+    market = _detect_market_overview(message)
+    if not market:
+        return {"success": False, "error": "not_market_overview"}
+
+    cfg = _MARKET_OVERVIEW_INDICES[market]
+    rows = _fetch_overview_indices(market)
+    if not rows:
+        return {"success": False, "error": "no_index_data"}
+
+    ok_rows = [r for r in rows if r.get("ok")]
+    # Build a markdown overview
+    lines = [f"## 📊 {cfg['label']}行情概览",
+             f"*数据时间: {datetime.now().strftime('%Y-%m-%d %H:%M')} · 不构成投资建议*",
+             "",
+             "| 指数 | 最新点位 | 涨跌幅 |",
+             "|------|---------|--------|"]
+    for r in rows:
+        if r.get("ok"):
+            arrow = "🔴" if r["change_pct"] < 0 else ("🟢" if r["change_pct"] > 0 else "⚪")
+            lines.append(f"| {r['name']} | {r['price']:,.2f} | {arrow} {r['change_pct']:+.2f}% |")
+        else:
+            lines.append(f"| {r['name']} | — | 数据暂不可用 |")
+
+    # Breadth summary from the indices we did get
+    if ok_rows:
+        up = sum(1 for r in ok_rows if r["change_pct"] > 0)
+        down = sum(1 for r in ok_rows if r["change_pct"] < 0)
+        avg = sum(r["change_pct"] for r in ok_rows) / len(ok_rows)
+        if avg > 0.5:
+            tone = "整体偏强，多数指数上涨"
+        elif avg < -0.5:
+            tone = "整体偏弱，多数指数下跌"
+        else:
+            tone = "涨跌互现，方向不明"
+        lines += ["", f"**概况**: {tone}（{up} 涨 / {down} 跌，均值 {avg:+.2f}%）"]
+
+    # Market-specific next steps
+    _next = {
+        "cn": ["`/north` — 北向资金流向", "`/limitup` — 涨停板复盘",
+               "`/quote 600519` — 个股报价（如贵州茅台）"],
+        "us": ["`/quote AAPL MSFT NVDA` — 龙头个股", "`/sector` — 板块表现",
+               "`fear greed` — 市场情绪指数"],
+        "hk": ["`/quote 0700.HK` — 腾讯等个股", "`/north` — 南向资金"],
+    }.get(market, [])
+    if _next:
+        lines += ["", "**下一步**"] + [f"- {s}" for s in _next]
+
+    return {"success": True, "response": "\n".join(lines),
+            "tools_used": ["market_overview"]}
+
+
+def _try_handle_market_snapshot_analysis(message: str, history: list = None, *,
+                                         evidence_required: bool = False) -> dict:
+    """Deterministic path for simple market analysis.
+
+    Local small models tend to mangle injected quote fields into fragments like
+    "N/A/N/A/-1.24%".  For snapshot requests, format the data directly.
+    ``evidence_required``: see ``_is_market_snapshot_request``.
+    """
+    if not _is_market_snapshot_request(message, history, evidence_required=evidence_required):
+        return {"success": False, "error": "not_market_snapshot"}
+    # The reply is in the language of the question, failures included.
+    _en = _detect_lang(message) == "en"
+
+    _etf_symbols = _resolve_etf_snapshot_symbols(message)
+    if len(_etf_symbols) >= 2:
+        return _try_handle_multi_market_snapshot(message, _etf_symbols)
+
+    _symbols = _extract_market_symbols(message)
+    if len(_symbols) >= 2:
+        return _try_handle_multi_market_snapshot(message, _symbols)
+
+    _msg_sym = _extract_market_symbol(message)
+
+    # Private company: PRIVATE:Name — render static profile instead of live data
+    if _msg_sym and _msg_sym.startswith("PRIVATE:"):
+        return _render_private_company_analysis(_msg_sym[len("PRIVATE:"):], message)
+
+    _hist_sym = (_extract_symbol_from_history(history) if history else "") if not _msg_sym else ""
+
+    # Guard: if message names an unrecognised company, don't silently use history symbol
+    if not _msg_sym and _has_unresolved_company_mention(message):
+        return {
+            "success": True,
+            "response": (
+                "## ❓ Unrecognised stock\n\n"
+                "The company or brand in your message did not resolve to a known ticker.\n\n"
+                "Try again with the ticker, for example:\n"
+                "- China A-shares: `/quote 600519` (Kweichow Moutai)\n"
+                "- Hong Kong: `/quote 0700.HK` (Tencent)\n"
+                "- US: `/quote AAPL`\n"
+                "- Europe: `/quote MC.PA` (LVMH)\n\n"
+                "*Tip: `/ta <ticker>` gives the full technical analysis.*"
+            ) if _en else (
+                "## ❓ 无法识别的股票\n\n"
+                "未能将消息中提到的公司/品牌解析为已知股票代码。\n\n"
+                "请提供具体代码后重试，例如：\n"
+                "- A股：`/quote 600519`（贵州茅台）\n"
+                "- 港股：`/quote 0700.HK`（腾讯）\n"
+                "- 美股：`/quote AAPL`\n"
+                "- 欧洲：`/quote MC.PA`（LVMH/路易威登）\n\n"
+                "*提示：如需全局搜索，可输入 `/ta <代码>` 获取完整技术分析。*"
+            ),
+            "tools_used": ["market_snapshot"],
+            "analysis_complete": True,
+        }
+
+    symbol = _msg_sym or _hist_sym or "AAPL"
+    def _snapshot_ashare_code(sym: str) -> str:
+        s = str(sym or "").strip().upper()
+        if s.endswith((".SZ", ".SS", ".SH")):
+            s = s.rsplit(".", 1)[0]
+        if s.startswith(("SH", "SZ")) and s[2:].isdigit() and len(s[2:]) == 6:
+            s = s[2:]
+        return s if s.isdigit() and len(s) == 6 else ""
+
+    _ashare_code = _snapshot_ashare_code(symbol)
+    if not _has_mdc_lazy():
+        return {
+            "success": True,
+            "response": (
+                f"## {symbol} market snapshot\n\n"
+                "The local market data client is not loaded, so there is no live quote.\n\n"
+                f"Run `/quote {symbol}` to retry."
+            ) if _en else (
+                f"## {symbol} 市场快照\n\n"
+                "当前本地行情客户端未加载，无法获取实时行情。\n\n"
+                f"可运行 `/quote {symbol}` 重试。"
+            ),
+            "tools_used": ["market_snapshot"],
+            "analysis_complete": True,
+        }
+
+    import time as _time_snap
+
+    def _clean_network_error(raw: str) -> str:
+        """Convert raw exception strings to readable messages."""
+        if "Connection aborted" in raw or "RemoteDisconnected" in raw:
+            return ("the server closed the connection; try again shortly" if _en
+                    else "网络连接被中断（服务器关闭连接），请稍后重试")
+        if "Connection refused" in raw:
+            return ("connection refused; the data service is unavailable for now" if _en
+                    else "连接被拒绝，数据服务暂时不可用")
+        if "timeout" in raw.lower() or "timed out" in raw.lower():
+            return "the connection timed out; try again shortly" if _en else "连接超时，请稍后重试"
+        if "NoneType" in raw or raw.strip() in ("None", ""):
+            return _no_price
+        return raw
+
+    _no_price = "the data source returned no valid price" if _en else "当前数据源未返回有效价格"
+
+    quote = {"success": False, "error": "not initialised" if _en else "未初始化"}
+    _snapshot_quality = {}
+    import contextlib as _ctxlib_snapshot
+    import io as _io_snapshot
+    for _attempt in range(3):
+        try:
+            mdc = _get_mdc_lazy()
+            try:
+                from packages.aria_services.data import DataService as _SnapshotDataService
+                with _ctxlib_snapshot.redirect_stdout(_io_snapshot.StringIO()), _ctxlib_snapshot.redirect_stderr(_io_snapshot.StringIO()):
+                    _quote_result = _SnapshotDataService(market_client=mdc, router=False).quote(symbol)
+                quote = _quote_result.data or {}
+                _snapshot_quality = _quote_result.quality or {}
+                if _quote_result.provider_chain:
+                    quote.setdefault("provider_chain", _quote_result.provider_chain)
+                quote.setdefault("success", bool(_quote_result.success))
+                if not quote.get("success"):
+                    with _ctxlib_snapshot.redirect_stdout(_io_snapshot.StringIO()), _ctxlib_snapshot.redirect_stderr(_io_snapshot.StringIO()):
+                        raw_quote = mdc.quote(symbol)
+                    if raw_quote:
+                        quote = raw_quote if isinstance(raw_quote, dict) else (
+                            raw_quote.to_dict() if hasattr(raw_quote, "to_dict") else vars(raw_quote)
+                        )
+            except Exception:
+                with _ctxlib_snapshot.redirect_stdout(_io_snapshot.StringIO()), _ctxlib_snapshot.redirect_stderr(_io_snapshot.StringIO()):
+                    quote = mdc.quote(symbol)
+            if quote.get("success"):
+                break
+            _err_str = str(quote.get("error", ""))
+            _err_lower = _err_str.lower()
+            # Clean raw exception strings in-place
+            if any(k in _err_str for k in ("Connection aborted", "RemoteDisconnected",
+                                            "Connection refused", "timeout")):
+                quote["error"] = _clean_network_error(_err_str)
+            # Retry on connection errors AND rate limits
+            _should_retry = (
+                ("rate" in _err_lower or "429" in _err_lower or "too many" in _err_lower)
+                or ("connection aborted" in _err_lower or "remotedisconnected" in _err_lower)
+            )
+            if _should_retry and _attempt < 2:
+                _time_snap.sleep(1 + _attempt)  # 1s, 2s
+                continue
+            break
+        except Exception as exc:
+            _raw_exc = str(exc)
+            _exc_lower = _raw_exc.lower()
+            _clean_err = _clean_network_error(_raw_exc)
+            _should_retry = (
+                ("rate" in _exc_lower or "429" in _exc_lower or "too many" in _exc_lower)
+                or ("connection aborted" in _exc_lower or "remotedisconnected" in _exc_lower)
+            )
+            if _should_retry and _attempt < 2:
+                _time_snap.sleep(1 + _attempt)
+                continue
+            quote = {"success": False, "error": _clean_err}
+            break
+
+    # Finnhub fallback when primary data source (yfinance) failed or rate-limited
+    # _get_provider_key reads both env vars AND ~/.arthera/providers.json
+    # NOTE: do NOT use dir() — it returns local scope, not module globals.
+    _fh_key = _get_provider_key("finnhub")
+    _fh_tried = False
+    if not quote.get("success") and _fh_key:
+        _fh_tried = True
+        try:
+            import requests as _rq
+            _fh_r = _rq.get(
+                f"https://finnhub.io/api/v1/quote?symbol={symbol}&token={_fh_key}",
+                timeout=6
+            )
+            if _fh_r.status_code == 200:
+                _fh = _fh_r.json()
+                if _fh.get("c"):  # current price present
+                    quote = {
+                        "success": True, "symbol": symbol,
+                        "price": round(_fh["c"], 2),
+                        "change_pct": round(float(_fh.get("dp") or 0), 2),
+                        "high": round(_fh.get("h", 0), 2),
+                        "low":  round(_fh.get("l", 0), 2),
+                        "currency": "USD", "provider": "finnhub",
+                    }
+        except Exception:
+            pass
+
+    # akshare fallback for A-shares when both yfinance and eastmoney fail
+    _is_a_share_sym = bool(_ashare_code)
+    if _is_a_share_sym and not quote.get("success"):
+        try:
+            import akshare as _ak
+            from datetime import datetime as _dt2, timedelta as _td2
+            _end_d = _dt2.now().strftime("%Y%m%d")
+            _start_d = (_dt2.now() - _td2(days=7)).strftime("%Y%m%d")
+            _df_q = _ak.stock_zh_a_hist(
+                symbol=_ashare_code, period="daily",
+                start_date=_start_d, end_date=_end_d, adjust=""
+            )
+            if not _df_q.empty:
+                _row = _df_q.iloc[-1]
+                _close = float(_row.get("收盘", 0))
+                _prev = float(_df_q.iloc[-2]["收盘"]) if len(_df_q) >= 2 else _close
+                _chg_p = round((_close - _prev) / _prev * 100, 2) if _prev else 0
+                _name = symbol
+                try:
+                    _info_df = _ak.stock_individual_info_em(symbol=_ashare_code)
+                    _name = str(_info_df[_info_df["item"] == "股票简称"]["value"].values[0])
+                except Exception:
+                    pass
+                quote = {
+                    "success": True, "symbol": symbol, "name": _name,
+                    "price": _close, "change_pct": _chg_p,
+                    "high": float(_row.get("最高", _close)),
+                    "low":  float(_row.get("最低", _close)),
+                    "volume": int(_row.get("成交量", 0)),
+                    "currency": "CNY", "provider": "akshare",
+                }
+        except Exception:
+            pass
+
+    def _num(v):
+        try:
+            if v in (None, "", "N/A", "-", "nan"):
+                return None
+            return float(v)
+        except Exception:
+            return None
+
+    price = _num(quote.get("price"))
+    # yfinance fallback when price is 0 or None (e.g. EDGAR source returns 0.00)
+    if price is None or price == 0:
+        try:
+            import yfinance as _yf_single
+            _t_s = _yf_single.Ticker(symbol)
+            _fi_s = _t_s.fast_info
+            _yf_p = getattr(_fi_s, "last_price", None) or getattr(_fi_s, "previous_close", None)
+            if _yf_p and float(_yf_p) > 0:
+                _yf_prev_s = getattr(_fi_s, "previous_close", _yf_p)
+                _yf_chg_s = (float(_yf_p) - float(_yf_prev_s)) / float(_yf_prev_s) * 100 if _yf_prev_s else 0
+                _yf_info_s = {}
+                try:
+                    _yf_info_s = _t_s.info or {}
+                except Exception:
+                    pass
+                price = round(float(_yf_p), 2)
+                quote = {
+                    "success": True, "symbol": symbol,
+                    "name": _yf_info_s.get("shortName") or _yf_info_s.get("longName") or symbol,
+                    "price": price,
+                    "change_pct": round(_yf_chg_s, 2),
+                    "currency": _yf_info_s.get("currency") or "USD",
+                    "market_cap": _yf_info_s.get("marketCap") or 0,
+                    "provider": "yfinance",
+                }
+        except Exception:
+            pass
+        price = _num(quote.get("price"))
+
+    if not quote.get("success") or price is None or price == 0:
+        err = quote.get("error") or _no_price
+        # "NoneType…" and a bare KeyError repr ("'currentTradingPeriod'", what
+        # yfinance raises for a symbol it has no chart for) say nothing to a user.
+        if "NoneType" in str(err) or re.fullmatch(r"'\w+'", str(err).strip()):
+            err = _no_price
+        is_rate_limit = "rate" in str(err).lower() or "429" in str(err) or "too many" in str(err).lower()
+        if is_rate_limit:
+            if _fh_tried:
+                # Finnhub was tried but also failed — both sources exhausted
+                _hint = ("\n\n[Note] yfinance and Finnhub are both rate-limited; wait 30 seconds and retry."
+                         if _en else "\n\n[提示] yfinance 和 Finnhub 均触发频率限制，请稍等 30 秒后重试。")
+            elif _fh_key:
+                # Key configured but Finnhub wasn't tried (shouldn't happen, but defensive)
+                _hint = ("\n\n[Note] The data source is rate-limited; wait 30 seconds and retry."
+                         if _en else "\n\n[提示] 数据源请求频率受限，请稍等 30 秒后重试。")
+            else:
+                # No Finnhub key — suggest configuring one
+                _hint = (
+                    "\n\n[Note] The data source is rate-limited: wait 30 seconds and retry, "
+                    "or add a Finnhub key as a fallback source: `/apikey set finnhub <key>` "
+                    "(sign up: https://finnhub.io/register)"
+                ) if _en else (
+                    "\n\n[提示] 数据源请求频率受限：请稍等 30 秒后重试，"
+                    "或配置 Finnhub key 使用备用数据源：`/apikey set finnhub <key>`"
+                    "（注册：https://finnhub.io/register）"
+                )
+        else:
+            _hint = ""
+        return {
+            "success": True,
+            "response": (
+                f"## {symbol} market snapshot\n\n"
+                f"No valid quote right now: {err}{_hint}\n\n"
+                f"Run `/quote {symbol}` to retry; RSI, MACD and support/resistance are withheld until data is back."
+            ) if _en else (
+                f"## {symbol} 市场快照\n\n"
+                f"当前无法获取有效行情：{err}{_hint}\n\n"
+                f"可运行 `/quote {symbol}` 重试；在数据恢复前不输出 RSI、MACD 或支撑/阻力位。"
+            ),
+            "tools_used": ["market_snapshot"],
+            "rate_limited": is_rate_limit,
+            "analysis_complete": True,
+        }
+
+    name = quote.get("name") or symbol
+    currency = quote.get("currency") or "USD"
+    chg = _num(quote.get("change_pct"))
+    high = _num(quote.get("high"))
+    low = _num(quote.get("low"))
+    volume = quote.get("volume")
+    market_cap_raw = _num(quote.get("market_cap"))
+    provider = quote.get("provider") or "market_data_client"
+    sign = "+" if (chg or 0) >= 0 else ""
+    chg_str = f"{sign}{chg:.2f}%" if chg is not None else "—"
+    range_str = f"{currency} {low:,.2f} - {currency} {high:,.2f}" if low is not None and high is not None else ""
+    # Format market cap: T / B / M abbreviation
+    if market_cap_raw and market_cap_raw > 0:
+        if market_cap_raw >= 1e12:
+            _mktcap_str = f"{currency} {market_cap_raw/1e12:.2f}T"
+        elif market_cap_raw >= 1e9:
+            _mktcap_str = f"{currency} {market_cap_raw/1e9:.1f}B"
+        elif market_cap_raw >= 1e6:
+            _mktcap_str = f"{currency} {market_cap_raw/1e6:.0f}M"
+        else:
+            _mktcap_str = f"{currency} {market_cap_raw:,.0f}"
+    else:
+        _mktcap_str = None
+
+    # ── Technical indicators: mdc → akshare(A股) → yfinance → Finnhub ────────
+    ti = {}
+    try:
+        with _ctxlib_snapshot.redirect_stdout(_io_snapshot.StringIO()), _ctxlib_snapshot.redirect_stderr(_io_snapshot.StringIO()):
+            ti = mdc.technical_indicators(symbol, days=120)
+    except Exception:
+        ti = {}
+
+    # Akshare fallback for A-shares (6-digit code, no suffix) — more reliable than yfinance for CN
+    _is_a_share = bool(_ashare_code)
+    if (_is_a_share and (not ti.get("success") or ti.get("rsi") is None)):
+        try:
+            import akshare as _ak
+            import numpy as _np_ak
+            from datetime import datetime as _dt, timedelta as _td
+            _ak_start = (_dt.now() - _td(days=200)).strftime("%Y%m%d")
+            _ak_end   = _dt.now().strftime("%Y%m%d")
+            _df_ak = _ak.stock_zh_a_hist(
+                symbol=_ashare_code, period="daily",
+                start_date=_ak_start, end_date=_ak_end,
+                adjust="qfq",
+            )
+            _col_map = {
+                "收盘": "Close", "成交量": "Volume",
+                "close": "Close", "volume": "Volume",
+            }
+            _df_ak = _df_ak.rename(columns=_col_map)
+            if "Close" in _df_ak.columns and len(_df_ak) >= 20:
+                _c_ak = _df_ak["Close"].astype(float)
+                _v_ak = _df_ak["Volume"].astype(float) if "Volume" in _df_ak.columns else None
+                # RSI(14)
+                _d_ak = _c_ak.diff()
+                _g_ak = _d_ak.clip(lower=0).rolling(14).mean()
+                _l_ak = (-_d_ak.clip(upper=0)).rolling(14).mean()
+                _rs_ak = _g_ak / _l_ak.replace(0, _np_ak.nan)
+                _rsi_ak = float((100 - 100 / (1 + _rs_ak)).iloc[-1])
+                # MACD
+                _ema12_ak = _c_ak.ewm(span=12).mean()
+                _ema26_ak = _c_ak.ewm(span=26).mean()
+                _macd_ak  = _ema12_ak - _ema26_ak
+                _sig_ak   = _macd_ak.ewm(span=9).mean()
+                _mhist_ak = float((_macd_ak - _sig_ak).iloc[-1])
+                # MA / BB
+                _ma20_ak  = _c_ak.rolling(20).mean()
+                _std20_ak = _c_ak.rolling(20).std()
+                _ma60_ak  = _c_ak.rolling(60).mean() if len(_c_ak) >= 60 else _ma20_ak
+                ti = {
+                    "success":   True,
+                    "rsi":       round(_rsi_ak, 2) if not _np_ak.isnan(_rsi_ak) else None,
+                    "macd_hist": round(_mhist_ak, 4),
+                    "ma20":      round(float(_ma20_ak.iloc[-1]), 2),
+                    "ma60":      round(float(_ma60_ak.iloc[-1]), 2),
+                    "bb_upper":  round(float((_ma20_ak + 2*_std20_ak).iloc[-1]), 2),
+                    "bb_lower":  round(float((_ma20_ak - 2*_std20_ak).iloc[-1]), 2),
+                    "provider":  "akshare",
+                }
+                if volume is None and _v_ak is not None:
+                    _rv = _v_ak.iloc[-1]
+                    if not _np_ak.isnan(_rv):
+                        volume = int(_rv)
+        except Exception:
+            pass
+
+    # If mdc returned nothing useful (all None), try yfinance directly
+    if (not ti.get("success") or ti.get("rsi") is None) and not _is_a_share:
+        try:
+            import yfinance as _yf
+            import numpy as _np
+            # A股裸6位代码需要 yfinance 后缀：6/68开头→.SS，其余→.SZ
+            _yf_sym = symbol
+            if symbol.isdigit() and len(symbol) == 6:
+                _yf_sym = symbol + (".SS" if symbol.startswith("6") else ".SZ")
+            _hist = _yf.Ticker(_yf_sym).history(period="6mo")
+            if len(_hist) >= 20:
+                _close = _hist["Close"]
+                _vol   = _hist["Volume"]
+                # RSI(14)
+                _d = _close.diff()
+                _g = _d.clip(lower=0).rolling(14).mean()
+                _l = (-_d.clip(upper=0)).rolling(14).mean()
+                _rs = _g / _l.replace(0, _np.nan)
+                _rsi = float((100 - 100 / (1 + _rs)).iloc[-1])
+                # MACD hist
+                _ema12  = _close.ewm(span=12).mean()
+                _ema26  = _close.ewm(span=26).mean()
+                _macd   = _ema12 - _ema26
+                _signal = _macd.ewm(span=9).mean()
+                _mhist  = float((_macd - _signal).iloc[-1])
+                # Bollinger Bands & MA
+                _ma20  = _close.rolling(20).mean()
+                _std20 = _close.rolling(20).std()
+                _ma60  = _close.rolling(60).mean() if len(_close) >= 60 else _ma20
+                ti = {
+                    "success":   True,
+                    "rsi":       round(_rsi, 2) if not _np.isnan(_rsi) else None,
+                    "macd_hist": round(_mhist, 4),
+                    "ma20":      round(float(_ma20.iloc[-1]), 2),
+                    "ma60":      round(float(_ma60.iloc[-1]), 2),
+                    "bb_upper":  round(float((_ma20 + 2 * _std20).iloc[-1]), 2),
+                    "bb_lower":  round(float((_ma20 - 2 * _std20).iloc[-1]), 2),
+                    "provider":  "yfinance_direct",
+                }
+                # Back-fill volume if missing from quote
+                if volume is None or str(volume) in ("None", "N/A", ""):
+                    _recent_vol = _vol.iloc[-1]
+                    if not _np.isnan(_recent_vol):
+                        volume = int(_recent_vol)
+        except Exception:
+            pass
+
+    # Finnhub candle fallback: when price came from Finnhub but yfinance TA failed,
+    # fetch 6-month daily candles from Finnhub to compute RSI/MACD/MA.
+    # Only attempted for US-style symbols (no A-share 6-digit codes, no .HK).
+    _is_us_sym = bool(symbol and not symbol.isdigit() and "." not in symbol)
+    if (not ti.get("success") or ti.get("rsi") is None) and _fh_key and _is_us_sym:
+        try:
+            import requests as _rq2
+            import time as _t2
+            _to_ts = int(_t2.time())
+            _from_ts = _to_ts - 180 * 86400   # ~6 months
+            _cr = _rq2.get(
+                f"https://finnhub.io/api/v1/stock/candle"
+                f"?symbol={symbol}&resolution=D&from={_from_ts}&to={_to_ts}&token={_fh_key}",
+                timeout=8,
+            )
+            if _cr.status_code == 200:
+                _cd = _cr.json()
+                if _cd.get("s") == "ok" and _cd.get("c") and len(_cd["c"]) >= 20:
+                    import numpy as _np2
+                    _c = _cd["c"]   # close prices list
+                    _v = _cd.get("v", [])
+                    import statistics as _st
+                    # RSI(14) — simple loop (no pandas needed)
+                    _gains, _losses = [], []
+                    for i in range(1, len(_c)):
+                        _delta = _c[i] - _c[i-1]
+                        _gains.append(max(_delta, 0))
+                        _losses.append(max(-_delta, 0))
+                    _ag = sum(_gains[:14]) / 14
+                    _al = sum(_losses[:14]) / 14
+                    for i in range(14, len(_gains)):
+                        _ag = (_ag * 13 + _gains[i]) / 14
+                        _al = (_al * 13 + _losses[i]) / 14
+                    _rsi_fh = (100 - 100 / (1 + _ag / _al)) if _al else 100
+                    # MACD(12,26,9)
+                    def _ema_list(prices, span):
+                        k, result_ema = 2/(span+1), [prices[0]]
+                        for p in prices[1:]: result_ema.append(p*k + result_ema[-1]*(1-k))
+                        return result_ema
+                    _ema12_fh = _ema_list(_c, 12)
+                    _ema26_fh = _ema_list(_c, 26)
+                    _macd_fh  = [a - b for a, b in zip(_ema12_fh, _ema26_fh)]
+                    _sig_fh   = _ema_list(_macd_fh, 9)
+                    _mhist_fh = _macd_fh[-1] - _sig_fh[-1]
+                    # MA20 / MA60
+                    _ma20_fh = sum(_c[-20:]) / 20
+                    _ma60_fh = sum(_c[-60:]) / 60 if len(_c) >= 60 else _ma20_fh
+                    # Bollinger Bands
+                    _std20_fh = _st.stdev(_c[-20:])
+                    ti = {
+                        "success":   True,
+                        "rsi":       round(_rsi_fh, 2),
+                        "macd_hist": round(_mhist_fh, 4),
+                        "ma20":      round(_ma20_fh, 2),
+                        "ma60":      round(_ma60_fh, 2),
+                        "bb_upper":  round(_ma20_fh + 2*_std20_fh, 2),
+                        "bb_lower":  round(_ma20_fh - 2*_std20_fh, 2),
+                        "provider":  "finnhub_candle",
+                    }
+                    if volume is None and _v:
+                        volume = int(_v[-1]) if _v[-1] else None
+        except Exception:
+            pass
+
+    # Yahoo Finance v8 direct API — different endpoint from yfinance, avoids rate-limit collision.
+    # Used when yfinance (via MDC) AND Finnhub candle both fail to produce TA data.
+    # Only for non-A-share symbols; A-shares use akshare which has its own path above.
+    if (not ti.get("success") or ti.get("rsi") is None) and _is_us_sym:
+        try:
+            import json as _json_yv8
+            import urllib.request as _urlreq_yv8
+            _yv8_url = (
+                f"https://query1.finance.yahoo.com/v8/finance/chart/{symbol}"
+                "?interval=1d&range=6mo"
+            )
+            _yv8_req = _urlreq_yv8.Request(_yv8_url, headers={
+                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
+                "Accept": "application/json",
+            })
+            with _urlreq_yv8.urlopen(_yv8_req, timeout=10) as _yv8_resp:
+                _yv8_data = _json_yv8.loads(_yv8_resp.read())
+            _yv8_result = _yv8_data["chart"]["result"][0]
+            _yv8_q      = _yv8_result["indicators"]["quote"][0]
+            _c_yv8      = [x for x in _yv8_q.get("close", []) if x is not None]
+            _v_yv8      = [x for x in _yv8_q.get("volume", []) if x is not None]
+            if len(_c_yv8) >= 26:
+                _c = _c_yv8
+                # RSI(14) — Wilder EMA
+                _d = [_c[i] - _c[i-1] for i in range(1, len(_c))]
+                _g = [max(x, 0) for x in _d];  _l = [max(-x, 0) for x in _d]
+                _ag = sum(_g[:14]) / 14;        _al = sum(_l[:14]) / 14
+                for i in range(14, len(_g)):
+                    _ag = (_ag * 13 + _g[i]) / 14; _al = (_al * 13 + _l[i]) / 14
+                _rsi_yv8 = (100 - 100 / (1 + _ag / _al)) if _al else 100.0
+                # MACD(12,26,9)
+                def _ema_yv8(prices, span):
+                    k, r = 2 / (span + 1), [prices[0]]
+                    for p in prices[1:]: r.append(p * k + r[-1] * (1 - k))
+                    return r
+                _ema12 = _ema_yv8(_c, 12); _ema26 = _ema_yv8(_c, 26)
+                _macd  = [a - b for a, b in zip(_ema12, _ema26)]
+                _sig   = _ema_yv8(_macd, 9)
+                _mhist_yv8 = _macd[-1] - _sig[-1]
+                # MA20 / MA60 / Bollinger
+                _ma20_yv8 = sum(_c[-20:]) / 20
+                _ma60_yv8 = sum(_c[-60:]) / 60 if len(_c) >= 60 else _ma20_yv8
+                import statistics as _st_yv8
+                _std20_yv8 = _st_yv8.stdev(_c[-20:])
+                ti = {
+                    "success":   True,
+                    "rsi":       round(_rsi_yv8, 2),
+                    "macd_hist": round(_mhist_yv8, 4),
+                    "ma20":      round(_ma20_yv8, 2),
+                    "ma60":      round(_ma60_yv8, 2),
+                    "bb_upper":  round(_ma20_yv8 + 2 * _std20_yv8, 2),
+                    "bb_lower":  round(_ma20_yv8 - 2 * _std20_yv8, 2),
+                    "provider":  "yahoo_v8",
+                }
+                if volume is None and _v_yv8:
+                    volume = int(_v_yv8[-1])
+        except Exception:
+            pass
+
+    rsi = _num(ti.get("rsi"))
+    mhist = _num(ti.get("macd_hist"))
+    ma20 = _num(ti.get("ma20"))
+    ma60 = _num(ti.get("ma60"))
+    bbu = _num(ti.get("bb_upper"))
+    bbl = _num(ti.get("bb_lower"))
+
+    if rsi is None:
+        rsi_view = "—"
+    elif rsi >= 70:
+        rsi_view = f"{rsi:.1f}，超买风险"
+    elif rsi <= 30:
+        rsi_view = f"{rsi:.1f}，超卖反弹可能"
+    else:
+        rsi_view = f"{rsi:.1f}，中性"
+
+    if mhist is None:
+        macd_view = "—"
+    else:
+        macd_view = f"{mhist:.4f}，{'偏多' if mhist > 0 else '偏空'}"
+
+    supports = [v for v in (bbl, ma60, ma20) if v is not None and v < price]
+    resistances = [v for v in (ma20, ma60, bbu) if v is not None and v > price]
+    supports = sorted(set(round(v, 2) for v in supports), reverse=True)[:3]
+    resistances = sorted(set(round(v, 2) for v in resistances))[:3]
+    support_str = ", ".join(f"{currency} {v:,.2f}" for v in supports)
+    resistance_str = ", ".join(f"{currency} {v:,.2f}" for v in resistances)
+    timeframe_levels = _build_timeframe_levels(
+        locals().get("mdc"),
+        symbol,
+        price,
+        currency,
+        ma20=ma20,
+        ma60=ma60,
+        bb_lower=bbl,
+        bb_upper=bbu,
+        fallback_supports=supports,
+        fallback_resistances=resistances,
+    )
+
+    # ── Signal logic ──────────────────────────────────────────────────────────
+    _enough_data = (rsi is not None) or (mhist is not None)
+
+    _SIGNAL_LABELS: dict[str, dict[str, str]] = {
+        "zh": {
+            "STRONG_BUY": "强势多头 — 趋势与动量共振",
+            "BUY":     "偏多 — 量化条件支持上行",
+            "SELL":    "偏空 — 量化条件提示下行",
+            "STRONG_SELL": "强势空头 — 趋势与动量共振下行",
+            "CAUTION": "超买 — 等待回调确认",
+            "WATCH":   "超卖 — 关注企稳信号",
+            "HOLD+":   "短线偏强，控制仓位",
+            "HOLD−":   "短线偏弱，守住支撑",
+            "NEUTRAL": "震荡观察，等待方向",
+            "—":       "指标数据不足",
+        },
+        "en": {
+            "STRONG_BUY": "Strong bullish — trend and momentum aligned",
+            "BUY":     "Bullish — quantitative setup supports upside",
+            "SELL":    "Bearish — quantitative setup warns downside",
+            "STRONG_SELL": "Strong bearish — trend and momentum aligned lower",
+            "CAUTION": "Overbought — wait for pullback",
+            "WATCH":   "Oversold — watch for stabilization",
+            "HOLD+":   "Short-term bias up, manage size",
+            "HOLD−":   "Short-term bias down, hold support",
+            "NEUTRAL": "Ranging — wait for direction",
+            "—":       "Insufficient indicator data",
+        },
+    }
+
+    if _enough_data:
+        _signal_score = 0
+        _signal_reasons = []
+        if ma20 is not None:
+            if price > ma20:
+                _signal_score += 1
+                _signal_reasons.append("price>MA20")
+            else:
+                _signal_score -= 1
+                _signal_reasons.append("price<MA20")
+        if ma60 is not None:
+            if price > ma60:
+                _signal_score += 1
+                _signal_reasons.append("price>MA60")
+            else:
+                _signal_score -= 1
+                _signal_reasons.append("price<MA60")
+        if mhist is not None:
+            if mhist > 0:
+                _signal_score += 1
+                _signal_reasons.append("MACD+")
+            elif mhist < 0:
+                _signal_score -= 1
+                _signal_reasons.append("MACD-")
+        if rsi is not None:
+            if rsi <= 30:
+                _signal_score += 2
+                _signal_reasons.append("RSI oversold")
+            elif rsi <= 40:
+                _signal_score += 1
+                _signal_reasons.append("RSI low")
+            elif rsi >= 75:
+                _signal_score -= 2
+                _signal_reasons.append("RSI very high")
+            elif rsi >= 65:
+                _signal_score -= 1
+                _signal_reasons.append("RSI high")
+        if chg is not None:
+            if chg >= 2:
+                _signal_score += 1
+                _signal_reasons.append("day momentum+")
+            elif chg <= -2:
+                _signal_score -= 1
+                _signal_reasons.append("day momentum-")
+
+        if _signal_score >= 4:
+            _sig_key = "STRONG_BUY"
+        elif _signal_score >= 2:
+            _sig_key = "BUY"
+        elif _signal_score <= -4:
+            _sig_key = "STRONG_SELL"
+        elif _signal_score <= -2:
+            _sig_key = "SELL"
+        elif _signal_score == 1:
+            _sig_key = "HOLD+"
+        elif _signal_score == -1:
+            _sig_key = "HOLD−"
+        else:
+            _sig_key = "NEUTRAL"
+    else:
+        _sig_key = "—"
+        _signal_score = 0
+        _signal_reasons = []
+    _signal_confidence = min(0.82, 0.46 + abs(_signal_score) * 0.07) if _enough_data else 0.0
+
+    signal = _sig_key
+    signal_str = _SIGNAL_LABELS["zh"][_sig_key]  # will be overwritten after _lang is resolved below
+
+    # ── Price-action analysis (available even without TA) ─────────────────
+    _range_size = (high - low) if (high is not None and low is not None) else None
+    _price_pos  = int((price - low) / _range_size * 100) if _range_size and _range_size > 0 else None
+    _swing_pct  = round(_range_size / price * 100, 2) if _range_size and price else None
+    _chg_abs    = abs(chg) if chg is not None else None
+
+    # ── Build output ──────────────────────────────────────────────────────
+    ti_provider = ti.get("provider", "")
+    quote_chain = quote.get("provider_chain") or [provider]
+    data_src = " -> ".join(str(p) for p in quote_chain if p)
+    if ti_provider and ti_provider not in quote_chain:
+        data_src += f" + {ti_provider}"
+    # volume == 0 means "not reported" here (finnhub /quote has no volume),
+    # not "zero trading" — treat as unknown so we hide the row vs showing "0".
+    _vol_str = _fmt_int(volume) if volume else "N/A"
+    _now_str = datetime.now().strftime("%Y-%m-%d")
+
+    # ── Language-aware labels ─────────────────────────────────────────────
+    _lang = _detect_lang(message)
+    _en = _lang == "en"
+    signal_str = _SIGNAL_LABELS.get(_lang, _SIGNAL_LABELS["zh"])[_sig_key]
+    _L = {
+        "disclaimer":   "Not investment advice" if _en else "不构成投资建议",
+        "session_open":   "Market open" if _en else "盘中",
+        "session_pre":    "Pre-market" if _en else "盘前",
+        "session_post":   "After-hours" if _en else "盘后",
+        "session_closed": "Market closed" if _en else "休市",
+        "session_24/7":   "24/7 market" if _en else "全天交易",
+        "price_hdr":    "Metric" if _en else "指标",
+        "value_hdr":    "Value" if _en else "数值",
+        "latest":       "Last price" if _en else "最新价",
+        "day_range":    "Day range" if _en else "日内区间",
+        "swing":        "Swing" if _en else "振幅",
+        "mktcap":       "Mkt cap" if _en else "市值",
+        "volume":       "Volume" if _en else "成交量",
+        "ta_hdr":       "Indicator" if _en else "技术指标",
+        "meaning_hdr":  "Meaning" if _en else "含义",
+        "overbought":   "Overbought" if _en else "超买",
+        "oversold":     "Oversold" if _en else "超卖",
+        "neutral":      "Neutral" if _en else "中性",
+        "bull_mom":     "Bullish momentum" if _en else "多头动能",
+        "bear_mom":     "Bearish momentum" if _en else "空头动能",
+        "above_ma20":   "Above MA20 ↑" if _en else "价格高于MA20 ↑",
+        "below_ma20":   "Below MA20 ↓" if _en else "价格低于MA20 ↓",
+        "above_ma60":   "Above MA60 ↑" if _en else "价格高于MA60 ↑",
+        "below_ma60":   "Below MA60 ↓" if _en else "价格低于MA60 ↓",
+        "support":      "Support" if _en else "支撑位",
+        "resistance":   "Resistance" if _en else "阻力位",
+        "signal_lbl":   "**Signal**" if _en else "**信号**",
+        "pa_hdr":       "**Price action** (TA indicators unavailable)" if _en else "**价格行动分析**（仅基于价格，TA 指标暂不可用）",
+        "sig_no_ta":    "TA indicators unavailable, price action above for reference" if _en else "技术指标暂缺，以上价格行动供参考",
+        "ta_unavail":   (f"*TA data unavailable — retry later or run `/ta {symbol}`*") if _en
+                        else f"*TA 数据暂时不可用，稍后重试或运行 `/ta {symbol}`*",
+        "ta_hint_fh":   ("*Enable full TA*: set a free Finnhub key → `/apikey set finnhub <KEY>`"
+                         "  ([finnhub.io](https://finnhub.io/register))") if _en else
+                        ("*启用完整 TA*：配置免费 Finnhub key → `/apikey set finnhub <KEY>`"
+                         "  ([注册](https://finnhub.io/register))"),
+        "data_status":  "**Data status**" if _en else "**数据状态**",
+        "stale_warn":   "Data may be stale, please retry later" if _en else "数据可能已过期，请稍后重试",
+        "missing":      "Missing fields" if _en else "缺少字段",
+        "rate_warn":    "Data source rate-limited, will auto-retry" if _en else "数据源请求频率受限，稍后自动重试",
+        "timeout_warn": "Data source request timed out" if _en else "数据源请求超时",
+        "nodata_warn":  "No data available for this symbol" if _en else "该标的暂无数据",
+        "next_hdr":     "**Next steps**" if _en else "**下一步**",
+        "team_desc":    "Deep analysis (fundamental + technical)" if _en else "深度分析（基本面 + 技术面）",
+        "ta_desc":      "Open full technical chart" if _en else "打开完整技术图表",
+        "report_desc":  "Generate institutional research report" if _en else "生成机构级研究报告",
+        "backtest_desc":"Backtest 1y momentum strategy" if _en else "回测 1 年动量策略",
+        "pos_high":     "Upper range" if _en else "日内高位",
+        "pos_low":      "Lower range" if _en else "日内低位",
+        "pos_mid":      "Mid range" if _en else "日内中段",
+        "pos_pct":      "day percentile" if _en else "百分位",
+        "swing_high":   " (high volatility)" if _en else "（波动偏大）",
+        "flat":         "Flat" if _en else "持平",
+        "rising":       "Up" if _en else "上涨",
+        "falling":      "Down" if _en else "下跌",
+        "strong":       " (sharp)" if _en else "（大幅）",
+        "mild":         " (mild)" if _en else "（温和）",
+        "day_momentum": "Momentum" if _en else "今日动能",
+        "day_pos":      "Price position" if _en else "价格位置",
+        "day_swing":    "Day swing" if _en else "日内振幅",
+    }
+
+    _sep = ": " if _en else "："
+    # On the exchange's clock, not this machine's; nothing when it is unknown.
+    _session = market_session(symbol)
+    session_note = _L.get(f"session_{_session}", "") if _session else ""
+
+    def _money(v: float | int | None) -> str:
+        try:
+            return f"{currency} {float(v):,.2f}"
+        except Exception:
+            return "—"
+
+    if _enough_data:
+        if _sig_key in ("STRONG_BUY", "BUY", "HOLD+"):
+            _bias_label = "bullish" if _en else "偏强"
+        elif _sig_key in ("STRONG_SELL", "SELL", "HOLD−"):
+            _bias_label = "bearish" if _en else "偏弱"
+        else:
+            _bias_label = "range-bound" if _en else "震荡"
+    else:
+        _bias_label = "insufficient TA data" if _en else "指标不足"
+
+    _trend_bits = []
+    if ma20 is not None:
+        _trend_bits.append(("above MA20" if price > ma20 else "below MA20") if _en else ("站上 MA20" if price > ma20 else "低于 MA20"))
+    if ma60 is not None:
+        _trend_bits.append(("above MA60" if price > ma60 else "below MA60") if _en else ("站上 MA60" if price > ma60 else "低于 MA60"))
+    if mhist is not None:
+        _trend_bits.append(("MACD positive" if mhist > 0 else "MACD negative") if _en else ("MACD 偏多" if mhist > 0 else "MACD 偏空"))
+    if rsi is not None:
+        if rsi >= 70:
+            _trend_bits.append("RSI overbought" if _en else "RSI 超买")
+        elif rsi <= 30:
+            _trend_bits.append("RSI oversold" if _en else "RSI 超卖")
+        else:
+            _trend_bits.append(f"RSI {rsi:.1f} neutral" if _en else f"RSI {rsi:.1f} 中性")
+
+    _watch_supports = next((row.get("support") or [] for row in timeframe_levels if row.get("support")), supports)
+    _watch_resistances = next((row.get("resistance") or [] for row in timeframe_levels if row.get("resistance")), resistances)
+    _nearest_support = _watch_supports[0] if _watch_supports else None
+    _nearest_resistance = _watch_resistances[0] if _watch_resistances else None
+    if _en:
+        _summary_line = f"{symbol} is currently {str(_bias_label)}"
+        if _trend_bits:
+            _summary_line += " — " + ", ".join(_trend_bits[:3]) + "."
+        else:
+            _summary_line += "."
+        if _nearest_support is not None and _nearest_resistance is not None:
+            _watch_line = (
+                f"Watch {_money(_nearest_resistance)} for a bullish break; "
+                f"losing {_money(_nearest_support)} raises downside risk."
+            )
+        elif _nearest_resistance is not None:
+            _watch_line = f"Watch {_money(_nearest_resistance)} as the next resistance."
+        elif _nearest_support is not None:
+            _watch_line = f"Watch {_money(_nearest_support)} as the nearest support."
+        else:
+            _watch_line = "No reliable support/resistance from current data."
+    else:
+        _summary_line = f"{symbol} 当前{_bias_label}"
+        if _trend_bits:
+            _summary_line += "，" + "，".join(_trend_bits[:3]) + "。"
+        else:
+            _summary_line += "。"
+        if _nearest_support is not None and _nearest_resistance is not None:
+            _watch_line = f"上破 {_money(_nearest_resistance)} 才能转强；跌破 {_money(_nearest_support)} 风险放大。"
+        elif _nearest_resistance is not None:
+            _watch_line = f"重点观察 {_money(_nearest_resistance)} 阻力。"
+        elif _nearest_support is not None:
+            _watch_line = f"重点观察 {_money(_nearest_support)} 支撑。"
+        else:
+            _watch_line = "当前数据不足以给出可靠支撑/阻力。"
+
+    _positive_reasons = []
+    _negative_reasons = []
+    _neutral_reasons = []
+    if ma20 is not None:
+        (_positive_reasons if price > ma20 else _negative_reasons).append("price>MA20" if _en and price > ma20 else "price<MA20" if _en else "价格高于 MA20" if price > ma20 else "价格低于 MA20")
+    if ma60 is not None:
+        (_positive_reasons if price > ma60 else _negative_reasons).append("price>MA60" if _en and price > ma60 else "price<MA60" if _en else "价格高于 MA60" if price > ma60 else "价格低于 MA60")
+    if mhist is not None:
+        (_positive_reasons if mhist > 0 else _negative_reasons).append("MACD positive" if _en and mhist > 0 else "MACD negative" if _en else "MACD 偏多" if mhist > 0 else "MACD 偏空")
+    if rsi is not None:
+        if 30 < rsi < 70:
+            _neutral_reasons.append(f"RSI {rsi:.1f} neutral" if _en else f"RSI {rsi:.1f} 中性")
+        elif rsi <= 30:
+            _positive_reasons.append("RSI oversold" if _en else "RSI 超卖")
+        elif rsi >= 70:
+            _negative_reasons.append("RSI overbought" if _en else "RSI 超买")
+
+    def _join_reasons(items: list[str]) -> str:
+        return ", ".join(items) if _en else "、".join(items)
+
+    lines = []
+    # ── Header ──
+    _header_name = name if name and name.upper() != symbol.upper() else ""
+    if _header_name:
+        lines.append(f"## {_header_name}  `{symbol}`")
+    else:
+        lines.append(f"## `{symbol}`")
+    lines.append("*" + " · ".join(p for p in (data_src, _now_str, session_note, _L["disclaimer"]) if p) + "*")
+    lines.append("")
+    # Two trailing spaces: a Markdown line break. Without it the renderer
+    # joined these lines into one paragraph ("…MACD negative. Watch: Watch
+    # USD 334.30…"). "Levels", not "Watch": the line itself starts "Watch …".
+    lines.append(f"**{'Takeaway' if _en else '结论'}**{_sep}{_summary_line}  ")
+    lines.append(f"**{'Levels' if _en else '观察位'}**{_sep}{_watch_line}")
+    lines.append("")
+
+    # ── Price table ──
+    _chg_display = chg_str if (chg is not None and abs(chg) >= 0.005) else "—"
+    lines.append(f"| {_L['price_hdr']} | {_L['value_hdr']} |")
+    lines.append("|------|------|")
+    lines.append(f"| {_L['latest']} | **{currency} {price:,.2f}**  `{_chg_display}` |")
+    if range_str:
+        swing_cell = f"  {_L['swing']} {_swing_pct:.1f}%" if _swing_pct else ""
+        lines.append(f"| {_L['day_range']} | {range_str}{swing_cell} |")
+    if _mktcap_str:
+        lines.append(f"| {_L['mktcap']} | {_mktcap_str} |")
+    if _vol_str != "N/A":
+        lines.append(f"| {_L['volume']} | {_vol_str} |")
+
+    # ── Technical table ──
+    lines.append("")
+    lines.append(f"| {_L['ta_hdr']} | {_L['value_hdr']} | {_L['meaning_hdr']} |")
+    lines.append("|---------|------|------|")
+    if rsi is not None:
+        _rsi_meaning = _L["overbought"] if rsi >= 70 else (_L["oversold"] if rsi <= 30 else _L["neutral"])
+        # rsi_view carries a Chinese gloss; the Meaning column says it in English.
+        lines.append(f"| RSI(14) | {f'{rsi:.1f}' if _en else rsi_view} | {_rsi_meaning} |")
+    else:
+        lines.append("| RSI(14) | — | — |")
+    if mhist is not None:
+        _macd_meaning = _L["bull_mom"] if mhist > 0 else _L["bear_mom"]
+        lines.append(f"| MACD hist | {mhist:.4f} | {_macd_meaning} |")
+    else:
+        lines.append("| MACD hist | — | — |")
+    if ma20 is not None:
+        lines.append(f"| MA20 | {currency} {ma20:,.2f} | {_L['above_ma20'] if price > ma20 else _L['below_ma20']} |")
+    if ma60 is not None:
+        lines.append(f"| MA60 | {currency} {ma60:,.2f} | {_L['above_ma60'] if price > ma60 else _L['below_ma60']} |")
+    if support_str:
+        lines.append(f"| {_L['support']} | {support_str} | |")
+    if resistance_str:
+        lines.append(f"| {_L['resistance']} | {resistance_str} | |")
+
+    _append_timeframe_levels(lines, timeframe_levels, currency, english=_en)
+
+    # ── Price-action lines (rebuild with language-aware labels) ──
+    _pa_lines_l10n = []
+    if _price_pos is not None:
+        _pos_label = _L["pos_high"] if _price_pos >= 70 else (_L["pos_low"] if _price_pos <= 30 else _L["pos_mid"])
+        _pa_lines_l10n.append(
+            f"{_L['day_pos']}: {_pos_label} ({_price_pos}th percentile of the day's range)" if _en else
+            f"{_L['day_pos']}：{_pos_label}（日内第 {_price_pos} {_L['pos_pct']}）")
+    if _swing_pct:
+        _swing_note = _L["swing_high"] if _swing_pct > 3 else ""
+        _pa_lines_l10n.append(f"{_L['day_swing']}{_sep}{_swing_pct:.1f}%{_swing_note}")
+    if chg is not None and _chg_abs is not None:
+        if _chg_abs < 0.01:
+            _pa_lines_l10n.append(f"{_L['day_momentum']}{_sep}{_L['flat']}")
+        else:
+            _mo = _L["rising"] if chg > 0 else _L["falling"]
+            _strength = _L["strong"] if _chg_abs > 2 else (_L["mild"] if _chg_abs < 0.5 else "")
+            _pa_lines_l10n.append(f"{_L['day_momentum']}{_sep}{_mo} {_chg_abs:.2f}%{_strength}")
+
+    # ── Signal ──
+    lines.append("")
+    if _enough_data:
+        _score_detail = (
+            f" · score {_signal_score:+d} · confidence {_signal_confidence:.0%}"
+            if _en else
+            f" · 量化分 {_signal_score:+d} · 置信度 {_signal_confidence:.0%}"
+        )
+        lines.append(f"{_L['signal_lbl']}{_sep}`{signal}` — {signal_str}{_score_detail}  ")
+        _reason_parts = []
+        if _positive_reasons:
+            _reason_parts.append(("support: " if _en else "支撑：") + _join_reasons(_positive_reasons[:3]))
+        if _negative_reasons:
+            _reason_parts.append(("pressure: " if _en else "压力：") + _join_reasons(_negative_reasons[:3]))
+        if _neutral_reasons:
+            _reason_parts.append(("neutral: " if _en else "中性：") + _join_reasons(_neutral_reasons[:2]))
+        if _reason_parts:
+            lines.append(f"**{'Signal drivers' if _en else '信号拆解'}**{_sep}" + ("; ".join(_reason_parts) if _en else "；".join(_reason_parts)))
+    else:
+        lines.append(_L["pa_hdr"])
+        for _pal in _pa_lines_l10n:
+            lines.append(f"- {_pal}")
+        lines.append("")
+        lines.append(f"{_L['signal_lbl']}{_sep}`{signal}` — {_L['sig_no_ta']}")
+
+    # ── Config hint (show only when TA missing) ──
+    if not _enough_data:
+        lines.append("")
+        if _is_a_share:
+            _ak_hint = (f"> **Full TA data**: akshare should be available — retry or run `/ta {symbol}`"
+                        if _en else
+                        f"> **完整 TA 数据**：akshare 应已可用，若持续失败请重试或运行 `/ta {symbol}`")
+            lines.append(_ak_hint)
+        elif not _fh_key:
+            lines.append(_L["ta_hint_fh"])
+        else:
+            lines.append(_L["ta_unavail"])
+
+    # ── Prediction hint when the user explicitly asks for forecast/outlook ──
+    if any(k in message.lower() for k in ("预测", "预判", "forecast", "predict", "prediction", "outlook")):
+        _prediction_added = False
+
+        def _append_rule_prediction() -> None:
+            nonlocal _prediction_added
+            if _prediction_added or not _enough_data:
+                return
+            score = 0
+            if ma20 is not None:
+                score += 1 if price > ma20 else -1
+            if ma60 is not None:
+                score += 1 if price > ma60 else -1
+            if mhist is not None:
+                score += 1 if mhist > 0 else -1
+            if rsi is not None:
+                if rsi >= 75:
+                    score -= 1
+                elif rsi <= 30:
+                    score += 1
+            if _en:
+                direction = "bullish" if score >= 2 else ("bearish" if score <= -2 else "range-bound")
+                confidence = min(0.7, 0.45 + abs(score) * 0.06)
+                lines.append("")
+                lines.append("### Forecast reference")
+                lines.append(f"- Rule-based direction: `{direction}` · confidence: {confidence:.0%}")
+                lines.append("- Prediction model did not return this symbol; this is inferred only from RSI, MACD, and moving averages.")
+            else:
+                direction = "偏强" if score >= 2 else ("偏弱" if score <= -2 else "震荡")
+                confidence = min(0.7, 0.45 + abs(score) * 0.06)
+                lines.append("")
+                lines.append("### 预测参考")
+                lines.append(f"- 规则型方向：`{direction}` · 置信度：{confidence:.0%}")
+                lines.append("- 预测工具当前未返回该标的数据，以上仅由 RSI、MACD 和均线结构推导。")
+            _prediction_added = True
+
+        try:
+            pred_symbol = symbol
+            if _is_a_share and _ashare_code:
+                pred_symbol = ("sh" if _ashare_code.startswith(("6", "9")) else "sz") + _ashare_code
+            from local_finance_tools import _get_predictions
+            import contextlib as _ctxlib_pred
+            import io as _io_pred
+            with _ctxlib_pred.redirect_stdout(_io_pred.StringIO()), _ctxlib_pred.redirect_stderr(_io_pred.StringIO()):
+                pred = _get_predictions({"symbols": [pred_symbol], "prediction_days": 5})
+            preds = pred.get("predictions") or []
+            if preds:
+                p0 = preds[0]
+                direction = str(p0.get("direction") or p0.get("signal") or "neutral")
+                ret = p0.get("predicted_return")
+                conf = p0.get("confidence")
+                lines.append("")
+                lines.append("### 预测参考")
+                bits = [f"方向：`{direction}`"]
+                try:
+                    bits.append(f"5日预期收益：{float(ret):+.2%}")
+                except Exception:
+                    pass
+                try:
+                    bits.append(f"置信度：{float(conf):.0%}")
+                except Exception:
+                    pass
+                lines.append("- " + " · ".join(bits))
+                lines.append("- 该预测由本地动量/技术因子模型生成，只作为风险参考，不构成投资建议。")
+                _prediction_added = True
+            elif _enough_data:
+                _append_rule_prediction()
+        except Exception:
+            _append_rule_prediction()
+
+    # ── Data quality — only show when actionable ──
+    _quality_missing = _snapshot_quality.get("missing_fields") or []
+    _quality_warnings = _snapshot_quality.get("warnings") or []
+    _quality_errors = _snapshot_quality.get("errors") or []
+    _quality_status = _snapshot_quality.get("status", "")
+    _show_quality = _quality_status in ("unavailable", "partial", "stale") or bool(_quality_missing)
+    if _snapshot_quality and _show_quality:
+        lines.append("")
+        lines.append(_L["data_status"])
+        if _snapshot_quality.get("stale"):
+            lines.append(f"- {_L['stale_warn']}")
+        if _quality_missing:
+            _missing_map = {"price": "price" if _en else "价格",
+                            "volume": "volume" if _en else "成交量",
+                            "change": "change %" if _en else "涨跌幅"}
+            # Suppress "price" from missing list when we actually have a price to display —
+            # it means the primary source (yfinance) failed but a fallback (Finnhub) succeeded.
+            _filtered_missing = [
+                f for f in _quality_missing
+                if not (f == "price" and price is not None and price > 0)
+            ]
+            _missing_labels = [_missing_map.get(f, f) for f in _filtered_missing]
+            if _missing_labels:
+                lines.append(f"- {_L['missing']}: {', '.join(_missing_labels)}")
+        _user_warnings = []
+        for w in (_quality_warnings + _quality_errors)[:2]:
+            _w = str(w)
+            if "rate" in _w.lower() or "429" in _w.lower() or "too many" in _w.lower():
+                _user_warnings.append(_L["rate_warn"])
+            elif "timeout" in _w.lower():
+                _user_warnings.append(_L["timeout_warn"])
+            elif "not found" in _w.lower() or "no data" in _w.lower():
+                _user_warnings.append(_L["nodata_warn"])
+        for _uw in dict.fromkeys(_user_warnings):
+            lines.append(f"- {_uw}")
+
+    # ── Next actions ──
+    lines.append("")
+    lines.append(_L["next_hdr"])
+    lines.append(f"- `/team {symbol}` — {_L['team_desc']}")
+    lines.append(f"- `/ta {symbol}` — {_L['ta_desc']}")
+    if _is_a_share:
+        lines.append(f"- `/report {symbol}` — {_L['report_desc']}")
+    else:
+        lines.append(f"- `/backtest momentum {symbol} --period 1y` — {_L['backtest_desc']}")
+
+    return {
+        "success": True,
+        "response": "\n".join(lines),
+        "tools_used": ["market_snapshot"],
+        "analysis_complete": True,
+        "symbol": symbol,
+        "price": price,
+        "change_pct": chg,
+        "currency": currency,
+        "name": name,
+        "signal": signal,
+        "signal_score": _signal_score,
+        "signal_confidence": _signal_confidence,
+        "rsi": rsi,
+        "macd_hist": mhist,
+        "ma20": ma20,
+        "ma60": ma60,
+        "bb_upper": bbu,
+        "bb_lower": bbl,
+        "support": support_str,
+        "resistance": resistance_str,
+        "supports": supports,
+        "resistances": resistances,
+        "timeframe_levels": timeframe_levels,
+        "data_src": data_src,
+        "as_of": _now_str,
+    }