young-stock-cli 0.2.2__tar.gz → 0.2.3__tar.gz

{young_stock_cli-0.2.2 → young_stock_cli-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: young-stock-cli
-Version: 0.2.2
+Version: 0.2.3
 Summary: A-share (China stock market) after-hours CLI — no login, no scraping tricks, just data.
 Project-URL: Homepage, https://github.com/AdvancingTitans/young-stock-cli
 Project-URL: Repository, https://github.com/AdvancingTitans/young-stock-cli
@@ -269,6 +269,27 @@ checks. Markdown, metadata, and `evidence.json` are retained under:
 ~/.young_stock/reports/YYYYMMDD/
 ```
 
+Before the model sees any data, young converts internal evidence into research-only Chinese terminology. The same
+conversion is applied to the downloaded stock-analysis methodology, so implementation guidance never enters the
+report-writing context. The returned Markdown is reviewed again before it can be saved or exported. Formal reports
+use only these source phrases:
+
+- normal data: `据公开市场数据`, `据交易所及财经终端披露`
+- missing data: `该指标当日未披露`, `历史数据不可得`, `本模块证据暂缺`
+- historical lookback: `按惯例回溯至该日`, `历史口径回溯`
+
+Report artifacts include the date, market session, and topic:
+
+```text
+20260618-早盘-A股深度复盘.md
+20260618-盘中-A股深度复盘.md
+20260618-盘后-A股深度复盘.md
+20260618-盘后-600519深度分析.md
+```
+
+Generating the same topic again in the same session replaces the previous artifact. A report from another session
+is retained.
+
 ### Professional PDF reports
 
 Install the optional renderer:

{young_stock_cli-0.2.2 → young_stock_cli-0.2.3}/README.md

@@ -234,6 +234,27 @@ checks. Markdown, metadata, and `evidence.json` are retained under:
 ~/.young_stock/reports/YYYYMMDD/
 ```
 
+Before the model sees any data, young converts internal evidence into research-only Chinese terminology. The same
+conversion is applied to the downloaded stock-analysis methodology, so implementation guidance never enters the
+report-writing context. The returned Markdown is reviewed again before it can be saved or exported. Formal reports
+use only these source phrases:
+
+- normal data: `据公开市场数据`, `据交易所及财经终端披露`
+- missing data: `该指标当日未披露`, `历史数据不可得`, `本模块证据暂缺`
+- historical lookback: `按惯例回溯至该日`, `历史口径回溯`
+
+Report artifacts include the date, market session, and topic:
+
+```text
+20260618-早盘-A股深度复盘.md
+20260618-盘中-A股深度复盘.md
+20260618-盘后-A股深度复盘.md
+20260618-盘后-600519深度分析.md
+```
+
+Generating the same topic again in the same session replaces the previous artifact. A report from another session
+is retained.
+
 ### Professional PDF reports
 
 Install the optional renderer:

{young_stock_cli-0.2.2 → young_stock_cli-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "young-stock-cli"
-version = "0.2.2"
+version = "0.2.3"
 description = "A-share (China stock market) after-hours CLI — no login, no scraping tricks, just data."
 readme = "README.md"
 requires-python = ">=3.9"

{young_stock_cli-0.2.2 → young_stock_cli-0.2.3}/src/young_stock/__init__.py

@@ -1,3 +1,3 @@
 """young-stock-cli: A-share after-hours CLI."""
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"

{young_stock_cli-0.2.2 → young_stock_cli-0.2.3}/src/young_stock/_core.py

@@ -36,6 +36,7 @@ from typing import Any
 
 from .calendar import nearest_trade_date as calendar_nearest_trade_date
 from .health import SourceHealthBook
+from .market_routes import route_board_data
 
 # ------------------------------------------------------------------
 # 配置
@@ -716,6 +717,32 @@ def fetch_ths_concept_money_flow_snapshot(date_str: str) -> dict[str, str]:
     return result
 
 
+def fetch_browser_fund_flow_snapshot(date_str: str) -> dict[str, str]:
+    raw = _playwright_html(THS_CONCEPT_MONEY_FLOW_URL)
+    if not raw:
+        return {}
+    rows = _parse_ths_money_flow_table(raw)
+    top_in_rows = sorted(
+        [row for row in rows if float(row.get("net") or 0) > 0],
+        key=lambda item: float(item.get("net") or 0),
+        reverse=True,
+    )[:5]
+    top_out_rows = sorted(
+        [row for row in rows if float(row.get("net") or 0) < 0],
+        key=lambda item: float(item.get("net") or 0),
+    )[:5]
+    if not top_in_rows or not top_out_rows:
+        return {}
+    return {
+        "date": _display_date(nearest_trade_date()),
+        "_source": "公开财经页面概念资金流",
+        "_scope": "A股",
+        "_fallback_indicator": "concept_money_flow",
+        "_concept_in": json.dumps(top_in_rows, ensure_ascii=False),
+        "_concept_out": json.dumps(top_out_rows, ensure_ascii=False),
+    }
+
+
 def _market_activity_snapshot(rows: list[dict[str, Any]], source: str, date_str: str) -> dict[str, str]:
     usable = [r for r in rows if r.get("f12") in {"000001", "399001"}]
     if not usable:
@@ -1995,8 +2022,15 @@ def get_fund_flow(date_str: str, *, strict_date: bool = True) -> dict[str, str]:
         latest_result["_date_note"] = "latest_available"
         cache_save("fund_flow", date_str, "eastmoney", latest_result)
         return latest_result
-    for fallback in (fetch_sina_sector_money_flow_snapshot, fetch_sina_market_activity_snapshot, fetch_tencent_market_activity_snapshot):
-        activity = fallback(date_str)
+    for online_reference in (fetch_sina_sector_money_flow_snapshot,):
+        activity = online_reference(date_str)
+        if activity:
+            return activity
+    browser_flow = fetch_browser_fund_flow_snapshot(date_str)
+    if browser_flow:
+        return browser_flow
+    for market_reference in (fetch_sina_market_activity_snapshot, fetch_tencent_market_activity_snapshot):
+        activity = market_reference(date_str)
         if activity:
             return activity
     cached_latest = load_latest_fund_flow_cache(date_str)
@@ -2171,13 +2205,15 @@ def fetch_eastmoney_board_list(board_type: str, date_str: str, limit: int = 100)
 
 def get_board_list(board_type: str, date_str: str, limit: int = 100) -> dict[str, Any]:
     """Return board rankings through the stock-analysis source order."""
-    result = fetch_eastmoney_board_list(board_type, date_str, limit=limit)
-    if result.get("rows"):
-        return result
-    browser_result = camofox_board_list(board_type)
-    if browser_result.get("rows"):
-        return browser_result
-    return result
+    return route_board_data(
+        board_type,
+        date_str,
+        direct=fetch_eastmoney_board_list,
+        camofox=camofox_board_list,
+        playwright=playwright_board_list,
+        limit=limit,
+        current_trade_date=nearest_trade_date(),
+    )
 
 
 @retry_on_recoverable(max_retries=MAX_RETRIES, initial_delay=INITIAL_BACKOFF)
@@ -2751,6 +2787,36 @@ def _parse_camofox_board_snapshot(markdown: str) -> list[dict[str, Any]]:
     return rows
 
 
+def _playwright_html(url: str) -> str:
+    try:
+        from playwright.sync_api import sync_playwright
+    except ImportError:
+        return ""
+    try:
+        with sync_playwright() as runtime:
+            browser = runtime.chromium.launch(headless=True)
+            page = browser.new_page()
+            page.goto(url, wait_until="networkidle", timeout=20_000)
+            content = page.content()
+            browser.close()
+            return content
+    except Exception as exc:
+        diag(f"Browser page unavailable: {exc}")
+        return ""
+
+
+def playwright_board_list(board_type: str = "industry") -> dict[str, Any]:
+    anchor = "industry_board" if board_type == "industry" else "concept_board"
+    html_text = _playwright_html(f"https://quote.eastmoney.com/center/gridlist.html#{anchor}")
+    if not html_text:
+        return {"board_type": board_type, "rows": [], "_unavailable": "browser unavailable"}
+    text = re.sub(r"<[^>]+>", "  ", html.unescape(html_text))
+    rows = _parse_camofox_board_snapshot(
+        "\n".join(f'row "{line.strip()}"' for line in text.splitlines() if re.match(r"^\s*\d+\s+", line))
+    )
+    return {"board_type": board_type, "rows": rows, "count": len(rows), "_source": "公开财经页面"}
+
+
 def camofox_board_list(board_type: str = "industry") -> dict[str, Any]:
     base = os.environ.get("CAMOFOX_URL", "http://localhost:9377")
     user_id = os.environ.get("CAMOFOX_USER_ID", "")

{young_stock_cli-0.2.2 → young_stock_cli-0.2.3}/src/young_stock/artifacts.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import re
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
@@ -11,6 +12,30 @@ from typing import Any
 from .local_store import young_home
 
 
+def market_session(now: datetime | None = None) -> str:
+    now = now or datetime.now()
+    minute = now.hour * 60 + now.minute
+    if 9 * 60 <= minute < 9 * 60 + 30:
+        return "早盘"
+    if 11 * 60 + 30 <= minute < 13 * 60:
+        return "午间"
+    if 9 * 60 + 30 <= minute < 11 * 60 + 30 or 13 * 60 <= minute < 15 * 60:
+        return "盘中"
+    return "盘后"
+
+
+@dataclass(frozen=True)
+class ReportIdentity:
+    trade_date: str
+    session: str
+    topic: str
+
+    @property
+    def prefix(self) -> str:
+        safe_topic = "".join(character for character in self.topic if character.isalnum() or character in "-_")
+        return f"{self.trade_date}-{self.session}-{safe_topic}"
+
+
 @dataclass
 class ReportArtifacts:
     trade_date: str
@@ -36,6 +61,9 @@ class ReportArtifacts:
         path.write_text(content.rstrip() + "\n", encoding="utf-8")
         return path
 
+    def write_report_markdown(self, identity: ReportIdentity, content: str) -> Path:
+        return self.write_markdown(identity.prefix, content)
+
     def write_json(self, name: str, data: dict[str, Any]) -> Path:
         path = self.path(name, "json")
         path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
@@ -48,6 +76,13 @@ class ReportArtifacts:
             candidates = list((reports / trade_date).glob("*.md"))
         else:
             candidates = list(reports.glob("*/*.md"))
+        identified = [
+            path
+            for path in candidates
+            if re.match(r"^\d{8}-(?:早盘|盘中|午间|盘后)-.+\.md$", path.name)
+        ]
+        if identified:
+            candidates = identified
         return max(candidates, key=lambda path: path.stat().st_mtime) if candidates else None
 
     @classmethod

{young_stock_cli-0.2.2 → young_stock_cli-0.2.3}/src/young_stock/cli.py

@@ -10,7 +10,7 @@ from datetime import datetime
 import click
 
 from . import __version__, _core
-from .artifacts import ReportArtifacts
+from .artifacts import ReportArtifacts, ReportIdentity, market_session
 from .config import (
     add_feishu_channel,
     config_path,
@@ -279,7 +279,10 @@ def _run_llm_replay(date_str: str, kind: str = "replay", symbol: str | None = No
         else build_daily_evidence(_core, date_str, profile)
     )
     artifacts = ReportArtifacts(date_str)
-    artifacts.write_json("evidence" if not symbol else f"{symbol}-evidence", evidence.to_dict())
+    session = market_session()
+    topic = f"{symbol}深度分析" if symbol else "A股深度复盘"
+    identity = ReportIdentity(date_str, session, topic)
+    artifacts.write_json(f"{identity.prefix}-evidence", evidence.to_dict())
     config = load_config(strict=False).get("llm", {})
     methodology = sync_stock_analysis_methodology()
     try:
@@ -292,9 +295,11 @@ def _run_llm_replay(date_str: str, kind: str = "replay", symbol: str | None = No
         raise click.ClickException(str(exc)) from exc
     metadata["stock_analysis_version"] = methodology.version
     metadata["stock_analysis_updated"] = methodology.updated
-    name = f"analyze-{symbol}" if symbol else kind
-    path = artifacts.write_markdown(name, markdown)
-    artifacts.write_metadata({"kind": name, **metadata})
+    path = artifacts.write_report_markdown(identity, markdown)
+    artifacts.write_json(
+        f"{identity.prefix}-metadata",
+        {"kind": kind, "session": session, "topic": topic, **metadata},
+    )
     from rich.console import Console
     from rich.markdown import Markdown
 

{young_stock_cli-0.2.2 → young_stock_cli-0.2.3}/src/young_stock/llm.py

@@ -92,6 +92,7 @@ class LLMClient:
     def _post(self, url: str, **kwargs: Any) -> Any:
         timeout = float(self.config.get("timeout") or 60)
         last_error: Exception | None = None
+        provider = str(self.config.get("provider") or "").lower()
         for attempt in range(3):
             try:
                 response = self.session.post(url, timeout=timeout, **kwargs)
@@ -105,7 +106,8 @@ class LLMClient:
                 time.sleep(0.2 * (attempt + 1))
                 continue
             if response.status_code in {401, 403}:
-                raise LLMError("LLM 认证失败，请检查 API key 和 provider 配置。")
+                detail = self._error_detail(response)
+                raise LLMError(self._auth_error_message("LLM", provider, detail))
             if response.status_code >= 400:
                 raise LLMError(f"LLM 请求失败（HTTP {response.status_code}）")
             return response
@@ -113,16 +115,48 @@ class LLMClient:
 
     def _get(self, url: str, **kwargs: Any) -> Any:
         timeout = float(self.config.get("timeout") or 60)
+        provider = str(self.config.get("provider") or "").lower()
         try:
             response = self.session.get(url, timeout=timeout, **kwargs)
         except requests.RequestException as exc:
             raise LLMError(f"模型列表请求失败: {exc.__class__.__name__}") from exc
         if response.status_code in {401, 403}:
-            raise LLMError("模型列表认证失败，请检查 API key、provider 和 api_base。")
+            detail = self._error_detail(response)
+            raise LLMError(self._auth_error_message("模型列表", provider, detail))
         if response.status_code >= 400:
             raise LLMError(f"模型列表请求失败（HTTP {response.status_code}）")
         return response
 
+    def _error_detail(self, response: Any) -> str:
+        try:
+            payload = response.json()
+        except Exception:
+            payload = None
+        if isinstance(payload, dict):
+            error = payload.get("error")
+            if isinstance(error, dict):
+                message = error.get("message") or error.get("type") or error.get("code")
+                if message:
+                    return str(message)
+            message = payload.get("message") or payload.get("detail") or payload.get("error_description")
+            if message:
+                return str(message)
+        text = str(getattr(response, "text", "") or "").strip()
+        return text[:160]
+
+    def _auth_error_message(self, surface: str, provider: str, detail: str) -> str:
+        message = f"{surface}认证失败，请检查 API key、provider 和 api_base。"
+        normalized = detail.strip()
+        if normalized:
+            message = f"{message} 服务端提示：{normalized}"
+        if provider in {"ark", "openai"}:
+            message = (
+                f"{message} 如使用 Ark，建议先运行 "
+                "`young config models --provider ark --api-key-env ARK_API_KEY` "
+                "或用 README 中的 curl 示例核对可用模型 ID。"
+            )
+        return message
+
     def _openai_compatible(
         self,
         api_base: str,

young_stock_cli-0.2.3/src/young_stock/market_routes.py

@@ -0,0 +1,60 @@
+"""Shared market-data routing for reports and terminal dashboards."""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+
+def _rows(result: Any) -> bool:
+    return isinstance(result, dict) and bool(result.get("rows"))
+
+
+def route_board_data(
+    board_type: str,
+    trade_date: str,
+    *,
+    direct: Callable[[str, str, int], dict[str, Any]],
+    camofox: Callable[[str], dict[str, Any]],
+    playwright: Callable[[str], dict[str, Any]],
+    limit: int = 100,
+    current_trade_date: str | None = None,
+) -> dict[str, Any]:
+    result = direct(board_type, trade_date, limit)
+    if _rows(result):
+        return result
+    if current_trade_date and trade_date != current_trade_date:
+        return {"board_type": board_type, "rows": [], "_unavailable": "历史数据不可得"}
+    for browser_source in (camofox, playwright):
+        candidate = browser_source(board_type)
+        if _rows(candidate):
+            return candidate
+    return result or {"board_type": board_type, "rows": [], "_unavailable": "本模块证据暂缺"}
+
+
+def _flow_available(result: Any) -> bool:
+    if not isinstance(result, dict) or result.get("_error") or result.get("_unavailable"):
+        return False
+    return any(
+        key != "date" and not str(key).startswith("_") and value not in (None, "")
+        for key, value in result.items()
+    )
+
+
+def route_fund_flow_data(
+    trade_date: str,
+    *,
+    online_sources: list[Callable[[str], dict[str, Any]]],
+    browser: Callable[[str], dict[str, Any]],
+    cached: Callable[[str], dict[str, Any]],
+) -> dict[str, Any]:
+    for source in online_sources:
+        result = source(trade_date)
+        if _flow_available(result):
+            return result
+    browser_result = browser(trade_date)
+    if _flow_available(browser_result):
+        return browser_result
+    cached_result = cached(trade_date)
+    if _flow_available(cached_result):
+        return cached_result
+    return {"date": trade_date, "_unavailable": "本模块证据暂缺"}

{young_stock_cli-0.2.2 → young_stock_cli-0.2.3}/src/young_stock/pdf.py

@@ -13,7 +13,7 @@ from importlib import resources
 from pathlib import Path
 from typing import Any, Callable
 
-from .artifacts import ReportArtifacts
+from .artifacts import ReportArtifacts, ReportIdentity, market_session
 from .local_store import load_store
 
 
@@ -159,7 +159,8 @@ def export_report_pdf(
             markdown = _capture_daily(core, trade_date, profile)
         else:
             raise ValueError("没有可用报告；请先运行 `young daily` 或提供日报生成器。")
-        markdown_path = artifacts.write_markdown("daily", markdown)
+        identity = ReportIdentity(trade_date, market_session(), "A股投资日报")
+        markdown_path = artifacts.write_report_markdown(identity, markdown)
     markdown = markdown_path.read_text(encoding="utf-8")
     body = markdown_to_html(markdown)
     title_match = re.search(r"^#\s+(.+)$", markdown, flags=re.MULTILINE)
@@ -170,8 +171,9 @@ def export_report_pdf(
         .replace("{{DATE}}", trade_date)
         .replace("{{BODY}}", body)
     )
-    html_path = artifacts.path("report", "html")
+    output_name = markdown_path.stem
+    html_path = artifacts.path(output_name, "html")
     html_path.write_text(document, encoding="utf-8")
-    pdf_path = artifacts.path("report", "pdf")
+    pdf_path = artifacts.path(output_name, "pdf")
     (render or _default_render)(html_path, pdf_path)
     return markdown_path, pdf_path

{young_stock_cli-0.2.2 → young_stock_cli-0.2.3}/src/young_stock/reports.py

@@ -5,6 +5,8 @@ import json
 import re
 from typing import Any
 
+from .research_style import review_research_report, to_research_evidence, to_research_methodology
+
 THEME_KEYWORDS = {
     "科技成长/AI": ("AI", "人工智能", "芯片", "半导体", "算力", "CPO", "光通信", "NVDA", "英伟达", "服务器"),
     "消费品牌": ("白酒", "消费", "茅台", "五粮液", "苹果", "Apple", "品牌"),
@@ -196,15 +198,16 @@ def generate_llm_daily_report(
 ) -> tuple[str, dict[str, Any]]:
     messages = [{"role": "system", "content": LLM_REPORT_SYSTEM_PROMPT}]
     if methodology:
+        research_methodology = to_research_methodology(methodology)
         messages.append(
             {
                 "role": "system",
                 "content": "以下是当前 stock-analysis 研究规范，仅用于报告结构和表达纪律：\n"
-                + methodology,
+                + research_methodology,
             }
         )
     messages.extend((history or [])[-10:])
-    report_context = _research_context(evidence)
+    report_context = to_research_evidence(evidence)
     messages.append(
         {
             "role": "user",
@@ -221,7 +224,7 @@ def generate_llm_daily_report(
         "quality_score": evidence.get("_meta", {}).get("quality_score"),
         "missing_modules": evidence.get("_meta", {}).get("missing_modules", []),
     }
-    return _sanitize_report_markdown(response.content), metadata
+    return review_research_report(response.content, evidence), metadata
 
 
 def _daily_watchlist_items(watchlist: dict[str, list[str]] | None, key: str) -> list[str]:

young_stock_cli-0.2.3/src/young_stock/research_style.py

@@ -0,0 +1,176 @@
+"""Convert internal market evidence into publication-safe research language."""
+
+from __future__ import annotations
+
+import copy
+import re
+from typing import Any
+
+MODULE_TITLES = {
+    "M1": "大盘指数与市场广度",
+    "M2": "板块强弱与资金流",
+    "M3": "赚钱效应与涨停结构",
+    "M4": "下跌风险与炸板结构",
+    "M5": "持仓与市场风格",
+    "M6": "抗跌方向",
+    "STOCK": "个股证据",
+}
+
+FIELD_TITLES = {
+    "a_indices": "A股指数",
+    "hk_indices": "港股指数",
+    "us_indices": "美股指数",
+    "northbound": "北向资金",
+    "breadth": "市场广度",
+    "industry": "行业板块",
+    "concept": "概念板块",
+    "fund_flow": "资金流",
+    "zt_count": "涨停家数",
+    "zt_pool": "涨停明细",
+    "early_limit_up_count": "早盘涨停家数",
+    "dt_count": "跌停家数",
+    "zb_count": "炸板家数",
+    "blowup_ratio": "炸板率",
+    "dt_pool": "跌停明细",
+    "zb_pool": "炸板明细",
+    "holdings": "持仓",
+    "style_signals": "风格观察",
+    "growth_board_count": "科创板与创业板活跃样本数",
+    "resilient": "抗跌方向",
+    "quote": "行情",
+    "block_trades": "大宗交易",
+    "news": "公开信息",
+    "trade_date": "交易日",
+    "quality_score": "证据完整度评分",
+    "missing_modules": "证据暂缺模块",
+    "degrade_mode": "报告范围",
+    "analysis_symbol": "分析标的",
+    "report_type": "报告类型",
+}
+
+FORBIDDEN_PATTERNS = (
+    r"\bmodules\.[A-Za-z0-9_.]+",
+    r"\b(?:available|growth_board_count|degrade_mode|missing_modules)\b",
+    r"\b(?:fallback)\b",
+    r"脚本|采集|推测|不确定性|猜测",
+    r"(?:[A-Za-z]:)?[/~][^\s，。；：)）`]+",
+    r"\b[\w-]+\.(?:py|js|sh)\b",
+    r"\bM[1-6]\s*(?:降级|缺失|不可用)",
+)
+
+
+class ResearchStyleError(RuntimeError):
+    """Report still contains publication-unsafe internal language."""
+
+
+def _public_source(value: Any) -> str:
+    text = str(value or "")
+    labels = []
+    for token, label in (
+        ("腾讯", "腾讯财经"),
+        ("sina", "新浪财经"),
+        ("新浪", "新浪财经"),
+        ("eastmoney", "东方财富"),
+        ("东财", "东方财富"),
+        ("同花顺", "同花顺"),
+        ("ths", "同花顺"),
+        ("futu", "富途公开资讯"),
+        ("富途", "富途公开资讯"),
+    ):
+        if token.lower() in text.lower() and label not in labels:
+            labels.append(label)
+    return "、".join(labels) if labels else "公开市场数据"
+
+
+def _convert(value: Any) -> Any:
+    if isinstance(value, list):
+        return [_convert(item) for item in value]
+    if not isinstance(value, dict):
+        return value
+    result = {}
+    for key, item in value.items():
+        if key == "available":
+            result["证据状态"] = "据公开市场数据" if item else "本模块证据暂缺"
+        elif key in {"source", "_source"}:
+            result["数据来源"] = _public_source(item)
+        elif key in {"_date_note", "_cache_note"}:
+            result["日期说明"] = "历史口径回溯"
+        elif key == "missing_modules":
+            result["证据暂缺模块"] = [MODULE_TITLES.get(name, name) for name in item]
+        elif key == "degrade_mode":
+            result["报告范围"] = {
+                "full": "完整报告",
+                "degraded": "证据受限报告",
+                "simplified": "简化报告",
+            }.get(str(item), str(item))
+        elif key.startswith("_"):
+            continue
+        else:
+            result[FIELD_TITLES.get(key, key)] = _convert(item)
+    return result
+
+
+def to_research_evidence(evidence: dict[str, Any]) -> dict[str, Any]:
+    """Return a publication-oriented copy without exposing internal field names."""
+    source = copy.deepcopy(evidence)
+    return {
+        "研报证据": {
+            MODULE_TITLES.get(name, name): _convert(payload)
+            for name, payload in (source.get("modules") or {}).items()
+        },
+        "报告信息": _convert(source.get("_meta") or {}),
+    }
+
+
+def to_research_methodology(text: str) -> str:
+    """Keep report structure and investment discipline, remove implementation guidance."""
+    safe_lines = []
+    in_code_block = False
+    for line in text.splitlines():
+        if line.strip().startswith("```"):
+            in_code_block = not in_code_block
+            continue
+        if in_code_block or _unsafe(line):
+            continue
+        if re.search(r"\b(?:API|HTTP|Session|Camofox|Playwright|JSON|evidence)\b", line, re.IGNORECASE):
+            continue
+        safe_lines.append(line)
+    return "\n".join(safe_lines).strip()
+
+
+def _replacement_lines(evidence: dict[str, Any]) -> list[str]:
+    modules = evidence.get("modules") or {}
+    lines = []
+    if not (modules.get("M2") or {}).get("available"):
+        lines.append("- 本模块证据暂缺。")
+    growth = ((modules.get("M5") or {}).get("style_signals") or {}).get("growth_board_count")
+    if isinstance(growth, (int, float)):
+        lines.append(f"- 据公开市场数据，科创板与创业板活跃样本数为 {growth:g} 家。")
+    lines.append("- 据公开市场数据，相关指标以已披露口径为准。")
+    return lines
+
+
+def _unsafe(line: str) -> bool:
+    return any(re.search(pattern, line, flags=re.IGNORECASE) for pattern in FORBIDDEN_PATTERNS)
+
+
+def review_research_report(markdown: str, evidence: dict[str, Any]) -> str:
+    """Remove unsafe sentences, add evidence-backed research wording, and validate."""
+    internal_fields = re.findall(r"\bmodules\.([A-Za-z0-9_]+)\.([A-Za-z0-9_.]+)", markdown)
+    known_modules = set((evidence.get("modules") or {}).keys())
+    if any(module not in known_modules for module, _field in internal_fields):
+        raise ResearchStyleError("正式研报包含无法转换的内部字段。")
+    safe_lines = []
+    removed = False
+    for line in markdown.splitlines():
+        if _unsafe(line):
+            removed = True
+            continue
+        safe_lines.append(line)
+    if removed:
+        insert_at = 1 if safe_lines and safe_lines[0].startswith("#") else 0
+        safe_lines[insert_at:insert_at] = ["", *_replacement_lines(evidence), ""]
+    reviewed = "\n".join(safe_lines).strip()
+    if _unsafe(reviewed):
+        raise ResearchStyleError("正式研报未通过研究语言审校。")
+    return reviewed