davidzhengdai
diff --git a/‎.env.example‎
Lines changed: 7 additions & 0 deletions b/‎.env.example‎
Lines changed: 7 additions & 0 deletions
diff --git a/‎docs/design-model-benchmark.html‎
Lines changed: 34 additions & 1 deletion b/‎docs/design-model-benchmark.html‎
Lines changed: 34 additions & 1 deletion
diff --git a/‎main.py‎
Lines changed: 28 additions & 0 deletions b/‎main.py‎
Lines changed: 28 additions & 0 deletions
diff --git a/‎src/config.py‎
Lines changed: 8 additions & 0 deletions b/‎src/config.py‎
Lines changed: 8 additions & 0 deletions
diff --git a/‎src/core/pipeline.py‎
Lines changed: 31 additions & 0 deletions b/‎src/core/pipeline.py‎
Lines changed: 31 additions & 0 deletions
diff --git a/‎src/services/model_benchmark.py‎
Lines changed: 157 additions & 0 deletions b/‎src/services/model_benchmark.py‎
Lines changed: 157 additions & 0 deletions
@@ -569,6 +569,13 @@ BACKTEST_ENGINE_VERSION=v1
 # 中性区间阈值（%），例如 2 表示 -2%~+2% 视为震荡
 BACKTEST_NEUTRAL_BAND_PCT=2.0
 
+# === 模型基准测试自动标注 ===
+# 是否在每次分析时自动标注 model_id + 性能数据到 context_snapshot（true/false）
+# 开启后，回测评估可自动产出跨模型对比报告，无需手动运行 benchmark CLI
+BENCHMARK_AUTO_TAG=true
+# 是否在回测完成后自动生成跨模型对比报告（true/false）
+BENCHMARK_AUTO_REPORT=true
+
 # === 定时任务配置 ===
 # 是否启用定时任务（true/false）
 SCHEDULE_ENABLED=false
 
@@ -163,7 +163,7 @@ <h1>Design: Model Benchmark</h1>
   <dt>Status</dt><dd>Implemented</dd>
   <dt>Module</dt><dd><code>src/services/model_benchmark.py</code></dd>
   <dt>Date</dt><dd>2026-05-11</dd>
-  <dt>Dependencies</dt><dd><code>BacktestEngine</code>, <code>BacktestService</code>, <code>AnalysisHistory</code>, <code>AgentFactory</code></dd>
+  <dt>Dependencies</dt><dd><code>BacktestEngine</code>, <code>BacktestService</code>, <code>AnalysisHistory</code>, <code>AgentFactory</code>, <code>BenchmarkTagger</code></dd>
   <dt>CLI Entry</dt><dd><code>python -m src.services.model_benchmark [--analyze|--evaluate|--report|--full] [--parallel] [--debug] [--max-parallel N]</code></dd>
 </dl>
 
@@ -366,6 +366,39 @@ <h3>All-in-One</h3>
 <pre><code>python -m src.services.model_benchmark --full --stocks AAPL,TSLA</code></pre>
 <p>Runs all three phases sequentially. Useful for immediate testing when eval window is 0 (same-day analysis + evaluation).</p>
 
+<h3>Phase 0: Passive Benchmarking (Zero-Click Background Collection)</h3>
+
+<div class="callout callout-tip">
+<div class="callout-title">核心设计理念：零操作、全自动</div>
+<p>用户<strong>无需</strong>显式调用 benchmark CLI。每次通过 <code>main.py</code> 正常分析股票时，系统自动在 <code>context_snapshot</code> 中标注当前使用的模型 ID 和性能数据（延迟 / Token / 成本估算），回测评估后自动产出跨模型对比报告。</p>
+</div>
+
+<p><strong>工作原理：</strong></p>
+<ol>
+  <li><strong>自动标注（BenchmarkTagger）</strong>：在 <code>StockAnalysisPipeline</code> 的每次分析执行前后，自动捕获 LLM 调用耗时（<code>time.perf_counter()</code>）、Token 用量（从 <code>AgentResult.stats</code> 提取）、模型 ID（从 <code>Config.litellm_model</code> 或 <code>AgentResult.model</code> 读取），写入 <code>context_snapshot.benchmark_meta</code></li>
+  <li><strong>被动积累</strong>：用户在日常使用中切换不同模型（今天用 Claude、明天用 Gemini），每条分析记录自动标注对应模型。日积月累，自然形成多模型对比数据集</li>
+  <li><strong>自动报告</strong>：回测完成后，若 <code>BENCHMARK_AUTO_REPORT=true</code>，自动调用 <code>ModelBenchmarkService.generate_report()</code>，JOIN 查询所有带 <code>"benchmark": true</code> 标记的回测结果，产出模型排名报告并保存到 <code>reports/benchmark_*.txt</code></li>
+</ol>
+
+<p><strong>配置项（.env）：</strong></p>
+<pre><code># 是否自动为每次分析标注模型+性能数据（默认 true）
+BENCHMARK_AUTO_TAG=true
+# 是否在回测完成后自动生成跨模型对比报告（默认 true）
+BENCHMARK_AUTO_REPORT=true</code></pre>
+
+<p><strong>Agent 与非 Agent 路径均覆盖：</strong></p>
+<ul>
+  <li><strong>非 Agent 路径</strong>（<code>analyzer.analyze()</code>）：标注 LLM 耗时；Token 数据通常不可用（传统路径不暴露 usage），<code>benchmark_meta.total_tokens=0</code></li>
+  <li><strong>Agent 路径</strong>（<code>executor.run()</code>）：标注 LLM 耗时 + 完整 Token 数据 + 成本估算，性能对比数据最完整</li>
+</ul>
+
+<p><strong>与显式 benchmark CLI 的关系：</strong></p>
+<ul>
+  <li>显式 benchmark CLI（<code>python -m src.services.model_benchmark --analyze ...</code>）仍然保留，用于<strong>主动</strong>对比多个模型（在单次运行中同时调用多个模型分析同一只股票）</li>
+  <li>被动标注（<code>BenchmarkTagger</code>）是<strong>互补</strong>机制，在日常使用中零成本收集数据，无需额外操作</li>
+  <li>两种路径产出的 <code>context_snapshot</code> 格式完全一致，共用同一套 <code>generate_report()</code> 查询逻辑</li>
+</ul>
+
 <!-- ═══════════════════════════════════════════════════════════════ -->
 <h2 id="data-model">5. Data Model &amp; Storage</h2>
 
 
@@ -742,6 +742,34 @@ def run_full_analysis(
                     f"自动回测完成: processed={stats.get('processed')} saved={stats.get('saved')} "
                     f"completed={stats.get('completed')} insufficient={stats.get('insufficient')} errors={stats.get('errors')}"
                 )
+
+                # === Auto benchmark report: 回测后自动产出跨模型对比 ===
+                if getattr(config, 'benchmark_auto_report', True):
+                    try:
+                        from src.services.model_benchmark import ModelBenchmarkService, format_benchmark_report
+
+                        logger.info("正在生成自动模型基准测试报告...")
+                        bench_svc = ModelBenchmarkService()
+                        bench_report = bench_svc.generate_report(
+                            eval_window_days=getattr(config, 'backtest_eval_window_days', 10),
+                        )
+                        if bench_report.models:
+                            bench_text = format_benchmark_report(bench_report)
+                            logger.info("自动模型基准测试报告:\n%s", bench_text)
+                            # 可选：保存到 reports/ 目录
+                            try:
+                                from pathlib import Path
+                                reports_dir = Path("reports")
+                                reports_dir.mkdir(exist_ok=True)
+                                report_path = reports_dir / f"benchmark_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
+                                report_path.write_text(bench_text, encoding="utf-8")
+                                logger.info("模型基准测试报告已保存: %s", report_path)
+                            except Exception as _save_exc:
+                                logger.debug("保存 benchmark 报告失败: %s", _save_exc)
+                        else:
+                            logger.info("暂无 benchmark 标注数据，跳过自动模型基准测试报告")
+                    except Exception as _benchmark_exc:
+                        logger.warning("自动模型基准测试报告生成失败（已忽略）: %s", _benchmark_exc)
         except Exception as e:
             logger.warning(f"自动回测失败（已忽略）: {e}")
 
 
@@ -833,6 +833,12 @@ class Config:
     backtest_min_age_days: int = 14
     backtest_engine_version: str = "v1"
     backtest_neutral_band_pct: float = 2.0
+
+    # === 模型基准测试自动标注 ===
+    # 开启后，每次分析自动在 context_snapshot 中标注 model_id + 性能数据（延迟/Token/成本），
+    # 使得回测评估后可以自动产出跨模型对比报告，无需手动运行 benchmark CLI。
+    benchmark_auto_tag: bool = True
+    benchmark_auto_report: bool = True
 
     # === 日志配置 ===
     log_dir: str = "./logs"  # 日志文件目录
@@ -1597,6 +1603,8 @@ def _load_from_env(cls) -> 'Config':
             backtest_eval_window_days=parse_env_int(os.getenv('BACKTEST_EVAL_WINDOW_DAYS'), 10, field_name='BACKTEST_EVAL_WINDOW_DAYS', minimum=1),
             backtest_min_age_days=parse_env_int(os.getenv('BACKTEST_MIN_AGE_DAYS'), 14, field_name='BACKTEST_MIN_AGE_DAYS', minimum=1),
             backtest_engine_version=os.getenv('BACKTEST_ENGINE_VERSION', 'v1'),
+            benchmark_auto_tag=os.getenv('BENCHMARK_AUTO_TAG', 'true').lower() == 'true',
+            benchmark_auto_report=os.getenv('BENCHMARK_AUTO_REPORT', 'true').lower() == 'true',
             backtest_neutral_band_pct=parse_env_float(
                 os.getenv('BACKTEST_NEUTRAL_BAND_PCT'),
                 2.0,
 
@@ -491,12 +491,14 @@ def _on_llm_stream(chars_received: int) -> None:
                 )
 
             self._emit_progress(64, f"{stock_name}：正在请求 LLM 生成报告")
+            _benchmark_t0 = time.perf_counter()
             result = self.analyzer.analyze(
                 enhanced_context,
                 news_context=news_context,
                 progress_callback=self._emit_progress,
                 stream_progress_callback=_on_llm_stream,
             )
+            _benchmark_latency_ms = (time.perf_counter() - _benchmark_t0) * 1000
 
             # Step 7.5a: 技术评分兜底 — LLM 未输出评分时使用 trend_result.signal_score
             if result and result.sentiment_score == 50 and trend_result is not None:
@@ -543,6 +545,17 @@ def _on_llm_stream(chars_received: int) -> None:
                         realtime_quote=realtime_quote,
                         chip_data=chip_data
                     )
+                    # === Benchmark auto-tag: 每次分析自动标注模型+性能数据 ===
+                    if getattr(self.config, 'benchmark_auto_tag', True):
+                        try:
+                            from src.services.model_benchmark import BenchmarkTagger
+                            context_snapshot = BenchmarkTagger.enrich_context_snapshot(
+                                existing_snapshot=context_snapshot,
+                                model_id=BenchmarkTagger.get_current_model_id(self.config),
+                                latency_ms=_benchmark_latency_ms,
+                            )
+                        except Exception as _benchmark_exc:
+                            logger.debug("Benchmark auto-tag skipped: %s", _benchmark_exc)
                     self.db.save_analysis_history(
                         result=result,
                         query_id=query_id,
@@ -897,7 +910,9 @@ def _analyze_with_agent(
                 message = f"Analyze stock {code} ({stock_name}) and return the full decision dashboard JSON in English."
             else:
                 message = f"请分析股票 {code} ({stock_name})，并生成决策仪表盘报告。"
+            _benchmark_t0 = time.perf_counter()
             agent_result = executor.run(message, context=initial_context)
+            _benchmark_latency_ms = (time.perf_counter() - _benchmark_t0) * 1000
 
             # 转换为 AnalysisResult
             result = self._agent_result_to_analysis_result(
@@ -963,6 +978,22 @@ def _analyze_with_agent(
             if result and result.success:
                 try:
                     initial_context["stock_name"] = resolved_stock_name
+                    # === Benchmark auto-tag: Agent 路径自动标注模型+性能数据 ===
+                    if getattr(self.config, 'benchmark_auto_tag', True):
+                        try:
+                            from src.services.model_benchmark import BenchmarkTagger
+                            model_id = (
+                                agent_result.model
+                                or BenchmarkTagger.get_current_model_id(self.config)
+                            )
+                            initial_context = BenchmarkTagger.enrich_context_snapshot(
+                                existing_snapshot=initial_context,
+                                model_id=model_id,
+                                latency_ms=_benchmark_latency_ms,
+                                agent_result=agent_result,
+                            )
+                        except Exception as _benchmark_exc:
+                            logger.debug("Benchmark auto-tag skipped (agent): %s", _benchmark_exc)
                     self.db.save_analysis_history(
                         result=result,
                         query_id=query_id,
 
@@ -1042,6 +1042,163 @@ def _extract_model_info(snapshot_json: Optional[str]) -> Tuple[Optional[str], Op
         return None, None
 
 
+# ---------------------------------------------------------------------------
+# BenchmarkTagger — passive / auto-tag every analysis for background scoring
+# ---------------------------------------------------------------------------
+
+class BenchmarkTagger:
+    """
+    被动评分标注器：在正常使用 main.py 运行分析时，自动为每一条分析结果标注
+    model_id + 性能元数据（延迟 / Token / 成本估算），使得后续回测评估后可以
+    自动产出跨模型对比报告，无需手动运行 benchmark CLI。
+
+    === 使用方式（由 pipeline 自动调用，用户无需操作） ===
+
+      from src.services.model_benchmark import BenchmarkTagger
+
+      # 在每次分析执行前后：
+      t0 = time.perf_counter()
+      result = run_analysis(...)
+      latency_ms = (time.perf_counter() - t0) * 1000
+
+      # 为 context_snapshot 注入 benchmark 标签：
+      enriched = BenchmarkTagger.enrich_context_snapshot(
+          existing_snapshot=original_context_snapshot,
+          model_id=config.litellm_model,
+          latency_ms=latency_ms,
+          agent_result=agent_result,   # Agent 路径传入，非 Agent 路径为 None
+      )
+
+      db.save_analysis_history(..., context_snapshot=enriched, ...)
+
+    === 存储格式（context_snapshot 内） ===
+
+      {
+          ...原有字段...,
+          "model_id": "anthropic/claude-sonnet-4-6",
+          "benchmark": true,
+          "benchmark_meta": {
+              "latency_ms": 3421.5,
+              "total_tokens": 8500,
+              "prompt_tokens": 5100,
+              "completion_tokens": 3400,
+              "estimated_cost_usd": 0.0663
+          }
+      }
+
+    只有含有 "benchmark": true 标记的分析记录，才会被 generate_report()
+    JOIN 查询纳入跨模型对比。
+    """
+
+    @staticmethod
+    def get_current_model_id(config) -> str:
+        """
+        获取当前正在使用的模型 ID。
+
+        优先级：
+        1. Agent 模式下的 AGENT_LITELLM_MODEL（显式配置）
+        2. Agent 模式下的 LITELLM_MODEL（fallback 继承）
+        3. 非 Agent 模式下的 LITELLM_MODEL
+        4. 环境变量 LITELLM_MODEL 兜底
+        """
+        # Check agent-specific model first
+        if getattr(config, 'agent_mode', False) or getattr(config, 'agent_skills', None):
+            agent_model = getattr(config, 'agent_litellm_model', '') or ''
+            if agent_model:
+                return agent_model
+        # Fall back to primary litellm model
+        primary = getattr(config, 'litellm_model', '') or ''
+        if primary:
+            return primary
+        # Last resort: env var
+        return os.environ.get('LITELLM_MODEL', 'unknown')
+
+    @staticmethod
+    def enrich_context_snapshot(
+        existing_snapshot: Optional[Dict[str, Any]],
+        model_id: str,
+        latency_ms: float,
+        agent_result: Any = None,
+    ) -> Dict[str, Any]:
+        """
+        为 context_snapshot 注入 benchmark 标注字段。
+
+        Args:
+            existing_snapshot: 原始 context_snapshot dict（可能为 None）
+            model_id: 当前使用的模型 ID（如 "anthropic/claude-sonnet-4-6"）
+            latency_ms: 分析耗时（毫秒）
+            agent_result: AgentResult 对象（Agent 路径传入，用于提取 Token 用量）
+
+        Returns:
+            注入 benchmark 字段后的新 dict（不修改原对象）
+        """
+        snapshot = dict(existing_snapshot) if existing_snapshot else {}
+
+        # 如果已有 benchmark 标记（例如 benchmark CLI 手动调用），保留不覆盖
+        # 但兼容日常路径未打标的情况
+        if snapshot.get("benchmark") and snapshot.get("model_id"):
+            # Already tagged, update perf meta only if missing
+            if not snapshot.get("benchmark_meta"):
+                snapshot["benchmark_meta"] = BenchmarkTagger._build_benchmark_meta(
+                    latency_ms, agent_result
+                )
+            return snapshot
+
+        # Extract token usage from AgentResult (agent path)
+        prompt_tokens = 0
+        completion_tokens = 0
+        total_tokens = 0
+        if agent_result is not None:
+            total_tokens = getattr(agent_result, 'total_tokens', 0) or 0
+            stats = getattr(agent_result, 'stats', None)
+            if stats:
+                prompt_tokens = getattr(stats, 'total_prompt_tokens', 0) or 0
+                completion_tokens = getattr(stats, 'total_completion_tokens', 0) or 0
+            # 如果没有细分数据但有总量，估算 6:4 拆分
+            if not prompt_tokens and not completion_tokens and total_tokens:
+                prompt_tokens = int(total_tokens * 0.6)
+                completion_tokens = total_tokens - prompt_tokens
+
+        cost = estimate_cost(model_id, prompt_tokens, completion_tokens)
+
+        snapshot["model_id"] = model_id
+        snapshot["benchmark"] = True
+        snapshot["benchmark_meta"] = {
+            "latency_ms": round(latency_ms, 1),
+            "total_tokens": total_tokens,
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "estimated_cost_usd": cost,
+        }
+        return snapshot
+
+    @staticmethod
+    def _build_benchmark_meta(
+        latency_ms: float,
+        agent_result: Any = None,
+    ) -> Dict[str, Any]:
+        """构建 benchmark_meta 子字典（内部复用）。"""
+        total_tokens = 0
+        prompt_tokens = 0
+        completion_tokens = 0
+        if agent_result is not None:
+            total_tokens = getattr(agent_result, 'total_tokens', 0) or 0
+            stats = getattr(agent_result, 'stats', None)
+            if stats:
+                prompt_tokens = getattr(stats, 'total_prompt_tokens', 0) or 0
+                completion_tokens = getattr(stats, 'total_completion_tokens', 0) or 0
+            if not prompt_tokens and not completion_tokens and total_tokens:
+                prompt_tokens = int(total_tokens * 0.6)
+                completion_tokens = total_tokens - prompt_tokens
+        return {
+            "latency_ms": round(latency_ms, 1),
+            "total_tokens": total_tokens,
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "estimated_cost_usd": 0.0,  # model_id unknown at this point
+        }
+
+
 # ---------------------------------------------------------------------------
 # Report formatting (updated with performance section)
 # ---------------------------------------------------------------------------