Merge branch 'main' into frontend-beautify

- 色板收敛为纸白/暖墨/印报红三色,移除默认 Tailwind 蓝
- 队名彩色哈希块、shimmer/ping/fade-up 动效、圆角卡片阵全部移除
- 报头改为双线+居中宋体刊名+报眉日期行
- 赛程列表表格化:细线分行,联赛改为文字版面切换
- 预测版:方正墨线框,大号宋体比分,胜平负改文字行,专家意见改汉字编号折叠行,终裁改红竖线引文
- 修复:桌面状态列 sm:contents 错位;移动端对阵未同行

.env.example

@@ -10,6 +10,11 @@ LLM_PROVIDER=openai
 LLM_API_KEY=sk-xxxx
 LLM_BASE_URL=https://api.openai.com/v1
 LLM_MODEL=gpt-4o
+# 多 Agent 分档模型(留空则回落 LLM_MODEL)
+LLM_SPECIALIST_MODEL=
+LLM_AGGREGATOR_MODEL=
+# 单次 LLM 调用超时(秒)
+LLM_TIMEOUT=60
 
 # ---- 数据源 ----
 BZZOIRO_KEY=
@@ -17,3 +22,8 @@ API_FOOTBALL_KEY=
 
 # ---- CORS ----
 CORS_ORIGINS=http://localhost:5173,http://localhost:3000
+
+# ---- 管理接口鉴权 ----
+# 采集/回测/回填接口的访问密钥(请求头 X-API-Key)。
+# 留空 = 不启用鉴权(本地开发默认);生产环境必须设置强随机值。
+ADMIN_API_KEY=

.gitignore

@@ -5,3 +5,12 @@ __pycache__/
 .pytest_cache/
 frontend/node_modules/
 frontend/dist/
+
+# AI 助手上下文文件(不入库)
+CLAUDE.md
+docs/AGENTS.md
+docs/agents/
+
+# 本地审查/预览脚手架(不入库)
+.tools/
+.preview/

CLAUDE.md

@@ -1,43 +0,0 @@
-# Profeto — 先知
-
-足球 LLM 预测服务。
-
-## 多 Agent 协同
-
-本项目采用 4 Agent 协同模式。详见 `docs/AGENTS.md`。
-
-| Agent | 所有权 | 上下文文件 |
-|---|---|---|
-| 🗄️ DBA (数据库) | `src/db/`, `alembic/`, 数据模型 | `docs/agents/dba.md` |
-| 🖥️ FE (前端) | `frontend/` | `docs/agents/fe.md` |
-| ⚙️ BE (后端) | `src/api/`, `src/core/`, `src/llm/`, `src/data/` | `docs/agents/be.md` |
-| 🚀 Ops (部署) | `Dockerfile`, `docker-compose.yml`, 配置 | `docs/agents/ops.md` |
-
-## 技术栈
-
-- **后端**: Python 3.11+, FastAPI, SQLAlchemy async, PostgreSQL
-- **前端**: React, TypeScript, Vite, Tailwind CSS
-- **LLM**: OpenAI-compatible (OpenAI / Deepseek / Ollama)
-- **数据源**: bzzoiro, understat, api-football
-
-## 常用命令
-
-```bash
-# 后端
-uvicorn src.api.app:app --reload        # 启动 API
-pytest                                   # 测试
-alembic upgrade head                     # 数据库迁移
-
-# 前端
-cd frontend && npm run dev               # 开发
-cd frontend && npm run build             # 构建
-
-# 部署
-docker compose up -d                     # 启动全部服务
-```
-
-## 协作原则
-
-- 每个 Agent 在自己的所有权范围内工作
-- 跨 Agent 变更通过接口契约协调（REST API / ORM 模型 / docker-compose）
-- 修改接口前通知相关 Agent

README.md

@@ -15,12 +15,13 @@
 │  ├── /api/v1/matches     比赛查询                   │
 │  ├── /api/v1/predict     LLM 预测 (单/多 Agent)     │
 │  ├── /api/v1/ingest/*    数据采集                   │
-│  └── /api/v1/eval/*      评估回填                   │
+│  ├── /api/v1/eval/*      评估回填                   │
+│  └── /api/v1/backtest    回测                       │
 └──────────┬─────────────────────────────┬────────────┘
            │                             │
 ┌──────────▼──────────┐    ┌─────────────▼────────────┐
 │  PostgreSQL         │    │  LLM (OpenAI-compatible)  │
-│  5 张表             │    │  OpenAI / Deepseek /      │
+│  6 张表             │    │  OpenAI / Deepseek /      │
 │  leagues/teams/     │    │  Ollama / 任意网关        │
 │  matches/match_     │    └──────────────────────────┘
 │  stats/predictions/ │
@@ -36,6 +37,16 @@
 └────────────────────────────────────────────────────┘
 ```
 
+### 分层架构
+
+```
+API Route → Application Service → Repository → UnitOfWork → DB
+```
+
+- **UnitOfWork**: 统一事务边界,业务层不再自行 commit
+- **Repository**: 封装数据访问,提供类型化查询接口
+- **DataSource**: 采集外部数据,通过注册表动态分发
+
 ### 多 Agent 预测
 
 默认模式 (`mode=multi`) 采用 **5 专家 + 终裁** 架构:
@@ -51,7 +62,14 @@
 - 各专家**只看到自己维度的数据切片**,避免信息过载
 - **fail-open**: 单个专家失败不影响整体
 - **no_data 门控**: 无数据维度跳过 LLM 调用,省 token 防幻觉
-- 终裁根据各报告的 `confidence` / `data_sufficiency` 加权输出 `agent_weights`
+- 终裁根据各报告的 `subjective_confidence` / `data_sufficiency` 输出 `agent_weights`
+
+### 数据正确性保障
+
+- **Cutoff 机制**: 回测时只使用 `cutoff_at` 之前已采集的数据
+- **Injury 防泄漏**: 伤停查询强制 `retrieved_at <= cutoff`
+- **LLM 输出校验**: Pydantic 严格校验 + 语义一致性检查
+- **数据库约束**: CHECK 约束作为最后一道防线
 
 ## 快速开始
 
@@ -64,7 +82,6 @@
 ### 1. 安装
 
 ```bash
-# 克隆
 git clone https://git.bilidili.cn/shangfangjian/Profeto.git
 cd Profeto
 
@@ -80,6 +97,7 @@ cp .env.example .env
 
 ```bash
 docker compose up -d postgres
+alembic upgrade head  # 首次运行需要执行迁移
 ```
 
 ### 3. 启动服务
@@ -94,58 +112,22 @@ cd frontend && npm install && npm run dev
 
 后端运行在 `http://localhost:8000`,前端在 `http://localhost:5173`。
 
-## 使用流程
+## API 概览
 
-### 1. 采集数据
-
-```bash
-# 采集 bzzoiro 比分与统计
-curl -X POST http://localhost:8000/api/v1/ingest/bzzoiro \
-  -H "Content-Type: application/json" \
-  -d '{"leagues":["E0","SP1"],"date_from":"2026-08-01","date_to":"2026-09-06"}'
-
-# 回填 understat xG
-curl -X POST http://localhost:8000/api/v1/ingest/understat \
-  -H "Content-Type: application/json" \
-  -d '{"league":"E0","season":2026}'
-
-# 采集伤停
-curl -X POST http://localhost:8000/api/v1/ingest/injuries \
-  -H "Content-Type: application/json" \
-  -d '{"date":"2026-09-09"}'
-```
-
-### 2. 查询比赛
-
-```bash
-curl "http://localhost:8000/api/v1/matches?league=E0&status=scheduled"
-```
-
-### 3. LLM 预测
-
-```bash
-# 多 Agent 预测 (默认)
-curl -X POST http://localhost:8000/api/v1/predict \
-  -H "Content-Type: application/json" \
-  -d '{"match_id": 1}'
-
-# 单次调用模式
-curl -X POST http://localhost:8000/api/v1/predict \
-  -H "Content-Type: application/json" \
-  -d '{"match_id": 1, "mode": "single"}'
-```
-
-### 4. 评估
-
-```bash
-# 赛后回填实际比分
-curl -X POST http://localhost:8000/api/v1/eval/settle \
-  -H "Content-Type: application/json" \
-  -d '{"prediction_id": 1, "home_goals": 2, "away_goals": 1}'
-
-# 查看准确率汇总
-curl http://localhost:8000/api/v1/eval/summary
-```
+| 方法 | 路径 | 说明 |
+|---|---|---|
+| GET | `/api/v1/matches` | 比赛查询(筛选/分页) |
+| GET | `/api/v1/leagues` | 联赛列表 |
+| POST | `/api/v1/predict` | LLM 预测 (`mode=single`/`multi`) |
+| GET | `/api/v1/predictions` | 预测历史 |
+| POST | `/api/v1/ingest/bzzoiro` | 采集比分/统计 |
+| POST | `/api/v1/ingest/understat` | 回填 xG |
+| POST | `/api/v1/ingest/injuries` | 采集伤停 |
+| POST | `/api/v1/eval/settle` | 回填实际结果 |
+| GET | `/api/v1/eval/summary` | 准确率汇总 |
+| POST | `/api/v1/backtest` | 历史回测 |
+| GET | `/health` | 存活检查 |
+| GET | `/health/ready` | 就绪检查(含 DB) |
 
 ## 项目结构
 
@@ -159,34 +141,36 @@ Profeto/
 │   │       ├── matches.py      # 比赛查询
 │   │       ├── predict.py      # 预测入口
 │   │       ├── ingest.py       # 数据采集
-│   │       └── eval.py         # 评估回填
+│   │       ├── eval.py         # 评估回填
+│   │       └── backtest.py     # 回测
 │   ├── core/                   # 基础设施
 │   │   ├── config.py           # pydantic-settings 配置
-│   │   └── http_client.py      # 共享 httpx 客户端
+│   │   ├── http_client.py      # 共享 httpx 客户端
+│   │   └── retry.py            # 重试工具(指数退避)
 │   ├── data/                   # 数据层
 │   │   ├── sources.py          # DataSource 协议 + 注册表
-│   │   ├── match_lookup.py     # 比赛匹配辅助函数
 │   │   ├── normalize.py        # 数据规范化契约
 │   │   ├── bzzoiro.py          # bzzoiro 数据源
 │   │   ├── understat.py        # understat xG 数据源
-│   │   ├── injuries.py         # 伤停数据 (独立领域)
+│   │   ├── injuries.py         # 伤停数据
 │   │   ├── config.py           # 联赛映射常量
 │   │   └── team_names.py       # 队名归一化
 │   ├── db/                     # 数据库
 │   │   ├── base.py             # SQLAlchemy async engine
-│   │   └── models.py           # ORM 模型 (5 表)
+│   │   ├── models.py           # ORM 模型 (6 表)
+│   │   ├── unit_of_work.py     # UnitOfWork 事务封装
+│   │   └── repositories.py     # Repository 数据访问
 │   └── llm/                    # LLM 预测核心
 │       ├── predict.py          # 预测服务 (缓存 + 单/多模式)
 │       ├── context_builder.py  # 数据切片 + 上下文拼接
 │       ├── eval.py             # 评估统计
+│       ├── backtest.py         # 回测框架
 │       ├── provider.py         # 多提供商 LLM 抽象
+│       ├── validation.py       # LLM 输出校验
 │       ├── agents/
 │       │   ├── base.py         # Agent 基础设施 + 解析
 │       │   └── orchestrator.py # 多 Agent 编排
 │       └── prompts/            # Prompt 模板
-│           ├── match_prediction_v1.md
-│           ├── match_prediction_v2.md
-│           └── agents/         # 各专家 prompt
 ├── alembic/                    # 数据库迁移
 ├── frontend/                   # React 前端
 ├── docs/                       # 详细文档
@@ -204,8 +188,10 @@ Profeto/
 | `prompts/` | Prompt 模板 (迭代最频繁) |
 | `provider.py` | OpenAI-compatible 多提供商抽象 |
 | `sources.py` | 数据源协议 + 注册表 |
-| `normalize.py` | 数据清洗契约 (校验/范围/归一) |
-| `orchestrator.py` | 多 Agent 编排 (并行专家 + 终裁) |
+| `unit_of_work.py` | 统一事务边界 |
+| `repositories.py` | 数据访问封装 |
+| `validation.py` | LLM 输出严格校验 |
+| `backtest.py` | 回测框架(防未来数据泄漏) |
 
 ## 配置
 
@@ -232,8 +218,6 @@ pytest
 
 ## 数据库迁移
 
-生产环境建议使用 Alembic:
-
 ```bash
 alembic upgrade head
 ```

alembic/versions/0004_snapshot_and_constraints.py

@@ -0,0 +1,64 @@
+"""add snapshot fields and check constraints
+
+Revision ID: 0004_snapshot_and_constraints
+Revises: 0003_injuries
+Create Date: 2026-09-15
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision: str = '0004_snapshot_and_constraints'
+down_revision: Union[str, None] = '0003_injuries'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # 1. 重命名 confidence → subjective_confidence
+    op.alter_column('predictions', 'confidence', new_column_name='subjective_confidence')
+
+    # 2. 新增快照字段
+    op.add_column('predictions', sa.Column('cutoff_at', sa.DateTime(timezone=True), nullable=True))
+    op.add_column('predictions', sa.Column('input_hash', sa.String(length=64), nullable=True))
+
+    # 3. 新增 CHECK 约束
+    #    注意: 对已有数据行加 CHECK 约束时,若存在越界数据 ALTER TABLE 会中途失败,
+    #    导致迁移卡在半完成状态。这里先做一次性清洗(把越界值收敛到合法域),
+    #    再建约束,保证在非空库上也能成功。
+    op.execute("UPDATE predictions SET pred_home_goals = 0 WHERE pred_home_goals IS NOT NULL AND pred_home_goals < 0")
+    op.execute("UPDATE predictions SET pred_away_goals = 0 WHERE pred_away_goals IS NOT NULL AND pred_away_goals < 0")
+    op.execute(
+        "UPDATE predictions SET subjective_confidence = "
+        "CASE WHEN subjective_confidence < 0 THEN 0 "
+        "     WHEN subjective_confidence > 1 THEN 1 ELSE subjective_confidence END "
+        "WHERE subjective_confidence IS NOT NULL "
+        "  AND (subjective_confidence < 0 OR subjective_confidence > 1)"
+    )
+    op.execute("UPDATE predictions SET pred_1x2 = NULL WHERE pred_1x2 IS NOT NULL AND pred_1x2 NOT IN ('1', 'X', '2')")
+    op.execute("UPDATE predictions SET mode = 'single' WHERE mode IS NOT NULL AND mode NOT IN ('single', 'multi')")
+
+    op.create_check_constraint('ck_pred_home_goals_nonneg', 'predictions', 'pred_home_goals >= 0')
+    op.create_check_constraint('ck_pred_away_goals_nonneg', 'predictions', 'pred_away_goals >= 0')
+    op.create_check_constraint('ck_confidence_range', 'predictions', 'subjective_confidence >= 0 AND subjective_confidence <= 1')
+    op.create_check_constraint('ck_pred_1x2_enum', 'predictions', "pred_1x2 IN ('1', 'X', '2')")
+    op.create_check_constraint('ck_mode_enum', 'predictions', "mode IN ('single', 'multi')")
+
+
+def downgrade() -> None:
+    # 1. 删除 CHECK 约束
+    op.drop_constraint('ck_mode_enum', 'predictions', type_='check')
+    op.drop_constraint('ck_pred_1x2_enum', 'predictions', type_='check')
+    op.drop_constraint('ck_confidence_range', 'predictions', type_='check')
+    op.drop_constraint('ck_pred_away_goals_nonneg', 'predictions', type_='check')
+    op.drop_constraint('ck_pred_home_goals_nonneg', 'predictions', type_='check')
+
+    # 2. 删除快照字段
+    op.drop_column('predictions', 'input_hash')
+    op.drop_column('predictions', 'cutoff_at')
+
+    # 3. 恢复列名
+    op.alter_column('predictions', 'subjective_confidence', new_column_name='confidence')

alembic/versions/0005_prediction_status_and_stats_provenance.py

@@ -0,0 +1,58 @@
+"""add prediction status/time semantics and MatchStats provenance
+
+Revision ID: 0005_prediction_status_and_stats_provenance
+Revises: 0004_snapshot_and_constraints
+Create Date: 2026-09-15
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision: str = '0005_prediction_status_and_stats_provenance'
+down_revision: Union[str, None] = '0004_snapshot_and_constraints'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # 1. Prediction 新增字段
+    op.add_column('predictions', sa.Column('status', sa.String(length=20), nullable=False, server_default='success'))
+    op.add_column('predictions', sa.Column('match_kickoff_at', sa.DateTime(timezone=True), nullable=True))
+    op.add_column('predictions', sa.Column('prediction_created_at', sa.DateTime(timezone=True), nullable=False, server_default=sa.func.now()))
+    op.add_column('predictions', sa.Column('prediction_cutoff_at', sa.DateTime(timezone=True), nullable=True))
+
+    # 重命名 cutoff_at → 保留作为兼容,prediction_cutoff_at 为主字段
+    # op.drop_column('predictions', 'cutoff_at')  # 暂不删除,避免破坏现有数据
+
+    # 2. 新增 status CHECK 约束
+    op.create_check_constraint('ck_status_enum', 'predictions', "status IN ('success', 'failed', 'degraded')")
+
+    # 3. MatchStats 新增数据血缘字段
+    op.add_column('match_stats', sa.Column('source', sa.String(length=30), nullable=True))
+    op.add_column('match_stats', sa.Column('source_record_id', sa.String(length=100), nullable=True))
+    op.add_column('match_stats', sa.Column('retrieved_at', sa.DateTime(timezone=True), nullable=True))
+    op.add_column('match_stats', sa.Column('available_at', sa.DateTime(timezone=True), nullable=True))
+
+    # 4. 索引
+    op.create_index('ix_match_stats_available_at', 'match_stats', ['available_at'])
+    op.create_index('ix_predictions_cutoff_at', 'predictions', ['prediction_cutoff_at'])
+
+
+def downgrade() -> None:
+    op.drop_index('ix_predictions_cutoff_at', table_name='predictions')
+    op.drop_index('ix_match_stats_available_at', table_name='match_stats')
+
+    op.drop_column('match_stats', 'available_at')
+    op.drop_column('match_stats', 'retrieved_at')
+    op.drop_column('match_stats', 'source_record_id')
+    op.drop_column('match_stats', 'source')
+
+    op.drop_constraint('ck_status_enum', 'predictions', type_='check')
+
+    op.drop_column('predictions', 'prediction_cutoff_at')
+    op.drop_column('predictions', 'prediction_created_at')
+    op.drop_column('predictions', 'match_kickoff_at')
+    op.drop_column('predictions', 'status')

alembic/versions/0006_schema_model_drift_cleanup.py

@@ -0,0 +1,80 @@
+"""清理 schema 与 ORM 模型的漂移
+
+Revision ID: 0006_schema_model_drift_cleanup
+Revises: 0005_prediction_status_and_stats_provenance
+Create Date: 2026-09-15
+
+背景(见代码审查报告 P1-1):
+  0005 迁移在 predictions 表留下了 `cutoff_at` 列(删除语句被注释掉),
+  但 ORM 模型 `Prediction` 中并无该字段 —— 这是一处会长期存在的 schema 漂移,
+  而 alembic autogenerate 会持续建议 drop 它,造成噪声。
+
+  同时 0005 创建的两个索引 `ix_match_stats_available_at` 与
+  `ix_predictions_cutoff_at` 未在 ORM 声明,autogenerate 会建议删除它们 ——
+  一旦被误删,数据血缘相关的时间过滤查询会退化为全表扫描。
+
+本迁移做两件事:
+  1. drop 掉幽灵列 predictions.cutoff_at(数据已由 prediction_cutoff_at 承载,
+     迁移前先把非空值回填过去,避免丢数据)
+  2. 显式重建这两个索引(幂等:先 drop if exists 再 create),使 DB 状态与
+     修正后的 ORM 声明一致
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision: str = '0006_schema_model_drift_cleanup'
+down_revision: Union[str, None] = '0005_prediction_status_and_stats_provenance'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+
+    # --- 1. 幽灵列 cutoff_at: 先把数据回填到 prediction_cutoff_at 再删除 ---
+    pred_cols = {c["name"] for c in inspector.get_columns("predictions")}
+    if "cutoff_at" in pred_cols:
+        if "prediction_cutoff_at" in pred_cols:
+            # 仅回填尚未有值的行,避免覆盖更权威的数据
+            op.execute(
+                "UPDATE predictions "
+                "SET prediction_cutoff_at = cutoff_at "
+                "WHERE prediction_cutoff_at IS NULL AND cutoff_at IS NOT NULL"
+            )
+        op.drop_column("predictions", "cutoff_at")
+
+    # --- 2. 与 ORM 声明对齐的索引(幂等重建) ---
+    stats_idx = {i["name"] for i in inspector.get_indexes("match_stats")}
+    if "ix_match_stats_available_at" not in stats_idx:
+        op.create_index("ix_match_stats_available_at", "match_stats", ["available_at"])
+
+    pred_idx = {i["name"] for i in inspector.get_indexes("predictions")}
+    if "ix_predictions_cutoff_at" not in pred_idx:
+        op.create_index(
+            "ix_predictions_cutoff_at", "predictions", ["prediction_cutoff_at"]
+        )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+
+    # 恢复幽灵列(与 0005 的最终状态一致:列存在但无值)
+    pred_cols = {c["name"] for c in inspector.get_columns("predictions")}
+    if "cutoff_at" not in pred_cols:
+        op.add_column(
+            "predictions",
+            sa.Column("cutoff_at", sa.DateTime(timezone=True), nullable=True),
+        )
+
+    stats_idx = {i["name"] for i in inspector.get_indexes("match_stats")}
+    if "ix_match_stats_available_at" in stats_idx:
+        op.drop_index("ix_match_stats_available_at", table_name="match_stats")
+
+    pred_idx = {i["name"] for i in inspector.get_indexes("predictions")}
+    if "ix_predictions_cutoff_at" in pred_idx:
+        op.drop_index("ix_predictions_cutoff_at", table_name="predictions")

docs/01-architecture.md

@@ -21,7 +21,7 @@
 │     │      └────────────┘  └───────────────────┘    │
 │     │              │              └ understat (xG)  │
 │  ┌──┴──────────────┴──┐       └ injuries (伤停)     │
-│  │ PostgreSQL (5 张表) │        httpx → 外部 API     │
+│  │ PostgreSQL (6 张表) │        httpx → 外部 API     │
 │  └────────────────────┘                            │
 └─────────────────────────────────────────────────────┘
 ```
@@ -57,38 +57,48 @@
 Profeto/
 ├── src/
 │   ├── api/
-│   │   ├── app.py               # FastAPI 工厂(lifespan 建表)
+│   │   ├── app.py               # FastAPI 工厂(lifespan 仅验证 DB 连接,不建表)
+│   │   ├── deps.py              # 依赖:管理接口鉴权(X-API-Key)
 │   │   ├── schemas.py           # Pydantic v2 请求/响应
 │   │   └── routes/
 │   │       ├── matches.py       # 联赛/比赛查询(游标分页)
 │   │       ├── predict.py       # 预测 + 预测历史
-│   │       ├── ingest.py        # 采集触发(自管 session)
-│   │       └── eval.py          # 赛后回填 + 准确率汇总
+│   │       ├── ingest.py        # 采集触发(自管 session,需鉴权)
+│   │       ├── eval.py          # 赛后回填 + 准确率汇总
+│   │       └── backtest.py      # 历史回测(需鉴权)
 │   ├── db/
 │   │   ├── base.py              # async engine + get_db/get_db_read
-│   │   └── models.py            # 5 张表 ORM
+│   │   ├── models.py            # 6 张表 ORM
+│   │   ├── repositories.py      # 仓储层
+│   │   └── unit_of_work.py      # 事务边界
 │   ├── data/
 │   │   ├── bzzoiro.py           # 赛果采集 + 幂等入库
 │   │   ├── understat.py         # xG 回填
 │   │   ├── injuries.py          # 伤停采集(带文件缓存)
 │   │   ├── normalize.py         # NormalizedMatch 清洗契约
 │   │   ├── team_names.py        # 队名归一映射
+│   │   ├── sources.py           # 数据源注册表
 │   │   └── config.py            # 联赛代码映射
 │   ├── llm/
 │   │   ├── provider.py          # OpenAI-compatible 抽象(共享连接池/JSON 兜底解析)
 │   │   ├── context_builder.py   # 数据切片(h2h/form/stats/home_away/injuries)+ 单 agent 拼接
 │   │   ├── predict.py           # 预测入口(mode 分派 + 缓存)
 │   │   ├── eval.py              # 准确率统计
+│   │   ├── validation.py        # LLM 输出严格校验(Pydantic)
+│   │   ├── backtest.py          # 回测执行
 │   │   ├── agents/
 │   │   │   ├── base.py          # AgentSpec / AgentReport / run_agent
 │   │   │   └── orchestrator.py  # 并行专家 → 终裁 → 存库
 │   │   └── prompts/
 │   │       ├── match_prediction_v1/v2.md   # 单 agent 模板
 │   │       └── agents/{h2h,form,stats,home_away,injuries,aggregator}_v1.md
-│   └── core/config.py           # pydantic-settings
-├── alembic/versions/            # 0001 建表 + 0002 agent 字段
-├── frontend/src/pages/Matches.tsx  # 单页(预测面板 + 专家报告折叠区)
-├── tests/                       # 33 项(核心 13 + agent 20)
+│   └── core/
+│       ├── config.py            # pydantic-settings
+│       ├── http_client.py       # 共享 httpx 客户端
+│       └── retry.py             # 重试工具
+├── alembic/versions/            # 0001~0006(0001 建表 → 0006 漂移清理)
+├── frontend/src/pages/Matches.tsx  # 单页(预测面板 + 专家报告折叠区 + 游标分页)
+├── tests/                       # 核心 + agent 测试
 ├── docker-compose.yml           # api + postgres 两容器
 └── docs/                         # 本文档
 ```

docs/03-api.md

@@ -87,17 +87,17 @@ Base URL: `http://localhost:8000` · 交互式文档: `/docs`(Swagger)与 `/redo
   "pred_home_goals": 2.1,
   "pred_away_goals": 1.0,
   "pred_1x2": "1",
-  "confidence": 0.68,
+  "subjective_confidence": 0.68,
   "reasoning": "综合 xg 报告的进球期望 2.1-1.0 与 form 报告的三连胜势头……",
   "agent_outputs": [
     {"agent": "h2h", "status": "ok", "data_sufficiency": "medium",
      "analysis": "近 5 次交锋主队 3 胜……", "home_edge": 0.4,
-     "confidence": 0.7, "key_evidence": ["近5次交锋主队3胜", "主场交锋3连胜"],
+     "subjective_confidence": 0.7, "key_evidence": ["近5次交锋主队3胜", "主场交锋3连胜"],
      "exp_home_goals": null, "exp_away_goals": null, "probable_score": null,
      "model": "gpt-4o-mini", "latency_ms": 2100,
      "prompt_tokens": 380, "completion_tokens": 120},
     {"agent": "injuries", "status": "no_data", "data_sufficiency": "none",
-     "analysis": "该维度无数据,跳过分析。", "home_edge": null, "confidence": null,
+     "analysis": "该维度无数据,跳过分析。", "home_edge": null, "subjective_confidence": null,
      "key_evidence": [], "exp_home_goals": null, "exp_away_goals": null,
      "probable_score": null, "model": "", "latency_ms": null,
      "prompt_tokens": null, "completion_tokens": null}
@@ -172,7 +172,7 @@ Base URL: `http://localhost:8000` · 交互式文档: `/docs`(Swagger)与 `/redo
 ```json
 {"summary": [
   {"provider": "openai", "model": "gpt-4o", "total": 12,
-   "accuracy_1x2": 58.3, "avg_score_rmse": 1.21, "avg_confidence": 0.65}
+   "accuracy_1x2": 58.3, "avg_score_rmse": 1.21, "avg_subjective_confidence": 0.65}
 ]}
 ```
 

docs/04-agents.md

@@ -65,7 +65,7 @@ POST /predict {match_id, mode: "multi"}
   "data_sufficiency": "high",
   "analysis": "近 5 次交锋主队 3 胜 1 平 1 负,主场交锋 3 连胜……",
   "home_edge": 0.4,
-  "confidence": 0.7,
+  "subjective_confidence": 0.7,
   "key_evidence": ["近5次交锋主队3胜", "主场交锋3连胜"]
 }
 ```
@@ -75,7 +75,7 @@ POST /predict {match_id, mode: "multi"}
 | `status` | `ok` / `no_data` / `error` / `parse_error` |
 | `data_sufficiency` | `high` / `medium` / `low` / `none` |
 | `home_edge` | -1.0 ~ 1.0,正数=利主队,负数=利客队 |
-| `confidence` | 0.0 ~ 1.0,该专家对自己分析的信心 |
+| `subjective_confidence` | 0.0 ~ 1.0,该专家对自己分析的主观信心(非概率) |
 | `key_evidence` | 关键证据列表(最多 5 条) |
 
 ### 终裁 Agent 输出
@@ -87,13 +87,13 @@ POST /predict {match_id, mode: "multi"}
   "pred_home_goals": 2.1,
   "pred_away_goals": 1.0,
   "1x2": "1",
-  "confidence": 0.68,
+  "subjective_confidence": 0.68,
   "reasoning": "综合 stats 报告的攻防强度与 form 报告的三连胜势头……",
   "agent_weights": {"form": 0.9, "stats": 0.8, "home_away": 0.7, "injuries": 0.0, "h2h": 0.8}
 }
 ```
 
-`agent_weights` 体现终裁对各专家报告的采信度(0–1),可用于后续分析"哪个维度对预测贡献大"。
+`agent_weights` 体现终裁对各专家报告的采信度(0–1),可用于后续分析"哪个维度对预测贡献大"。注意:这是 LLM 主观权重,非统计权重。
 
 ## 模型分档配置
 

docs/05-data.md

@@ -59,7 +59,7 @@
 
 ## 数据库 Schema
 
-5 张表:
+6 张表:
 
 ```sql
 -- 联赛
@@ -124,7 +124,12 @@ CREATE TABLE predictions (
     latency_ms INT,
     pred_home_goals FLOAT, pred_away_goals FLOAT,
     pred_1x2 VARCHAR(3),                 -- '1' / 'X' / '2'
-    confidence FLOAT,
+    subjective_confidence FLOAT,         -- LLM 主观置信度(非概率)
+    status VARCHAR(20) NOT NULL DEFAULT 'success',  -- 'success' / 'failed' / 'degraded'
+    match_kickoff_at TIMESTAMPTZ,        -- 比赛时间
+    prediction_created_at TIMESTAMPTZ,   -- 预测创建时间
+    prediction_cutoff_at TIMESTAMPTZ,    -- 数据截止时间
+    input_hash VARCHAR(64),              -- 输入快照 hash
     reasoning TEXT,
     raw_response JSONB,                  -- LLM 完整原始响应
     agent_outputs JSONB,                 -- multi 模式: 5 份专家报告

docs/06-deployment.md

@@ -128,7 +128,7 @@ alembic revision -m "描述"
 ```
 
 已有迁移:
-- `0001_initial`: 初始 5 张表
+- `0001_initial`: 初始 5 张表,0003 增加 injuries,0004 增加约束,0005 增加时间语义
 - `0002_agent_outputs`: predictions 加 `mode` + `agent_outputs`
 
 ## 备份与恢复

docs/07-development.md

@@ -35,27 +35,34 @@ Profeto/
 ├── src/                        # 后端源码
 │   ├── api/
 │   │   ├── routes/             # FastAPI 路由
-│   │   │   ├── leagues.py      # 联赛/比赛查询
+│   │   │   ├── matches.py      # 联赛/比赛查询
 │   │   │   ├── predict.py      # 预测入口
 │   │   │   ├── ingest.py       # 数据采集
-│   │   │   └── eval.py         # 评估回填
+│   │   │   ├── eval.py         # 评估回填
+│   │   │   └── backtest.py     # 历史回测
+│   │   ├── deps.py             # 依赖:管理接口鉴权(X-API-Key)
 │   │   ├── schemas.py          # Pydantic 模型
 │   │   └── app.py              # FastAPI 工厂
 │   ├── db/
 │   │   ├── base.py             # SQLAlchemy async engine + session
-│   │   └── models.py           # 5 张表 ORM
+│   │   ├── models.py           # 6 张表 ORM
+│   │   ├── repositories.py     # 仓储层(查询封装)
+│   │   └── unit_of_work.py     # 事务边界
 │   ├── data/
 │   │   ├── bzzoiro.py          # bzzoiro 采集 + 入库
 │   │   ├── understat.py        # understat xG 回填
 │   │   ├── injuries.py         # 伤停采集
 │   │   ├── normalize.py        # 数据清洗契约
 │   │   ├── team_names.py       # 队名归一化映射
+│   │   ├── sources.py          # 数据源注册表
 │   │   └── config.py           # 联赛映射常量
 │   ├── llm/
 │   │   ├── provider.py         # LLM 提供商抽象(OpenAI-compatible)
 │   │   ├── context_builder.py  # 数据切片 + 拼接
 │   │   ├── predict.py          # 预测入口(单/多模式分派)
 │   │   ├── eval.py             # 评估统计
+│   │   ├── validation.py       # LLM 输出严格校验
+│   │   ├── backtest.py         # 回测执行
 │   │   ├── agents/
 │   │   │   ├── base.py         # AgentSpec + run_agent
 │   │   │   └── orchestrator.py # 多 agent 编排
@@ -69,12 +76,18 @@ Profeto/
 │   │           ├── h2h_v1.md
 │   │           └── aggregator_v1.md
 │   └── core/
-│       └── config.py           # pydantic-settings 配置
+│       ├── config.py           # pydantic-settings 配置
+│       ├── http_client.py      # 共享 httpx 客户端
+│       └── retry.py            # 重试工具
 ├── frontend/                   # React 单页前端
 ├── alembic/                    # 数据库迁移
 │   └── versions/
 │       ├── 0001_initial.py
-│       └── 0002_agent_outputs.py
+│       ├── 0002_agent_outputs.py
+│       ├── 0003_injuries.py
+│       ├── 0004_snapshot_and_constraints.py
+│       ├── 0005_prediction_status_and_stats_provenance.py
+│       └── 0006_schema_model_drift_cleanup.py
 ├── tests/                      # 测试
 │   ├── test_core.py            # 核心逻辑测试
 │   └── test_agents.py          # 多 agent 测试
@@ -118,7 +131,7 @@ class MockProvider:
         return LLMResponse(
             content="{}",
             parsed={"data_sufficiency": "high", "analysis": "ok",
-                    "home_edge": 0.5, "confidence": 0.8,
+                    "home_edge": 0.5, "subjective_confidence": 0.8,
                     "key_evidence": ["证据"]},
             prompt_tokens=10, completion_tokens=5, latency_ms=100,
         )

docs/AGENTS.md

@@ -1,128 +0,0 @@
-# 多 Agent 协同架构
-
-本项目采用 4 个专业 Agent 协同工作,各司其职。
-
-## Agent 职责
-
-### 🗄️ 数据库 Agent (DBA)
-**所有权:** `src/db/`, `alembic/`, 数据模型
-
-职责:
-- 数据库 schema 设计与迁移 (Alembic)
-- ORM 模型定义与关系
-- 查询性能优化与索引
-- 数据完整性约束
-- 数据源入库逻辑
-
-边界:
-- 不写业务路由
-- 不写前端代码
-- 对外暴露稳定的模型接口
-
----
-
-### 🖥️ 前端 Agent (FE)
-**所有权:** `frontend/`
-
-职责:
-- React 组件与页面
-- 用户界面与交互
-- 状态管理
-- API 调用与数据展示
-- 样式 (Tailwind)
-
-边界:
-- 不直接操作数据库
-- 不写后端业务逻辑
-- 通过 REST API 与后端通信
-
----
-
-### ⚙️ 后端 Agent (BE)
-**所有权:** `src/api/`, `src/core/`, `src/llm/`, `src/data/`
-
-职责:
-- API 路由与业务逻辑
-- LLM 预测管线 (上下文构建 → 调用 → 存储)
-- 数据采集与清洗
-- 定时任务调度
-- 多 Agent 编排 (LLM 专家系统)
-
-边界:
-- 不写前端展示
-- 不直接配置部署环境
-- 对外暴露 REST API
-
----
-
-### 🚀 部署 Agent (Ops)
-**所有权:** `Dockerfile`, `docker-compose.yml`, `.env.example`, 配置
-
-职责:
-- 容器化与编排
-- 环境变量与配置管理
-- 服务健康检查
-- 日志与监控
-- 备份策略
-
-边界:
-- 不写应用代码
-- 不修改业务逻辑
-- 通过配置文件影响行为
-
----
-
-## 协作接口
-
-### FE ↔ BE
-```
-REST API (OpenAPI 契约)
-- GET  /api/v1/matches
-- POST /api/v1/predict
-- GET  /api/v1/predictions
-- POST /api/v1/eval/settle
-- GET  /api/v1/backtest
-```
-
-### BE ↔ DBA
-```
-SQLAlchemy 模型接口
-- Match, Team, League, MatchStats, Prediction, Injury
-- AsyncSession 依赖注入
-```
-
-### BE ↔ LLM
-```
-LLMProvider 抽象
-- OpenAI / Deepseek / Ollama / 任意兼容网关
-- JSON mode 结构化输出
-```
-
-### Ops ↔ 所有
-```
-环境变量 + docker-compose
-- .env 配置注入
-- 服务发现 (localhost:8000 / 5432)
-```
-
----
-
-## 工作流程
-
-```
-1. 用户/编排者 发起任务
-2. 拆解任务分配给对应 Agent
-3. Agent 在各自所有权范围内工作
-4. 跨 Agent 变更通过接口契约协调
-5. 集成测试验证协作
-```
-
-## 变更协调规则
-
-| 变更类型 | 需要协调 |
-|---|---|
-| 新增 API 字段 | BE + FE |
-| 修改数据模型 | DBA + BE + FE |
-| 新增数据源 | DBA + BE |
-| 修改部署配置 | Ops + 所有 |
-| 修改 LLM Prompt | BE (独立) |

docs/README.md

@@ -6,7 +6,7 @@
 | [02-快速开始](02-quickstart.md) | 安装、启动、首次跑通全流程 |
 | [03-API 参考](03-api.md) | 全部 12 个端点、请求/响应示例、curl 全流程 |
 | [04-多 Agent 预测](04-agents.md) | 5 专家 + 终裁架构、执行语义、输出契约、prompt 版本化、如何新增 agent |
-| [05-数据层与数据库](05-data.md) | 三数据源、清洗契约、5 张表 schema、入库语义、采集建议 |
+| [05-数据层与数据库](05-data.md) | 三数据源、清洗契约、6 张表 schema、入库语义、采集建议 |
 | [06-部署](06-deployment.md) | Docker Compose、本地部署、环境变量、LLM 提供商配置、迁移、备份 |
 | [07-开发指南](07-development.md) | 项目结构、测试、常见开发任务(prompt/agent/数据源/联赛)、前端开发 |
 

docs/agents/be.md

@@ -1,61 +0,0 @@
-# 后端 Agent (BE)
-
-你是 Profeto 项目的后端 Agent，负责所有业务逻辑和 API。
-
-## 所有权
-- `src/api/` — FastAPI 路由、应用工厂、schemas
-- `src/core/` — 配置、HTTP 客户端、重试工具
-- `src/llm/` — LLM 预测核心（provider、上下文构建、多 Agent 编排、评估、回测）
-- `src/data/` — 数据采集源、规范化、数据源协议
-
-## 当前 API 路由
-
-| 方法 | 路径 | 作用 |
-|---|---|---|
-| GET | `/api/v1/matches` | 比赛查询（筛选/分页） |
-| GET | `/api/v1/matches/{id}` | 单场详情 |
-| GET | `/api/v1/leagues` | 联赛列表 |
-| POST | `/api/v1/predict` | LLM 预测（single/multi） |
-| GET | `/api/v1/predictions` | 预测历史 |
-| GET | `/api/v1/predictions/{id}` | 单条预测详情 |
-| POST | `/api/v1/ingest/bzzoiro` | 采集比分/统计 |
-| POST | `/api/v1/ingest/understat` | 回填 xG |
-| POST | `/api/v1/ingest/injuries` | 采集伤停 |
-| POST | `/api/v1/eval/settle` | 回填实际结果 |
-| GET | `/api/v1/eval/summary` | 准确率汇总 |
-| POST | `/api/v1/backtest` | 回测 |
-
-## 核心模块
-
-### LLM 预测管线
-```
-match_id → build_context (数据切片) → LLM 调用 → 解析 → 存储
-```
-
-### 多 Agent 编排 (LLM 专家系统)
-```
-5 专家 (form/stats/home_away/injuries/h2h) → 终裁 → 最终预测
-```
-
-### 数据源协议
-```python
-class DataSource(Protocol):
-    name: str
-    async def ingest(db, **kwargs) -> dict: ...
-```
-
-## 设计原则
-- RESTful API，OpenAPI 文档自动生成
-- 异步优先（asyncpg + async httpx）
-- 错误分层（404/502/500）
-- 预测结果持久化
-
-## 对外接口
-- 为 FE Agent 提供稳定 REST API
-- 使用 DBA Agent 提供的 ORM 模型
-- 遵循 Ops Agent 定义的环境配置
-
-## 不做
-- 不写前端展示
-- 不修改 schema（通过 DBA）
-- 不配置部署（通过 Ops）

docs/agents/dba.md

@@ -1,36 +0,0 @@
-# 数据库 Agent (DBA)
-
-你是 Profeto 项目的数据库 Agent，负责所有数据层工作。
-
-## 所有权
-- `src/db/` — SQLAlchemy 引擎、会话、Base
-- `src/db/models.py` — 所有 ORM 模型
-- `alembic/` — 数据库迁移脚本
-- `src/data/normalize.py` — 数据规范化契约
-- `src/data/match_lookup.py` — 比赛匹配辅助函数
-
-## 当前 Schema (5 表 + 1 新增)
-
-```
-leagues (id, code, name, country)
-teams (id, name, name_zh, team_type)
-matches (id, league_id, season, home_team_id, away_team_id, match_date, match_status, goals..., stats...)
-match_stats (match_id PK, xg, shots, corners, possession, cards...)
-predictions (id, match_id, provider, model, prompt_version, tokens, pred_1x2, confidence, raw_response, mode, agent_outputs, actual_..., settled)
-injuries (id, player_id, player_name, team_id, fixture_id, injury_type, reason, dates...)
-```
-
-## 设计原则
-- 所有字段可空性明确（业务可空 vs 必须 NOT NULL）
-- 外键级联删除合理（match 删除 → stats/predictions 级联）
-- 索引覆盖高频查询（按日期、按球队、按联赛）
-- 迁移脚本幂等
-
-## 对外接口
-- 提供稳定的 ORM 模型供 BE Agent 使用
-- 变更模型时通知 BE Agent 更新查询
-
-## 不做
-- 不写 API 路由
-- 不写前端代码
-- 不修改业务逻辑

docs/agents/fe.md

@@ -1,46 +0,0 @@
-# 前端 Agent (FE)
-
-你是 Profeto 项目的前端 Agent，负责所有用户界面工作。
-
-## 所有权
-- `frontend/` — 整个前端项目
-- React + TypeScript + Vite + Tailwind CSS
-
-## 当前结构
-```
-frontend/src/
-├── main.tsx          # 入口
-├── App.tsx           # 根组件 + ErrorBoundary
-├── index.css         # 全局样式
-├── components/
-│   └── ErrorBoundary.tsx
-└── pages/
-    └── Matches.tsx   # 当前唯一页面（比赛列表 + 预测）
-```
-
-## 当前 API 契约（来自 BE Agent）
-
-| 端点 | 用途 |
-|---|---|
-| `GET /api/v1/matches?league=&status=&limit=` | 比赛列表 |
-| `POST /api/v1/predict` body: `{match_id, mode}` | 触发预测 |
-| `GET /api/v1/predictions?match_id=&limit=` | 预测历史 |
-| `POST /api/v1/backtest` | 回测（管理用） |
-| `POST /api/v1/eval/settle` | 回填结果（管理用） |
-| `GET /api/v1/eval/summary` | 准确率统计 |
-
-## 设计原则
-- 单页应用，预测面板为核心
-- 展示为主，控制操作最小化
-- 响应式（移动端优先）
-- 加载/错误/空状态完整
-
-## 对外依赖
-- 通过 REST API 与 BE Agent 通信
-- 不直接访问数据库
-- 不修改 API 契约（需与 BE 协商）
-
-## 不做
-- 不写后端业务逻辑
-- 不操作数据库
-- 不修改部署配置

docs/agents/ops.md

@@ -1,47 +0,0 @@
-# 部署 Agent (Ops)
-
-你是 Profeto 项目的部署 Agent，负责基础设施和运维。
-
-## 所有权
-- `Dockerfile` — API 服务镜像
-- `docker-compose.yml` — 服务编排
-- `.env.example` — 环境变量模板
-- `pyproject.toml` — Python 依赖声明
-
-## 当前服务架构
-
-```yaml
-services:
-  postgres:  # PostgreSQL 16, port 5432
-  api:       # FastAPI, port 8000, depends on postgres
-```
-
-## 环境变量
-
-| 变量 | 说明 |
-|---|---|
-| `DATABASE_URL` | PostgreSQL 连接 |
-| `LLM_PROVIDER` | 提供商标识 |
-| `LLM_API_KEY` | API 密钥 |
-| `LLM_BASE_URL` | API 地址 |
-| `LLM_MODEL` | 模型名 |
-| `LLM_SPECIALIST_MODEL` | 专家模型（多 Agent 模式） |
-| `LLM_AGGREGATOR_MODEL` | 终裁模型 |
-| `BZZOIRO_KEY` | bzzoiro 数据源密钥 |
-| `API_FOOTBALL_KEY` | api-football 密钥 |
-| `CORS_ORIGINS` | 跨域来源 |
-
-## 设计原则
-- 配置与代码分离（.env 不入库）
-- 健康检查（postgres + api）
-- 数据持久化（postgres volume）
-- 最小镜像（python:3.11-slim）
-
-## 对外接口
-- 为 BE Agent 提供运行环境
-- 为 FE Agent 提供反向代理目标（同端口或 nginx）
-
-## 不做
-- 不写应用代码
-- 不修改业务逻辑
-- 不变更 API 契约

frontend/postcss.config.js

@@ -1,5 +1,6 @@
 export default {
-  content: ['./index.html', './src/**/*.{ts,tsx}'],
-  theme: { extend: {} },
-  plugins: [],
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
 }

frontend/src/App.tsx

@@ -1,17 +1,54 @@
 import { ErrorBoundary } from './components/ErrorBoundary'
 import Matches from './pages/Matches'
 
+/** 报眉日期行:2026年9月15日 星期二 */
+function dateLine(): string {
+  return new Date().toLocaleDateString('zh-CN', {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+    weekday: 'long',
+  })
+}
+
 export default function App() {
   return (
     <ErrorBoundary>
-      <div className="min-h-screen bg-gray-50">
-        <header className="bg-white border-b px-6 py-3 flex items-center justify-between">
-          <h1 className="text-xl font-bold text-blue-700">⚽ 先知 Profeto</h1>
-          <span className="text-sm text-gray-500">足球 LLM 预测服务</span>
+      <div className="min-h-screen bg-paper-50">
+        {/* ── 报头:粗线 + 居中刊名 + 报眉 ── */}
+        <header className="masthead-rule">
+          <div className="mx-auto max-w-5xl px-5 sm:px-8">
+            <div className="border-b border-ink-900 py-5 text-center sm:py-6">
+              <h1 className="font-serif text-4xl font-bold tracking-widest text-ink-900">
+                先知
+                <span className="ml-3 align-baseline font-serif text-base font-normal italic tracking-normal text-ink-500">
+                  Profeto
+                </span>
+              </h1>
+              <p className="mt-2 text-2xs tracking-[0.4em] text-ink-500">
+                足球比分预测 · 五路专家 · 终裁汇总
+              </p>
+            </div>
+            <div className="flex items-center justify-between border-b border-ink-200 py-2 text-2xs text-ink-500">
+              <span>{dateLine()}</span>
+              <span className="flex items-center gap-1.5">
+                <span className="inline-block h-1.5 w-1.5 bg-emerald-600" aria-hidden="true" />
+                服务运行中
+              </span>
+            </div>
+          </div>
         </header>
-        <main className="max-w-5xl mx-auto p-6">
+
+        <main className="mx-auto max-w-5xl px-5 py-6 sm:px-8 sm:py-8">
           <Matches />
         </main>
+
+        {/* ── 版底 ── */}
+        <footer className="mx-auto max-w-5xl px-5 pb-10 sm:px-8">
+          <div className="border-t border-ink-200 pt-3 text-center text-2xs leading-relaxed text-ink-400">
+            预测结果由大语言模型生成 · 仅供研究参考 · 不构成任何投注建议
+          </div>
+        </footer>
       </div>
     </ErrorBoundary>
   )

frontend/src/index.css

@@ -1,3 +1,102 @@
 @tailwind base;
 @tailwind components;
 @tailwind utilities;
+
+@layer base {
+  html {
+    -webkit-text-size-adjust: 100%;
+    text-rendering: optimizeLegibility;
+  }
+
+  body {
+    @apply bg-paper-50 text-ink-800 font-sans antialiased;
+    font-feature-settings: 'tnum' 1; /* 数字等宽:比分/百分比不跳动 */
+  }
+
+  ::selection {
+    @apply bg-press-wash text-press;
+  }
+
+  /* 统一焦点环:印报红细线,键盘可达 */
+  :focus-visible {
+    outline: 2px solid #9e1b1b;
+    outline-offset: 2px;
+  }
+
+  /* 细滚动条 */
+  ::-webkit-scrollbar {
+    width: 10px;
+    height: 10px;
+  }
+  ::-webkit-scrollbar-track {
+    background: transparent;
+  }
+  ::-webkit-scrollbar-thumb {
+    @apply rounded-full bg-ink-300;
+  }
+  ::-webkit-scrollbar-thumb:hover {
+    @apply bg-ink-400;
+  }
+
+  /* 尊重「减少动态效果」偏好 */
+  @media (prefers-reduced-motion: reduce) {
+    *,
+    *::before,
+    *::after {
+      animation-duration: 0.01ms !important;
+      animation-iteration-count: 1 !important;
+      transition-duration: 0.01ms !important;
+    }
+  }
+}
+
+@layer components {
+  /* ── 报头双线:粗线在上、细线在下 ── */
+  .masthead-rule {
+    border-top: 3px solid #17140f;
+  }
+
+  /* ── 按钮:方正边框式,悬停反白 ── */
+  .btn {
+    @apply inline-flex items-center justify-center gap-1.5 border border-ink-300 bg-transparent px-3 py-1.5
+           text-sm text-ink-700 transition-colors duration-150
+           hover:border-ink-900 hover:bg-ink-900 hover:text-paper-50
+           disabled:cursor-not-allowed disabled:opacity-40
+           disabled:hover:border-ink-300 disabled:hover:bg-transparent disabled:hover:text-ink-700;
+  }
+  .btn-sm {
+    @apply px-2.5 py-1 text-xs;
+  }
+  .btn-solid {
+    @apply border-ink-900 bg-ink-900 text-paper-50 hover:border-press hover:bg-press;
+  }
+
+  /* ── 表单控件:方正、无圆角 ── */
+  .field {
+    @apply border border-ink-300 bg-transparent px-2.5 py-1.5 text-sm text-ink-800
+           transition-colors hover:border-ink-400
+           focus:border-press focus:outline-none;
+  }
+
+  /* ── 版面切换文字标签(联赛/状态/模式) ── */
+  .tab {
+    @apply whitespace-nowrap px-0.5 py-1 text-sm text-ink-500 transition-colors hover:text-ink-900;
+  }
+  .tab-on {
+    @apply font-medium text-press;
+  }
+  .tab-on::after {
+    content: '';
+    @apply absolute inset-x-0 bottom-0 h-0.5 bg-press;
+  }
+
+  /* ── 小节标题:宋体加粗 + 墨色底线 ── */
+  .section-head {
+    @apply border-b border-ink-900 pb-1.5 font-serif text-sm font-bold text-ink-900;
+  }
+
+  /* ── 骨架占位:低调脉动,不用渐变扫光 ── */
+  .skeleton {
+    @apply animate-pulse rounded-none bg-ink-200;
+  }
+}

frontend/src/pages/Matches.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from 'react'
+import { useCallback, useEffect, useRef, useState } from 'react'
 
 interface Match {
   id: number
@@ -26,7 +26,7 @@ interface Prediction {
   pred_home_goals: number | null
   pred_away_goals: number | null
   pred_1x2: string | null
-  confidence: number | null
+  subjective_confidence: number | null
   reasoning: string | null
   agent_outputs: AgentReport[] | null
   agent_weights: Record<string, number> | null
@@ -40,7 +40,7 @@ interface AgentReport {
   data_sufficiency: string
   analysis: string
   home_edge: number | null
-  confidence: number | null
+  subjective_confidence: number | null
   key_evidence: string[]
   exp_home_goals: number | null
   exp_away_goals: number | null
@@ -65,54 +65,207 @@ const LEAGUES = [
   { code: 'F1', name: '法甲' },
 ]
 
+/** 汉字编号,给专家意见排版用 */
+const CN_NUM = ['一', '二', '三', '四', '五', '六', '七', '八']
+
+const STATUS_META: Record<string, { label: string; cls: string }> = {
+  finished: { label: '已完赛', cls: 'text-ink-400' },
+  scheduled: { label: '未开赛', cls: 'text-ink-600' },
+  live: { label: '进行中', cls: 'text-press font-medium' },
+}
+
+/** 1x2 → 中文标签 */
+const OUTCOME_LABEL: Record<string, string> = { '1': '主胜', X: '平局', '2': '客胜' }
+
+/** 置信度细线:0~1 数值的低调可视化 */
+function Meter({ value }: { value: number }) {
+  const pct = Math.max(0, Math.min(100, Math.round(value * 100)))
+  return (
+    <div className="h-px w-full bg-ink-200" role="presentation">
+      <div className="h-px bg-press transition-[width] duration-500" style={{ width: `${pct}%` }} />
+    </div>
+  )
+}
+
+/** home_edge(-1~1,正=利主队)的可视化:以中线为原点的双向细条 */
+function EdgeBar({ value }: { value: number }) {
+  const v = Math.max(-1, Math.min(1, value))
+  const half = Math.abs(v) * 50
+  return (
+    <div className="relative h-px w-full bg-ink-200" role="presentation">
+      <span className="absolute left-1/2 top-1/2 h-2 w-px -translate-x-1/2 -translate-y-1/2 bg-ink-400" />
+      <span
+        className={`absolute top-0 h-px transition-all duration-500 ${v >= 0 ? 'bg-press' : 'bg-ink-600'}`}
+        style={
+          v >= 0
+            ? { left: '50%', width: `${half}%` }
+            : { right: '50%', width: `${half}%` }
+        }
+      />
+    </div>
+  )
+}
+
+/** 骨架占位行:低调脉动灰块 */
+function SkeletonRows({ n = 4 }: { n?: number }) {
+  return (
+    <>
+      {Array.from({ length: n }).map((_, i) => (
+        <div key={i} className="flex items-center gap-4 border-b border-ink-200 px-1 py-3.5">
+          <div className="skeleton h-3 w-16" />
+          <div className="skeleton h-3 flex-1" />
+          <div className="skeleton h-3 w-10" />
+          <div className="skeleton h-3 flex-1" />
+          <div className="skeleton h-3 w-16" />
+        </div>
+      ))}
+    </>
+  )
+}
+
+function Spinner({ className = '' }: { className?: string }) {
+  return (
+    <svg
+      viewBox="0 0 20 20"
+      className={`h-3.5 w-3.5 animate-spin ${className}`}
+      fill="none"
+      aria-hidden="true"
+    >
+      <circle cx="10" cy="10" r="7.5" stroke="currentColor" strokeWidth="1.5" strokeOpacity="0.25" />
+      <path d="M17.5 10A7.5 7.5 0 0010 2.5" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" />
+    </svg>
+  )
+}
+
+/** 胜平负一行文字:选中的红字加方块标记,未选中的退灰 */
+function OutcomeLine({
+  pick,
+  confidence,
+}: {
+  pick: string | null
+  confidence: number | null
+}) {
+  const options = ['1', 'X', '2'] as const
+  return (
+    <div>
+      <div className="flex items-baseline justify-center gap-6 sm:gap-10">
+        {options.map(o => {
+          const on = pick === o
+          return (
+            <div key={o} className="flex flex-col items-center gap-1">
+              <span className={`flex items-center gap-1.5 text-sm ${on ? 'font-semibold text-press' : 'text-ink-400'}`}>
+                {on && <span className="inline-block h-2 w-2 bg-press" aria-hidden="true" />}
+                {OUTCOME_LABEL[o]}
+              </span>
+              {on && confidence !== null && (
+                <span className="text-2xs tabular-nums text-ink-500">
+                  置信 {Math.round(confidence * 100)}%
+                </span>
+              )}
+            </div>
+          )
+        })}
+      </div>
+      {pick && confidence !== null && (
+        <div className="mx-auto mt-3 max-w-xs">
+          <Meter value={confidence} />
+          <p className="mt-1 text-center text-2xs text-ink-400">主观置信度,非统计概率</p>
+        </div>
+      )}
+    </div>
+  )
+}
+
 export default function Matches() {
   const [league, setLeague] = useState('E0')
   const [status, setStatus] = useState('scheduled')
   const [matches, setMatches] = useState<Match[]>([])
+  const [nextCursor, setNextCursor] = useState<string | null>(null)
+  const [loadingMore, setLoadingMore] = useState(false)
   const [loading, setLoading] = useState(false)
   const [predictingId, setPredictingId] = useState<number | null>(null)
   const [prediction, setPrediction] = useState<Prediction | null>(null)
+  const [predictionFor, setPredictionFor] = useState<Match | null>(null)
   const [error, setError] = useState<string | null>(null)
   const [mode, setMode] = useState<'single' | 'multi'>('multi')
 
+  // 请求竞态防护:切换联赛/状态很快时,先发的慢请求可能后返回,
+  // 把旧结果覆盖到新筛选上。用递增序号只认最后一次请求的响应。
+  const loadSeq = useRef(0)
+  const predictSeq = useRef(0)
+
   const load = useCallback(async () => {
+    const seq = ++loadSeq.current
     setLoading(true)
+    // 切换筛选时作废进行中的「加载更多」,避免其标志位卡住
+    setLoadingMore(false)
     setError(null)
     try {
       const params = new URLSearchParams({ league, status, limit: '50' })
       const res = await fetch(`/api/v1/matches?${params}`)
+      if (seq !== loadSeq.current) return // 已有更新的请求,丢弃本次结果
       if (!res.ok) throw new Error(`HTTP ${res.status}`)
       const data = await res.json()
+      if (seq !== loadSeq.current) return
       setMatches(data.items)
+      setNextCursor(data.next_cursor ?? null)
     } catch (e) {
+      if (seq !== loadSeq.current) return
       setError(e instanceof Error ? e.message : String(e))
     } finally {
-      setLoading(false)
+      if (seq === loadSeq.current) setLoading(false)
     }
   }, [league, status])
 
+  // 加载下一页(游标分页)
+  const loadMore = async () => {
+    if (!nextCursor || loadingMore) return
+    const seq = loadSeq.current // 不做自增:切换筛选会自增,这里只跟随当前序列
+    setLoadingMore(true)
+    try {
+      const params = new URLSearchParams({ league, status, limit: '50', cursor: nextCursor })
+      const res = await fetch(`/api/v1/matches?${params}`)
+      if (seq !== loadSeq.current) return
+      if (!res.ok) throw new Error(`HTTP ${res.status}`)
+      const data = await res.json()
+      if (seq !== loadSeq.current) return
+      setMatches(prev => [...prev, ...data.items])
+      setNextCursor(data.next_cursor ?? null)
+    } catch (e) {
+      if (seq !== loadSeq.current) return
+      setError(e instanceof Error ? e.message : String(e))
+    } finally {
+      if (seq === loadSeq.current) setLoadingMore(false)
+    }
+  }
+
   useEffect(() => { load() }, [load])
 
-  const predict = async (matchId: number) => {
-    setPredictingId(matchId)
+  const predict = async (m: Match) => {
+    const seq = ++predictSeq.current
+    setPredictingId(m.id)
     setError(null)
     setPrediction(null)
+    setPredictionFor(m)
     try {
       const res = await fetch('/api/v1/predict', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ match_id: matchId, mode }),
+        body: JSON.stringify({ match_id: m.id, mode }),
       })
+      if (seq !== predictSeq.current) return
       if (!res.ok) {
         const t = await res.text()
         throw new Error(`HTTP ${res.status}: ${t}`)
       }
       const data = await res.json()
+      if (seq !== predictSeq.current) return
       setPrediction(data)
     } catch (e) {
+      if (seq !== predictSeq.current) return
       setError(e instanceof Error ? e.message : String(e))
     } finally {
-      setPredictingId(null)
+      if (seq === predictSeq.current) setPredictingId(null)
     }
   }
 
@@ -121,195 +274,410 @@ export default function Matches() {
     return d.toLocaleString('zh-CN', { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' })
   }
 
+  const leagueName = LEAGUES.find(l => l.code === league)?.name ?? league
+
+  /** 状态/模式一组的文字切换 */
+  const Switch = ({ value, onChange, items }: {
+    value: string
+    onChange: (v: string) => void
+    items: { v: string; label: string; title?: string }[]
+  }) => (
+    <span className="inline-flex items-center gap-2.5">
+      {items.map((it, i) => (
+        <span key={it.v} className="inline-flex items-center gap-2.5">
+          {i > 0 && <span className="text-ink-300" aria-hidden="true">/</span>}
+          <button
+            onClick={() => onChange(it.v)}
+            title={it.title}
+            className={`relative tab ${value === it.v ? 'tab-on' : ''} text-xs`}
+          >
+            {it.label}
+          </button>
+        </span>
+      ))}
+    </span>
+  )
+
   return (
-    <div className="space-y-4">
-      {/* 筛选 */}
-      <div className="flex gap-3 items-center flex-wrap">
-        <select value={league} onChange={e => setLeague(e.target.value)}
-          className="border rounded px-3 py-1.5 text-sm">
-          {LEAGUES.map(l => <option key={l.code} value={l.code}>{l.name}</option>)}
-        </select>
-        <select value={status} onChange={e => setStatus(e.target.value)}
-          className="border rounded px-3 py-1.5 text-sm">
-          <option value="scheduled">未开赛</option>
-          <option value="finished">已完赛</option>
-          <option value="">全部</option>
-        </select>
-        <div className="flex items-center gap-2 text-sm">
-          <span className="text-gray-500">模式:</span>
+    <div className="space-y-5">
+      {/* ── 联赛版面切换 ── */}
+      <nav className="flex items-center gap-6 overflow-x-auto border-b border-ink-900" aria-label="联赛">
+        {LEAGUES.map(l => (
           <button
-            onClick={() => setMode('single')}
-            className={`px-2 py-1 rounded text-xs ${mode === 'single' ? 'bg-blue-600 text-white' : 'bg-gray-100 text-gray-600'}`}
-          >单次</button>
-          <button
-            onClick={() => setMode('multi')}
-            className={`px-2 py-1 rounded text-xs ${mode === 'multi' ? 'bg-blue-600 text-white' : 'bg-gray-100 text-gray-600'}`}
-          >多 Agent</button>
-        </div>
-        <button onClick={load} disabled={loading}
-          className="bg-blue-600 text-white text-sm px-4 py-1.5 rounded hover:bg-blue-700 disabled:opacity-50">
-          {loading ? '加载中...' : '刷新'}
-        </button>
-        <span className="text-sm text-gray-500">共 {matches.length} 场</span>
+            key={l.code}
+            onClick={() => setLeague(l.code)}
+            className={`relative tab ${league === l.code ? 'tab-on' : ''} font-serif`}
+          >
+            {l.name}
+          </button>
+        ))}
+      </nav>
+
+      {/* ── 第二行:状态 / 模式 / 计数 / 刷新 ── */}
+      <div className="flex flex-wrap items-center gap-x-5 gap-y-2 text-xs text-ink-500">
+        <span className="inline-flex items-center gap-2.5">
+          <span className="text-2xs text-ink-400">状态</span>
+          <Switch
+            value={status}
+            onChange={setStatus}
+            items={[
+              { v: 'scheduled', label: '未开赛' },
+              { v: 'finished', label: '已完赛' },
+              { v: '', label: '全部' },
+            ]}
+          />
+        </span>
+
+        <span className="inline-flex items-center gap-2.5">
+          <span className="text-2xs text-ink-400">模式</span>
+          <Switch
+            value={mode}
+            onChange={v => setMode(v as 'single' | 'multi')}
+            items={[
+              { v: 'single', label: '单次', title: '单次调用,快但只有一个模型看全部数据' },
+              { v: 'multi', label: '多专家', title: '5 个专家并行分析后由终裁汇总,质量更高' },
+            ]}
+          />
+        </span>
+
+        <span className="ml-auto inline-flex items-center gap-3">
+          <span className="tabular-nums">共 {matches.length} 场</span>
+          <button onClick={load} disabled={loading} className="btn btn-sm">
+            {loading ? (<><Spinner /> 获取中</>) : '刷新'}
+          </button>
+        </span>
       </div>
 
+      {/* ── 错误提示 ── */}
       {error && (
-        <div className="bg-red-50 border border-red-200 text-red-700 px-4 py-2 rounded text-sm flex items-center justify-between">
-          <span>❌ {error}</span>
-          <button onClick={() => setError(null)} className="text-red-500 hover:text-red-700 text-xs">✕</button>
+        <div className="flex items-start justify-between gap-3 border border-press bg-press-wash px-4 py-3">
+          <div>
+            <p className="text-sm font-medium text-press">请求失败</p>
+            <p className="mt-0.5 text-xs text-ink-600">{error}</p>
+          </div>
+          <button onClick={() => setError(null)} className="text-ink-400 transition-colors hover:text-ink-900" aria-label="关闭">
+            <svg viewBox="0 0 20 20" className="h-4 w-4" fill="currentColor" aria-hidden="true">
+              <path d="M6.3 5.3a1 1 0 011.4 0L10 7.6l2.3-2.3a1 1 0 111.4 1.4L11.4 9l2.3 2.3a1 1 0 01-1.4 1.4L10 10.4l-2.3 2.3a1 1 0 01-1.4-1.4L8.6 9 6.3 6.7a1 1 0 010-1.4z" />
+            </svg>
+          </button>
         </div>
       )}
 
-      {/* 比赛表 */}
-      <div className="bg-white rounded border overflow-hidden">
-        <table className="w-full text-sm">
-          <thead className="bg-gray-100 text-gray-600">
-            <tr>
-              <th className="text-left px-4 py-2">日期</th>
-              <th className="text-left px-4 py-2">主队</th>
-              <th className="text-left px-4 py-2">客队</th>
-              <th className="text-center px-4 py-2">比分</th>
-              <th className="text-center px-4 py-2">状态</th>
-              <th className="text-center px-4 py-2">操作</th>
-            </tr>
-          </thead>
-          <tbody>
-            {loading && (
-              <tr><td colSpan={6} className="text-center text-gray-400 py-8">
-                <span className="inline-block animate-spin mr-2">⏳</span>加载中...
-              </td></tr>
-            )}
-            {!loading && matches.length === 0 && (
-              <tr><td colSpan={6} className="text-center text-gray-400 py-8">暂无数据,请先采集</td></tr>
-            )}
-            {matches.map(m => (
-              <tr key={m.id} className="border-t hover:bg-gray-50">
-                <td className="px-4 py-2 text-gray-600">{fmtDate(m.match_date)}</td>
-                <td className="px-4 py-2 font-medium">{m.home_team_zh || m.home_team}</td>
-                <td className="px-4 py-2 font-medium">{m.away_team_zh || m.away_team}</td>
-                <td className="px-4 py-2 text-center">
-                  {m.home_goals !== null ? `${m.home_goals} - ${m.away_goals}` : '-'}
-                </td>
-                <td className="px-4 py-2 text-center">
-                  <span className={`text-xs px-2 py-0.5 rounded ${
-                    m.match_status === 'finished' ? 'bg-green-100 text-green-700' :
-                    m.match_status === 'scheduled' ? 'bg-blue-100 text-blue-700' : 'bg-gray-100'
-                  }`}>
-                    {m.match_status === 'finished' ? '完赛' : m.match_status === 'scheduled' ? '未开赛' : m.match_status}
-                  </span>
-                </td>
-                <td className="px-4 py-2 text-center">
-                  <button onClick={() => predict(m.id)}
-                    disabled={predictingId === m.id}
-                    className="text-blue-600 hover:underline text-xs disabled:opacity-50">
-                    {predictingId === m.id ? '预测中...' : 'LLM 预测'}
+      {/* ── 赛程栏:表格化,行间细线 ── */}
+      <section aria-label="赛程">
+        {loading && <SkeletonRows n={4} />}
+
+        {!loading && matches.length === 0 && (
+          <div className="border-y border-ink-200 py-14 text-center">
+            <p className="font-serif text-sm text-ink-600">本版暂无赛程</p>
+            <p className="mt-1.5 text-xs text-ink-400">请先通过采集接口导入 {leagueName} 的比赛数据</p>
+          </div>
+        )}
+
+        {!loading && matches.map(m => {
+          const st = STATUS_META[m.match_status] ?? { label: m.match_status, cls: 'text-ink-400' }
+          const homeName = m.home_team_zh || m.home_team
+          const awayName = m.away_team_zh || m.away_team
+          const busy = predictingId === m.id
+          const active = predictionFor?.id === m.id
+
+          return (
+            <div
+              key={m.id}
+              className={`border-b border-ink-200 px-1 py-3 transition-colors hover:bg-paper-100 ${
+                active ? 'bg-press-wash/50' : ''
+              }`}
+            >
+              <div className="flex flex-col gap-2 sm:grid sm:grid-cols-[88px_minmax(0,1fr)_64px_minmax(0,1fr)_56px_auto] sm:items-center sm:gap-x-3 sm:gap-y-0">
+                {/* 日期 + 状态:移动端同行,桌面端日期单独归列 */}
+                <div className="flex items-center justify-between sm:contents">
+                  <span className="text-2xs tabular-nums text-ink-400">{fmtDate(m.match_date)}</span>
+                  <span className={`text-2xs sm:hidden ${st.cls}`}>{st.label}</span>
+                </div>
+
+                {/* 对阵:移动端主队/比分/客队同一行,桌面端 sm:contents 拆回 grid 列 */}
+                <div className="flex items-center gap-2 sm:contents">
+                  {/* 主队(右对齐) */}
+                  <div className="flex min-w-0 flex-1 items-center justify-end">
+                    <span className="truncate text-sm font-medium text-ink-900">{homeName}</span>
+                  </div>
+
+                  {/* 比分 / VS */}
+                  <div className="flex w-14 flex-shrink-0 flex-col items-center sm:w-auto">
+                    {m.home_goals !== null && m.away_goals !== null ? (
+                      <span className="font-serif text-base font-bold tabular-nums text-ink-900">
+                        {m.home_goals}<span className="mx-0.5 font-normal text-ink-300">:</span>{m.away_goals}
+                      </span>
+                    ) : (
+                      <span className="text-2xs tracking-widest text-ink-400">VS</span>
+                    )}
+                    {m.home_xg !== null && m.away_xg !== null && (
+                      <span className="text-2xs tabular-nums text-ink-400">
+                        xG {m.home_xg.toFixed(1)}-{m.away_xg.toFixed(1)}
+                      </span>
+                    )}
+                  </div>
+
+                  {/* 客队(左对齐) */}
+                  <div className="flex min-w-0 flex-1 items-center">
+                    <span className="truncate text-sm font-medium text-ink-900">{awayName}</span>
+                  </div>
+                </div>
+
+                {/* 状态列(桌面) */}
+                <span className={`hidden text-right text-2xs sm:block ${st.cls}`}>{st.label}</span>
+
+                {/* 预测按钮 */}
+                <div className="flex justify-end">
+                  <button
+                    onClick={() => predict(m)}
+                    disabled={busy}
+                    className="btn btn-sm w-[76px]"
+                    title={`以${mode === 'multi' ? '多专家' : '单次'}模式预测这场`}
+                  >
+                    {busy ? (<><Spinner /> 预测中</>) : '预测'}
                   </button>
-                </td>
-              </tr>
-            ))}
-          </tbody>
-        </table>
-      </div>
-
-      {/* 预测中指示 */}
-      {predictingId && (
-        <div className="bg-blue-50 border border-blue-200 text-blue-700 px-4 py-3 rounded text-sm flex items-center gap-2">
-          <span className="inline-block animate-spin">⏳</span>
-          LLM 预测中,请稍候...
-        </div>
-      )}
-
-      {/* 预测结果 */}
-      {prediction && (
-        <div className="bg-white rounded border p-5 space-y-3">
-          <h3 className="font-bold text-lg">🤖 LLM 预测结果</h3>
-          <div className="grid grid-cols-2 md:grid-cols-4 gap-4 text-sm">
-            <div className="bg-blue-50 rounded p-3">
-              <div className="text-gray-500 text-xs">主进球</div>
-              <div className="text-xl font-bold">{prediction.pred_home_goals ?? '-'}</div>
-            </div>
-            <div className="bg-blue-50 rounded p-3">
-              <div className="text-gray-500 text-xs">客进球</div>
-              <div className="text-xl font-bold">{prediction.pred_away_goals ?? '-'}</div>
-            </div>
-            <div className="bg-amber-50 rounded p-3">
-              <div className="text-gray-500 text-xs">胜平负</div>
-              <div className="text-xl font-bold">{prediction.pred_1x2 ?? '-'}</div>
-            </div>
-            <div className="bg-green-50 rounded p-3">
-              <div className="text-gray-500 text-xs">置信度</div>
-              <div className="text-xl font-bold">
-                {prediction.confidence !== null ? `${(prediction.confidence * 100).toFixed(0)}%` : '-'}
+                </div>
               </div>
             </div>
-          </div>
-          <div className="text-xs text-gray-400">
-            {prediction.provider} / {prediction.model} · 耗时 {prediction.latency_ms}ms
-            {prediction.mode === 'multi' && ' · 多 Agent 模式'}
-          </div>
+          )
+        })}
 
-          {/* 各专家 agent 报告 */}
-          {prediction.agent_outputs && prediction.agent_outputs.length > 0 && (
-            <div className="space-y-2">
-              <div className="text-sm font-medium text-gray-700">专家 Agent 报告</div>
-              {prediction.agent_outputs.map((r) => (
-                <details key={r.agent} className="bg-white border rounded">
-                  <summary className="cursor-pointer px-3 py-2 text-sm flex items-center justify-between">
-                    <span className="font-medium">
-                      {AGENT_LABELS[r.agent] || r.agent}
-                      {r.status !== 'ok' && (
-                        <span className={`ml-2 text-xs px-1.5 py-0.5 rounded ${
-                          r.status === 'no_data' ? 'bg-gray-100 text-gray-500' : 'bg-red-100 text-red-600'
-                        }`}>
-                          {r.status === 'no_data' ? '无数据' : '失败'}
-                        </span>
-                      )}
-                    </span>
-                    <span className="flex gap-3 text-xs text-gray-500">
-                      {r.home_edge !== null && (
-                        <span className={r.home_edge > 0 ? 'text-blue-600' : r.home_edge < 0 ? 'text-amber-600' : ''}>
-                          主队优势 {r.home_edge > 0 ? '+' : ''}{r.home_edge.toFixed(2)}
-                        </span>
-                      )}
-                      {r.confidence !== null && <span>信心 {(r.confidence * 100).toFixed(0)}%</span>}
-                      {r.probable_score && <span>比分 {r.probable_score}</span>}
-                    </span>
-                  </summary>
-                  <div className="px-3 pb-3 pt-1 space-y-2 text-sm">
-                    {r.analysis && <p className="text-gray-700">{r.analysis}</p>}
-                    {r.key_evidence.length > 0 && (
-                      <ul className="text-xs text-gray-500 list-disc pl-4">
-                        {r.key_evidence.map((e, i) => <li key={i}>{e}</li>)}
-                      </ul>
-                    )}
-                    {r.exp_home_goals !== null && r.exp_away_goals !== null && (
-                      <div className="text-xs text-gray-500">
-                        进球期望: {r.exp_home_goals.toFixed(1)} - {r.exp_away_goals.toFixed(1)}
-                      </div>
-                    )}
-                    <div className="text-xs text-gray-400">
-                      数据充分度 {r.data_sufficiency} · {r.model} · {r.latency_ms}ms
-                    </div>
-                  </div>
-                </details>
-              ))}
-            </div>
-          )}
+        {!loading && nextCursor && (
+          <div className="flex justify-center pt-4">
+            <button onClick={loadMore} disabled={loadingMore} className="btn btn-sm">
+              {loadingMore ? (<><Spinner /> 获取中</>) : '载入更多'}
+            </button>
+          </div>
+        )}
+      </section>
 
-          {prediction.reasoning && (
-            <div className="bg-gray-50 rounded p-3">
-              <div className="text-xs text-gray-500 mb-1">推理过程</div>
-              <div className="text-sm whitespace-pre-wrap">{prediction.reasoning}</div>
+      {/* ── 预测中占位 ── */}
+      {predictingId && !prediction && (
+        <div className="border border-ink-900">
+          <div className="flex items-center gap-2 border-b border-ink-900 bg-paper-100 px-4 py-2.5">
+            <Spinner className="text-press" />
+            <span className="text-sm font-medium text-ink-800">正在生成预测</span>
+            <span className="text-2xs text-ink-500">
+              {mode === 'multi' ? '五路专家并行分析后终裁,约需 20-60 秒' : '单次调用,约需 5-15 秒'}
+            </span>
+          </div>
+          <div className="space-y-4 px-4 py-6">
+            <div className="flex items-center justify-center gap-6">
+              <div className="skeleton h-4 w-20" />
+              <div className="skeleton h-10 w-24" />
+              <div className="skeleton h-4 w-20" />
             </div>
-          )}
-          <details className="text-xs">
-            <summary className="cursor-pointer text-gray-500 hover:text-gray-700">查看完整上下文</summary>
-            <pre className="mt-2 bg-gray-900 text-green-300 p-3 rounded overflow-x-auto text-xs">
-              {prediction.context}
-            </pre>
-          </details>
+            <div className="skeleton mx-auto h-px w-64" />
+            <div className="skeleton h-16 w-full" />
+          </div>
         </div>
       )}
+
+      {/* ── 预测版 ── */}
+      {prediction && predictionFor && (
+        <PredictionPanel prediction={prediction} match={predictionFor} mode={mode} />
+      )}
     </div>
   )
 }
+
+function PredictionPanel({
+  prediction,
+  match,
+  mode,
+}: {
+  prediction: Prediction
+  match: Match
+  mode: 'single' | 'multi'
+}) {
+  const homeName = match.home_team_zh || match.home_team
+  const awayName = match.away_team_zh || match.away_team
+  const okReports = (prediction.agent_outputs ?? []).filter(r => r.status === 'ok')
+
+  return (
+    <article className="border border-ink-900 bg-paper-50">
+      {/* 版头 */}
+      <div className="flex flex-wrap items-baseline justify-between gap-2 border-b border-ink-900 bg-paper-100 px-4 py-2.5 sm:px-5">
+        <h3 className="font-serif text-sm font-bold text-ink-900">
+          预测版 · {homeName} 对 {awayName}
+        </h3>
+        <span className="text-2xs tabular-nums text-ink-500">
+          {prediction.provider} / {prediction.model}
+          {prediction.latency_ms !== null && ` · ${(prediction.latency_ms / 1000).toFixed(1)}s`}
+        </span>
+      </div>
+
+      <div className="space-y-7 px-4 py-6 sm:px-5">
+        {/* ── 预测比分:版面核心,大号宋体 ── */}
+        <div className="text-center">
+          <p className="font-serif text-5xl font-bold tabular-nums leading-none text-ink-900 sm:text-6xl">
+            {prediction.pred_home_goals ?? '-'}
+            <span className="mx-3 font-normal text-ink-300">:</span>
+            {prediction.pred_away_goals ?? '-'}
+          </p>
+          <p className="mt-3 text-2xs tracking-[0.5em] text-ink-400">预测比分</p>
+        </div>
+
+        {/* ── 胜平负 ── */}
+        <div className="border-y border-ink-200 py-4">
+          <OutcomeLine pick={prediction.pred_1x2} confidence={prediction.subjective_confidence} />
+        </div>
+
+        {/* ── 元信息一行 ── */}
+        <p className="text-center text-2xs text-ink-500">
+          {mode === 'multi' ? `多专家模式 · ${okReports.length}/${prediction.agent_outputs?.length ?? 0} 路有效` : '单次模式'}
+          {prediction.prompt_version && ` · prompt ${prediction.prompt_version}`}
+          {prediction.latency_ms !== null && ` · 终裁耗时 ${(prediction.latency_ms / 1000).toFixed(1)} 秒`}
+        </p>
+
+        {/* ── 专家意见 ── */}
+        {prediction.agent_outputs && prediction.agent_outputs.length > 0 && (
+          <section>
+            <div className="section-head flex flex-wrap items-baseline justify-between gap-1">
+              <span>五路专家意见</span>
+              {prediction.agent_weights && (
+                <span className="font-sans text-2xs font-normal text-ink-500">
+                  终裁权重:{Object.entries(prediction.agent_weights)
+                    .sort((a, b) => b[1] - a[1])
+                    .map(([k, v]) => `${AGENT_LABELS[k] ?? k} ${Math.round(v * 100)}%`)
+                    .join(' / ')}
+                </span>
+              )}
+            </div>
+
+            <div>
+              {prediction.agent_outputs.map((r, i) => (
+                <AgentCard key={r.agent} report={r} no={CN_NUM[i] ?? String(i + 1)} />
+              ))}
+            </div>
+          </section>
+        )}
+
+        {/* ── 终裁意见:引文式,红竖线 ── */}
+        {prediction.reasoning && (
+          <section>
+            <h4 className="section-head mb-3">终裁意见</h4>
+            <blockquote className="border-l-2 border-press pl-4">
+              <p className="whitespace-pre-wrap font-serif text-sm leading-loose text-ink-700">
+                {prediction.reasoning}
+              </p>
+            </blockquote>
+          </section>
+        )}
+
+        {/* ── 原始上下文 ── */}
+        <details className="group">
+          <summary className="flex cursor-pointer list-none items-center gap-1.5 text-xs text-ink-500 transition-colors hover:text-ink-800">
+            <svg viewBox="0 0 20 20" className="h-3 w-3 transition-transform group-open:rotate-90" fill="currentColor" aria-hidden="true">
+              <path d="M7.3 5.3a1 1 0 011.4 0l4 4a1 1 0 010 1.4l-4 4a1 1 0 01-1.4-1.4L10.6 10 7.3 6.7a1 1 0 010-1.4z" />
+            </svg>
+            查看喂给模型的完整数据切片
+          </summary>
+          <pre className="mt-2 max-h-80 overflow-auto border border-ink-200 bg-paper-100 p-3 font-mono text-2xs leading-relaxed text-ink-600">
+            {prediction.context}
+          </pre>
+        </details>
+      </div>
+    </article>
+  )
+}
+
+const STATUS_BADGE: Record<string, { label: string; cls: string }> = {
+  ok: { label: '正常', cls: 'text-ink-500' },
+  no_data: { label: '无数据', cls: 'text-ink-400' },
+  error: { label: '调用失败', cls: 'text-press' },
+  parse_error: { label: '解析失败', cls: 'text-press' },
+}
+
+const SUFFICIENCY_LABEL: Record<string, string> = {
+  high: '充分',
+  medium: '一般',
+  low: '偏少',
+  none: '无',
+}
+
+/** 单路专家意见:汉字编号 + 细线行 */
+function AgentCard({ report: r, no }: { report: AgentReport; no: string }) {
+  const badge = STATUS_BADGE[r.status] ?? { label: r.status, cls: 'text-ink-400' }
+  const inactive = r.status !== 'ok'
+
+  return (
+    <details className="group border-b border-ink-200">
+      <summary className="flex cursor-pointer list-none items-baseline gap-2.5 px-1 py-3">
+        <span className="font-serif text-sm text-ink-400">{no}</span>
+        <span className="text-sm font-medium text-ink-900">{AGENT_LABELS[r.agent] ?? r.agent}</span>
+        <span className={`text-2xs ${badge.cls}`}>{badge.label}</span>
+
+        <span className="ml-auto flex items-baseline gap-3 text-2xs tabular-nums text-ink-500">
+          {r.status === 'ok' && r.subjective_confidence !== null && (
+            <span>信心 {Math.round(r.subjective_confidence * 100)}%</span>
+          )}
+          {r.status === 'ok' && r.probable_score && (
+            <span className="font-serif font-bold text-ink-800">{r.probable_score}</span>
+          )}
+          <svg viewBox="0 0 20 20" className="h-3 w-3 self-center text-ink-300 transition-transform group-open:rotate-90" fill="currentColor" aria-hidden="true">
+            <path d="M7.3 5.3a1 1 0 011.4 0l4 4a1 1 0 010 1.4l-4 4a1 1 0 01-1.4-1.4L10.6 10 7.3 6.7a1 1 0 010-1.4z" />
+          </svg>
+        </span>
+      </summary>
+
+      <div className="space-y-3 px-1 pb-4 pl-7">
+        {/* 无数据 / 失败时给出明确说明,避免用户以为是空白 bug */}
+        {inactive && (
+          <p className="text-xs leading-relaxed text-ink-500">
+            {r.status === 'no_data' && '该维度没有可用数据,已跳过 LLM 分析以节省额度(不影响其他专家)。'}
+            {r.status === 'error' && '该专家调用失败,本次结论未纳入其视角(fail-open 设计,不阻断整体预测)。'}
+            {r.status === 'parse_error' && '模型输出未通过格式校验,该报告已丢弃。'}
+          </p>
+        )}
+
+        {!inactive && r.home_edge !== null && (
+          <div>
+            <div className="mb-1.5 flex items-baseline justify-between text-2xs">
+              <span className="text-ink-500">主队优势</span>
+              <span className={`font-semibold tabular-nums ${r.home_edge > 0 ? 'text-press' : r.home_edge < 0 ? 'text-ink-700' : 'text-ink-500'}`}>
+                {r.home_edge > 0 ? '+' : ''}{r.home_edge.toFixed(2)}
+              </span>
+            </div>
+            <EdgeBar value={r.home_edge} />
+            <div className="mt-1 flex justify-between text-2xs text-ink-400">
+              <span>利客队</span>
+              <span>利主队</span>
+            </div>
+          </div>
+        )}
+
+        {r.analysis && (
+          <p className="font-serif text-sm leading-loose text-ink-700">{r.analysis}</p>
+        )}
+
+        {r.key_evidence.length > 0 && (
+          <ul className="space-y-1.5">
+            {r.key_evidence.map((e, i) => (
+              <li key={i} className="flex gap-2 text-xs leading-relaxed text-ink-600">
+                <span className="flex-shrink-0 text-ink-300" aria-hidden="true">—</span>
+                <span>{e}</span>
+              </li>
+            ))}
+          </ul>
+        )}
+
+        {r.exp_home_goals !== null && r.exp_away_goals !== null && (
+          <p className="text-xs text-ink-500">
+            进球期望 <span className="font-serif font-bold tabular-nums text-ink-900">{r.exp_home_goals.toFixed(1)} - {r.exp_away_goals.toFixed(1)}</span>
+          </p>
+        )}
+
+        {!inactive && (
+          <p className="border-t border-ink-100 pt-2.5 text-2xs text-ink-400">
+            数据充分度 {SUFFICIENCY_LABEL[r.data_sufficiency] ?? r.data_sufficiency}
+            <span className="mx-2 text-ink-200">|</span>
+            <span className="font-mono">{r.model}</span>
+            {r.latency_ms !== null && <span className="ml-2 tabular-nums">{r.latency_ms}ms</span>}
+          </p>
+        )}
+      </div>
+    </details>
+  )
+}

frontend/tailwind.config.js

@@ -1,6 +1,61 @@
 /** @type {import('tailwindcss').Config} */
 export default {
   content: ['./index.html', './src/**/*.{ts,tsx}'],
-  theme: { extend: {} },
+  theme: {
+    extend: {
+      colors: {
+        // 纸白:微暖底色,像新闻纸而不是纯白画布
+        paper: {
+          50: '#FDFCF8',
+          100: '#F7F4EC',
+          200: '#EDE9DE',
+          300: '#DDD7C7',
+        },
+        // 墨色:暖黑灰阶,替代冷调 slate
+        ink: {
+          50: '#FAF9F7',
+          100: '#F0EEE9',
+          200: '#E2DFD7',
+          300: '#C9C4B8',
+          400: '#9C9587',
+          500: '#6E675B',
+          600: '#524C42',
+          700: '#3B362E',
+          800: '#282420',
+          900: '#17140F',
+        },
+        // 印报红:全站唯一强调色,克制使用
+        press: {
+          DEFAULT: '#9E1B1B',
+          dark: '#7C1414',
+          wash: '#F7E9E4',
+        },
+      },
+      fontFamily: {
+        // 标题与比分:宋体血统,报纸版面的骨架
+        serif: [
+          'Georgia',
+          '"Times New Roman"',
+          '"Songti SC"',
+          'STSong',
+          'SimSun',
+          '"Noto Serif CJK SC"',
+          'serif',
+        ],
+        // 正文:中文黑体栈
+        sans: [
+          '"PingFang SC"',
+          '"Hiragino Sans GB"',
+          '"Microsoft YaHei"',
+          '"Noto Sans CJK SC"',
+          'sans-serif',
+        ],
+        mono: ['ui-monospace', 'SFMono-Regular', 'Menlo', 'Consolas', 'monospace'],
+      },
+      fontSize: {
+        '2xs': ['11px', { lineHeight: '16px' }],
+      },
+    },
+  },
   plugins: [],
 }

src/api/app.py

@@ -15,7 +15,7 @@ from src.core.config import settings
 async def lifespan(app: FastAPI) -> AsyncIterator[None]:
     from src.db.base import init_db
     from src.core.http_client import close_client
-    await init_db()
+    await init_db()  # 验证连接,不建表
     yield
     await close_client()
 
@@ -53,6 +53,18 @@ def create_app() -> FastAPI:
     async def health():
         return {"status": "healthy", "service": "profeto"}
 
+
+    @app.get("/health/ready")
+    async def health_ready():
+        """就绪检查: 验证数据库连接。"""
+        from src.db.base import engine
+        try:
+            async with engine.begin() as conn:
+                await conn.run_sync(lambda conn: None)
+            return {"status": "ready"}
+        except Exception:
+            return {"status": "not_ready"}
+
     return app
 
 

src/api/deps.py

@@ -0,0 +1,43 @@
+"""API 依赖:鉴权等横切关注点。
+
+审查报告 P2-7:ingest / backtest / settle 这类「写入型或高成本」接口此前
+完全无鉴权 —— 任何能访问到服务的人都可触发采集、或直接烧掉 LLM 额度。
+
+策略(渐进式,不破坏本地开发):
+  - `ADMIN_API_KEY` 未配置 → 直接放行,并打一次 warning。
+    这样本地 `docker compose up` 无需额外配置即可用。
+  - 已配置 → 必须带匹配的 `X-API-Key` 请求头,否则 401。
+"""
+from __future__ import annotations
+
+import logging
+import secrets
+
+from fastapi import Header, HTTPException
+
+from src.core.config import settings
+
+logger = logging.getLogger(__name__)
+
+_warned_unset = False
+
+
+async def require_admin_key(x_api_key: str | None = Header(None, alias="X-API-Key")) -> None:
+    """保护「写入型 / 高成本」接口的依赖。
+
+    用法: `@router.post("/ingest/bzzoiro", dependencies=[Depends(require_admin_key)])`
+    """
+    global _warned_unset
+
+    expected = settings.ADMIN_API_KEY
+    if not expected:
+        if not _warned_unset:
+            logger.warning(
+                "ADMIN_API_KEY 未设置,采集/回测接口当前【无鉴权】。"
+                "生产环境请设置该环境变量。"
+            )
+            _warned_unset = True
+        return
+
+    if not x_api_key or not secrets.compare_digest(x_api_key, expected):
+        raise HTTPException(status_code=401, detail="无效或缺失的 X-API-Key")

src/api/routes/backtest.py

@@ -1,11 +1,16 @@
 """回测路由。"""
 from __future__ import annotations
 
-from fastapi import APIRouter, HTTPException
+import logging
+
+from fastapi import APIRouter, Depends, HTTPException
 from pydantic import BaseModel, Field
 
+from src.api.deps import require_admin_key
 from src.llm.backtest import run_backtest
 
+logger = logging.getLogger(__name__)
+
 router = APIRouter(prefix="/api/v1", tags=["backtest"])
 
 
@@ -18,10 +23,13 @@ class BacktestRequest(BaseModel):
     model: str | None = Field(None, description="指定模型 (空=默认)")
 
 
-@router.post("/backtest")
+@router.post("/backtest", dependencies=[Depends(require_admin_key)])
 async def backtest(req: BacktestRequest):
     """对历史比赛运行回测。
 
+    该接口会对每场已完赛比赛各发起一次 LLM 预测,成本高 —— 因此需要
+    `X-API-Key` 鉴权(见审查报告 P2-7)。
+
     对每场已完赛比赛:
       1. 用比赛之前的数据构建上下文 (防未来信息泄漏)
       2. 调 LLM 预测
@@ -38,7 +46,8 @@ async def backtest(req: BacktestRequest):
             model=req.model,
         )
     except Exception as e:
-        raise HTTPException(500, f"backtest failed: {e}")
+        logger.exception("backtest failed")
+        raise HTTPException(500, "回测执行失败,请查看服务器日志")
 
     return {
         "summary": {
@@ -46,7 +55,7 @@ async def backtest(req: BacktestRequest):
             "scored": summary.scored,
             "accuracy_1x2": summary.accuracy_1x2,
             "avg_score_rmse": summary.avg_score_rmse,
-            "avg_confidence": summary.avg_confidence,
+            "avg_subjective_confidence": summary.avg_subjective_confidence,
             "calibration": summary.calibration,
         },
         "results": [
@@ -61,7 +70,7 @@ async def backtest(req: BacktestRequest):
                 "pred_home": r.pred_home,
                 "pred_away": r.pred_away,
                 "pred_1x2": r.pred_1x2,
-                "confidence": r.confidence,
+                "subjective_confidence": r.subjective_confidence,
                 "correct_1x2": r.correct_1x2,
             }
             for r in summary.results

src/api/routes/eval.py

@@ -1,23 +1,32 @@
 """评估路由。"""
 from __future__ import annotations
 
+import logging
+
 from fastapi import APIRouter, Depends, HTTPException
 
+from src.api.deps import require_admin_key
 from src.api.schemas import EvalSummaryOut, SettleRequest
 from src.db.base import AsyncSession, get_db, get_db_read
 from src.llm.eval import get_eval_summary, settle_prediction
 
+logger = logging.getLogger(__name__)
+
 router = APIRouter(prefix="/api/v1", tags=["eval"])
 
 
-@router.post("/eval/settle")
+@router.post("/eval/settle", dependencies=[Depends(require_admin_key)])
 async def settle(req: SettleRequest, db: AsyncSession = Depends(get_db)):
     """回填实际结果。"""
     try:
         pred = await settle_prediction(req.prediction_id, req.home_goals, req.away_goals)
         return {"id": pred.id, "settled": pred.settled}
     except ValueError as e:
-        raise HTTPException(404, str(e))
+        logger.warning("settle failed: %s", e)
+        raise HTTPException(404, "预测记录不存在")
+    except Exception as e:
+        logger.exception("settle error")
+        raise HTTPException(500, "回填失败,请查看服务器日志")
 
 
 @router.get("/eval/summary", response_model=EvalSummaryOut)

src/api/routes/ingest.py

@@ -1,56 +1,60 @@
 """采集路由。"""
 from __future__ import annotations
 
-from fastapi import APIRouter, HTTPException
+import logging
 
+from fastapi import APIRouter, Depends, HTTPException
+
+from src.api.deps import require_admin_key
 from src.api.schemas import IngestBzzoiroRequest, IngestResponse, IngestUnderstatRequest, IngestInjuriesRequest, IngestSimpleResponse
 from src.data.sources import get_source
 from src.data.injuries import ingest_injuries
-from src.db.base import AsyncSessionLocal
+from src.db.unit_of_work import get_uow
+
+logger = logging.getLogger(__name__)
 
 router = APIRouter(prefix="/api/v1", tags=["ingest"])
 
 
-@router.post("/ingest/bzzoiro", response_model=IngestResponse)
+@router.post("/ingest/bzzoiro", response_model=IngestResponse, dependencies=[Depends(require_admin_key)])
 async def ingest_bzzoiro_route(req: IngestBzzoiroRequest):
     """触发 bzzoiro 采集。"""
     source = get_source("bzzoiro")
-    async with AsyncSessionLocal() as db:
-        try:
+    try:
+        async with get_uow() as session:
             result = await source.ingest(
-                db,
+                session,
                 leagues=req.leagues,
                 date_from=req.date_from,
                 date_to=req.date_to,
                 status=req.status,
             )
-            await db.commit()
-            return IngestResponse(**result)
-        except Exception as e:
-            await db.rollback()
-            raise HTTPException(500, str(e))
+        return IngestResponse(**result)
+    except Exception as e:
+        logger.exception("bzzoiro ingest failed")
+        raise HTTPException(500, "数据采集失败,请查看服务器日志")
 
 
-@router.post("/ingest/understat", response_model=IngestSimpleResponse)
+@router.post("/ingest/understat", response_model=IngestSimpleResponse, dependencies=[Depends(require_admin_key)])
 async def ingest_understat_route(req: IngestUnderstatRequest):
     """触发 understat xG 回填。"""
     source = get_source("understat")
-    async with AsyncSessionLocal() as db:
-        try:
-            result = await source.ingest(db, league=req.league, season=req.season)
-            return IngestSimpleResponse(**result)
-        except Exception as e:
-            await db.rollback()
-            raise HTTPException(500, str(e))
+    try:
+        async with get_uow() as session:
+            result = await source.ingest(session, league=req.league, season=req.season)
+        return IngestSimpleResponse(**result)
+    except Exception as e:
+        logger.exception("understat ingest failed")
+        raise HTTPException(500, "xG 回填失败,请查看服务器日志")
 
 
-@router.post("/ingest/injuries", response_model=IngestSimpleResponse)
+@router.post("/ingest/injuries", response_model=IngestSimpleResponse, dependencies=[Depends(require_admin_key)])
 async def ingest_injuries_route(req: IngestInjuriesRequest):
     """触发伤停采集。"""
-    async with AsyncSessionLocal() as db:
-        try:
-            result = await ingest_injuries(db, date=req.date)
-            return IngestSimpleResponse(**result)
-        except Exception as e:
-            await db.rollback()
-            raise HTTPException(500, str(e))
+    try:
+        async with get_uow() as session:
+            result = await ingest_injuries(session, date=req.date)
+        return IngestSimpleResponse(**result)
+    except Exception as e:
+        logger.exception("injuries ingest failed")
+        raise HTTPException(500, "伤停采集失败,请查看服务器日志")

src/api/routes/predict.py

@@ -1,7 +1,9 @@
 """预测路由。"""
 from __future__ import annotations
 
-from fastapi import APIRouter, Depends, HTTPException
+import logging
+
+from fastapi import APIRouter, Depends, HTTPException, Query
 from sqlalchemy import select
 from sqlalchemy.orm import selectinload
 
@@ -10,6 +12,8 @@ from src.db.base import AsyncSession, get_db, get_db_read
 from src.db.models import Prediction
 from src.llm.predict import predict_match, PredictResult
 
+logger = logging.getLogger(__name__)
+
 router = APIRouter(prefix="/api/v1", tags=["predict"])
 
 
@@ -24,9 +28,14 @@ async def predict(req: PredictRequest, db: AsyncSession = Depends(get_db)):
             mode=req.mode,
         )
     except ValueError as e:
-        raise HTTPException(404, str(e))
+        logger.warning("predict validation error: %s", e)
+        raise HTTPException(404, "比赛不存在")
     except RuntimeError as e:
-        raise HTTPException(502, str(e))
+        logger.error("predict LLM error: %s", e)
+        raise HTTPException(502, "LLM 预测失败,请查看服务器日志")
+    except Exception as e:
+        logger.exception("predict unexpected error")
+        raise HTTPException(500, "预测失败,请查看服务器日志")
 
     # single / multi 两种结果统一映射
     return PredictOut(
@@ -38,7 +47,7 @@ async def predict(req: PredictRequest, db: AsyncSession = Depends(get_db)):
         pred_home_goals=result.pred_home_goals,
         pred_away_goals=result.pred_away_goals,
         pred_1x2=result.pred_1x2,
-        confidence=result.confidence,
+        subjective_confidence=result.subjective_confidence,
         reasoning=result.reasoning,
         agent_outputs=getattr(result, "agent_outputs", None),
         agent_weights=getattr(result, "agent_weights", None),
@@ -50,7 +59,7 @@ async def predict(req: PredictRequest, db: AsyncSession = Depends(get_db)):
 @router.get("/predictions", response_model=list[PredictionOut])
 async def list_predictions(
     match_id: int | None = None,
-    limit: int = 50,
+    limit: int = Query(50, ge=1, le=200),
     db: AsyncSession = Depends(get_db_read),
 ):
     stmt = select(Prediction).options(selectinload(Prediction.match))
@@ -69,7 +78,7 @@ async def list_predictions(
             pred_home_goals=p.pred_home_goals,
             pred_away_goals=p.pred_away_goals,
             pred_1x2=p.pred_1x2,
-            confidence=p.confidence,
+            subjective_confidence=p.subjective_confidence,
             reasoning=p.reasoning,
             agent_outputs=p.agent_outputs,
             created_at=p.created_at,
@@ -96,7 +105,7 @@ async def get_prediction(prediction_id: int, db: AsyncSession = Depends(get_db_r
         pred_home_goals=p.pred_home_goals,
         pred_away_goals=p.pred_away_goals,
         pred_1x2=p.pred_1x2,
-        confidence=p.confidence,
+        subjective_confidence=p.subjective_confidence,
         reasoning=p.reasoning,
         agent_outputs=p.agent_outputs,
         created_at=p.created_at,

src/api/schemas.py

@@ -54,7 +54,7 @@ class PredictOut(BaseModel):
     pred_home_goals: float | None
     pred_away_goals: float | None
     pred_1x2: str | None
-    confidence: float | None
+    subjective_confidence: float | None
     reasoning: str | None
     agent_outputs: list[dict] | None = None
     agent_weights: dict | None = None
@@ -72,7 +72,7 @@ class PredictionOut(BaseModel):
     pred_home_goals: float | None
     pred_away_goals: float | None
     pred_1x2: str | None
-    confidence: float | None
+    subjective_confidence: float | None
     reasoning: str | None
     agent_outputs: list[dict] | None = None
     created_at: datetime

src/core/config.py

@@ -33,5 +33,11 @@ class Settings(BaseSettings):
     # --- CORS ---
     CORS_ORIGINS: str = "http://localhost:5173,http://localhost:3000"
 
+    # --- 管理接口鉴权 ---
+    # 采集 / 回测等高成本或写入型接口需要此 Key(请求头 X-API-Key)。
+    # 留空表示「未启用鉴权」(本地开发默认),生产环境必须设置。
+    # 见审查报告 P2-7:ingest/backtest 无鉴权可被任意调用并烧掉 LLM 额度。
+    ADMIN_API_KEY: str = ""
+
 
 settings = Settings()

src/core/retry.py

@@ -1,4 +1,11 @@
-"""重试工具:带指数退避的瞬态错误重试。"""
+"""重试工具:带指数退避的瞬态错误重试。
+
+NOTE(审查报告 P3):当前全项目**无调用点** —— bzzoiro 在 `_fetch_json_sync`
+里自带了一套重试逻辑,understat/injuries 各自也有。这里保留是作为后续统一
+重试策略的落点,但请勿误以为它已在生效。
+
+如果决定不引入统一重试,建议删除本文件以避免"看起来有重试、实际没有"的误判。
+"""
 from __future__ import annotations
 
 import asyncio

src/data/bzzoiro.py

@@ -1,6 +1,7 @@
 """Bzzoiro 数据源:抓取 + 入库。
 
 迁移自旧项目 app/data/sources/bzzoiro/,改成 async + 简化入库。
+使用 Repository 模式进行数据访问,不直接控制事务。
 """
 from __future__ import annotations
 
@@ -13,19 +14,39 @@ import urllib.error
 import urllib.parse
 import urllib.request
 from collections.abc import Iterable
+from datetime import datetime, timezone
 
 from sqlalchemy import select
 
 from src.core.config import settings
 from src.data.config import BZZOIRO_LEAGUE_IDS, LEAGUE_COUNTRIES, LEAGUE_NAMES, REQUEST_INTERVAL
-from src.data.match_lookup import find_existing_match, get_or_create_team
 from src.data.normalize import normalize_bzzoiro
 from src.data.sources import register
-from src.db.models import League, Match, MatchStats
+from src.db.models import League, Match, MatchStats, Team
 
 logger = logging.getLogger(__name__)
 
 
+def _to_date(value):
+    """把 datetime / date / str 统一成 `date`。"""
+    if value is None:
+        return None
+    if hasattr(value, "date") and callable(value.date):
+        return value.date()
+    return value
+
+
+def _match_key(home_team_id: int, away_team_id: int, match_date) -> tuple[int, int, str]:
+    """比赛去重键:(主队, 客队, 天级日期 ISO 字符串)。
+
+    统一在这里构造,避免"预加载时用 str(date)、写入时用 isoformat()"这类
+    隐式格式依赖 —— 两者当前恰好相等,但一旦有人改动其一就会静默失配,
+    导致所有比赛被判为不存在而重复插入。
+    """
+    d = _to_date(match_date)
+    return (home_team_id, away_team_id, d.isoformat() if d is not None else "")
+
+
 def _fetch_json_sync(path: str, params: dict | None = None, max_retries: int = 3) -> dict | list:
     """同步 HTTP(bzzoiro 客户端保持同步,在 async 函数里 run_in_executor)。"""
     base = settings.BZZOIRO_BASE.rstrip("/")
@@ -125,7 +146,10 @@ class BzzoiroSource:
         date_to: str | None = None,
         status: str = "finished",
     ) -> dict:
-        """采集 bzzoiro → 入库。返回统计。"""
+        """采集 bzzoiro → 入库。返回统计。
+
+        注意: 本方法不控制事务(commit/rollback),由调用方通过 UnitOfWork 控制。
+        """
         result: dict = {"leagues": {}, "total_inserted": 0, "total_updated": 0, "errors": []}
 
         for code in leagues:
@@ -146,32 +170,70 @@ class BzzoiroSource:
                 db.add(league)
                 await db.flush()
 
-            for raw in raw_events:
-                try:
+            # === 批量优化: 预加载球队和已有比赛到内存 ===
+            team_name_to_id: dict[str, int] = {}
+            existing_matches: dict[tuple[int, int, str], Match] = {}  # 完整对象,避免重复查询
+            # (NormalizedMatch, 原始 event) 成对保存:后续写 source_record_id 时
+            # 必须用配对的那条 event,不能依赖外层循环变量残留值。
+            normalized_matches: list[tuple] = []
+
+            if raw_events:
+                # 一次遍历: 收集球队名 + 规范化
+                all_team_names = set()
+                for raw in raw_events:
                     nm = normalize_bzzoiro(raw, code)
-                    if nm is None:
-                        continue
-                    nm.validate()
-                except Exception as e:
-                    logger.debug("normalize skip: %s", e)
-                    league_r["errors"].append(f"normalize: {e}")
-                    continue
+                    if nm is not None:
+                        try:
+                            nm.validate()
+                        except Exception as e:
+                            logger.debug("normalize skip: %s", e)
+                            league_r["errors"].append(f"normalize: {e}")
+                            continue
+                        normalized_matches.append((nm, raw))
+                        all_team_names.add(nm.home_team)
+                        all_team_names.add(nm.away_team)
 
-                # 球队
-                home_team = await get_or_create_team(db, nm.home_team)
-                away_team = await get_or_create_team(db, nm.away_team)
+                if all_team_names:
+                    stmt = select(Team).where(Team.name.in_(all_team_names))
+                    teams = (await db.execute(stmt)).scalars().all()
+                    team_name_to_id = {t.name: t.id for t in teams}
 
-                # 查找已有比赛(天级匹配)
-                existing = await find_existing_match(db, league.id, nm.home_team, nm.away_team, nm.date)
+                # 预加载已有比赛(完整对象)
+                stmt = select(Match).where(Match.league_id == league.id)
+                for m in (await db.execute(stmt)).scalars():
+                    key = _match_key(m.home_team_id, m.away_team_id, m.match_date_date)
+                    existing_matches[key] = m
 
-                if existing is None:
+            for nm, raw in normalized_matches:
+                # 球队: 内存查找 + 按需创建
+                home_team_id = team_name_to_id.get(nm.home_team)
+                if home_team_id is None:
+                    home = Team(name=nm.home_team)
+                    db.add(home)
+                    await db.flush()
+                    home_team_id = home.id
+                    team_name_to_id[nm.home_team] = home_team_id
+
+                away_team_id = team_name_to_id.get(nm.away_team)
+                if away_team_id is None:
+                    away = Team(name=nm.away_team)
+                    db.add(away)
+                    await db.flush()
+                    away_team_id = away.id
+                    team_name_to_id[nm.away_team] = away_team_id
+
+                # 查找已有比赛: 内存查找
+                match_key = _match_key(home_team_id, away_team_id, nm.date)
+                existing_match = existing_matches.get(match_key)
+
+                if existing_match is None:
                     m = Match(
                         league_id=league.id,
                         season=nm.season_label or None,
-                        home_team_id=home_team.id,
-                        away_team_id=away_team.id,
+                        home_team_id=home_team_id,
+                        away_team_id=away_team_id,
                         match_date=nm.date,
-                        match_date_date=nm.date.date() if hasattr(nm.date, "date") else nm.date,
+                        match_date_date=_to_date(nm.date),
                         match_status=nm.match_status,
                         home_goals=nm.home_goals,
                         away_goals=nm.away_goals,
@@ -181,7 +243,9 @@ class BzzoiroSource:
                     )
                     db.add(m)
                     await db.flush()
+                    existing_matches[match_key] = m  # 防止同批重复
                     if nm.home_xg is not None or nm.away_xg is not None:
+                        now = datetime.now(timezone.utc)
                         stats = MatchStats(
                             match_id=m.id,
                             home_xg=nm.home_xg,
@@ -197,44 +261,54 @@ class BzzoiroSource:
                             away_yellow_cards=nm.away_yellow_cards,
                             home_red_cards=nm.home_red_cards,
                             away_red_cards=nm.away_red_cards,
+                            source="bzzoiro",
+                            source_event_id=str(raw.get("id", "")),
+                            retrieved_at=now,
+                            available_at=now,
                         )
                         db.add(stats)
                     league_r["inserted"] += 1
                 else:
-                    # 更新(只补空 / 状态升级)
+                    # 已有比赛: 直接从内存获取对象更新(无需再查询)
                     changed = False
-                    if existing.match_status != nm.match_status and nm.match_status == "finished":
-                        existing.match_status = nm.match_status
+                    if existing_match.match_status != nm.match_status and nm.match_status == "finished":
+                        existing_match.match_status = nm.match_status
                         changed = True
-                    if existing.home_goals is None and nm.home_goals is not None:
-                        existing.home_goals = nm.home_goals
-                        existing.away_goals = nm.away_goals
-                        existing.home_ht_goals = nm.home_ht_goals
-                        existing.away_ht_goals = nm.away_ht_goals
+                    if existing_match.home_goals is None and nm.home_goals is not None:
+                        existing_match.home_goals = nm.home_goals
+                        existing_match.away_goals = nm.away_goals
+                        existing_match.home_ht_goals = nm.home_ht_goals
+                        existing_match.away_ht_goals = nm.away_ht_goals
                         changed = True
-                    if existing.match_stage is None and nm.match_stage:
-                        existing.match_stage = nm.match_stage
+                    if existing_match.match_stage is None and nm.match_stage:
+                        existing_match.match_stage = nm.match_stage
                         changed = True
-                    # stats 只补空
-                    if existing.stats is None and (nm.home_xg is not None or nm.away_xg is not None):
-                        existing.stats = MatchStats(match_id=existing.id)
-                        db.add(existing.stats)
+                    if existing_match.stats is None and (nm.home_xg is not None or nm.away_xg is not None):
+                        now = datetime.now(timezone.utc)
+                        existing_match.stats = MatchStats(
+                            match_id=existing_match.id,
+                            source="bzzoiro",
+                            source_event_id=str(raw.get("id", "")),
+                            retrieved_at=now,
+                            available_at=now,
+                        )
+                        db.add(existing_match.stats)
                         await db.flush()
-                    if existing.stats is not None:
+                    if existing_match.stats is not None:
                         for fld in ("home_xg", "away_xg", "home_shots", "away_shots",
                                     "home_shots_on_target", "away_shots_on_target",
                                     "home_corners", "away_corners", "home_possession",
                                     "home_yellow_cards", "away_yellow_cards",
                                     "home_red_cards", "away_red_cards"):
-                            if getattr(existing.stats, fld, None) is None:
+                            if getattr(existing_match.stats, fld, None) is None:
                                 v = getattr(nm, fld, None)
                                 if v is not None:
-                                    setattr(existing.stats, fld, v)
+                                    setattr(existing_match.stats, fld, v)
                                     changed = True
                     if changed:
                         league_r["updated"] += 1
 
-            await db.commit()
+            # 注意: 不在此处 commit,由调用方 UnitOfWork 控制事务
             result["leagues"][code] = league_r
             result["total_inserted"] += league_r["inserted"]
             result["total_updated"] += league_r["updated"]

src/data/injuries.py

@@ -100,7 +100,10 @@ async def fetch_injuries(*, date: str | None = None, fixture_id: int | None = No
 
 
 async def ingest_injuries(db, *, date: str | None = None) -> dict:
-    """采集伤停数据并入库(injuries 表)。"""
+    """采集伤停数据并入库(injuries 表)。
+
+    注意: 本方法不控制事务(commit/rollback),由调用方通过 UnitOfWork 控制。
+    """
     from sqlalchemy import select
 
     from src.data.team_names import normalize as normalize_name
@@ -173,17 +176,27 @@ async def ingest_injuries(db, *, date: str | None = None) -> dict:
         except Exception as e:
             result["errors"].append(f"parse error: {e}")
 
-    await db.commit()
+    # 注意: 不在此处 commit,由调用方 UnitOfWork 控制事务
     logger.info("injuries: fetched %d, inserted %d for %s", result["count"], result["inserted"], date)
     return result
 
 
-async def get_injuries_for_match(db, team_id: int, match_date) -> list[Injury]:
-    """查询某场比赛前某队的伤停名单(比赛日仍缺阵的)。"""
-    from sqlalchemy import and_, or_, select
+async def get_injuries_for_match(db, team_id: int, match_date, as_of=None) -> list[Injury]:
+    """查询某场比赛前某队的伤停名单(比赛日仍缺阵的)。
+
+    Args:
+        db: 数据库 session
+        team_id: 球队 ID
+        match_date: 比赛日期
+        as_of: 截止时间(cutoff)。只返回 retrieved_at <= as_of 的记录。
+               用于回测时防止"未来采集的数据"泄漏到历史预测。
+               必须保持 timezone-aware datetime,不会截断为 date。
+    """
+    from sqlalchemy import or_, select
 
     from src.db.models import Injury
 
+    # 只处理 match_date:去掉时间部分,仅比较日期
     if hasattr(match_date, "date"):
         match_date = match_date.date()
 
@@ -192,7 +205,14 @@ async def get_injuries_for_match(db, team_id: int, match_date) -> list[Injury]:
         .where(Injury.team_id == team_id)
         .where(Injury.injury_date <= match_date)
         .where(or_(Injury.return_date.is_(None), Injury.return_date >= match_date))
-        .order_by(Injury.injury_date.desc())
     )
+
+    # 回测防泄漏: 只使用 as_of 时间点之前已采集的数据
+    # 注意: as_of 保持 datetime,不截断为 date,避免错误排除同日合法数据
+    if as_of is not None:
+        stmt = stmt.where(Injury.retrieved_at.is_not(None))
+        stmt = stmt.where(Injury.retrieved_at <= as_of)
+
+    stmt = stmt.order_by(Injury.injury_date.desc())
     result = await db.execute(stmt)
     return list(result.scalars().all())

src/data/match_lookup.py

@@ -1,40 +0,0 @@
-"""比赛匹配辅助函数(多数据源共用)。
-
-bzzoiro / understat 等数据源在入库时都需要:
-  - 按队名获取或创建球队(get_or_create_team)
-  - 按联赛+主队+客队+日期找已有比赛(find_existing_match)
-"""
-from __future__ import annotations
-
-from sqlalchemy import func, select
-
-from src.db.models import Match, Team
-
-
-async def get_or_create_team(db, name: str) -> Team:
-    """按名获取球队,不存在则创建。"""
-    stmt = select(Team).where(Team.name == name)
-    team = (await db.execute(stmt)).scalar_one_or_none()
-    if team is None:
-        team = Team(name=name)
-        db.add(team)
-        await db.flush()
-    return team
-
-
-async def find_existing_match(db, league_id: int, home_name: str, away_name: str, date) -> Match | None:
-    """按联赛+主队+客队+日期找已有比赛(天级匹配,避免时间精度差异)。"""
-    home_team = (await db.execute(select(Team).where(Team.name == home_name))).scalar_one_or_none()
-    away_team = (await db.execute(select(Team).where(Team.name == away_name))).scalar_one_or_none()
-    if home_team is None or away_team is None:
-        return None
-
-    date_only = date.date() if hasattr(date, "date") else date
-    stmt = (
-        select(Match)
-        .where(Match.league_id == league_id)
-        .where(Match.home_team_id == home_team.id)
-        .where(Match.away_team_id == away_team.id)
-        .where(func.date(Match.match_date) == date_only)
-    )
-    return (await db.execute(stmt)).scalar_one_or_none()

src/data/understat.py

@@ -1,6 +1,7 @@
 """Understat xG 数据源。
 
 迁移自旧项目 app/data/sources/understat.py,改成 async。
+使用 Repository 模式进行数据访问,不直接控制事务。
 """
 from __future__ import annotations
 
@@ -9,13 +10,15 @@ import json
 import logging
 import random
 import re
+from datetime import datetime, timezone
+
+from sqlalchemy import func, select
 
 from src.core.http_client import get_client
 from src.data.config import FDCO_TO_UNDERSTAT, LEAGUE_NAMES
-from src.data.match_lookup import find_existing_match
 from src.data.normalize import normalize_understat
 from src.data.sources import register
-from src.db.models import League, Match, MatchStats
+from src.db.models import League, Match, MatchStats, Team
 
 logger = logging.getLogger(__name__)
 
@@ -80,8 +83,11 @@ class UnderstatSource:
     name = "understat"
 
     async def ingest(self, db, *, league: str, season: int) -> dict:
-        """采集 understat xG → 回填到现有 Match。只回填 xG 字段,不创建新 Match。"""
-        from sqlalchemy import select
+        """采集 understat xG → 回填到现有 Match。只回填 xG 字段,不创建新 Match。
+
+        注意: 本方法不控制事务(commit/rollback),由调用方通过 UnitOfWork 控制。
+        """
+        from src.db.repositories import LeagueRepository, MatchRepository, TeamRepository
 
         result = {"updated": 0, "skipped": 0, "unmatched": 0, "errors": []}
 
@@ -92,9 +98,13 @@ class UnderstatSource:
             result["errors"].append(f"fetch failed: {e}")
             return result
 
+        # 使用 Repository
+        league_repo = LeagueRepository(db)
+        team_repo = TeamRepository(db)
+        match_repo = MatchRepository(db)
+
         # 查联赛
-        stmt = select(League).where(League.code == league)
-        league_obj = (await db.execute(stmt)).scalar_one_or_none()
+        league_obj = await league_repo.get_by_code(league)
         if league_obj is None:
             result["errors"].append(f"league {league} not found in DB")
             return result
@@ -111,15 +121,30 @@ class UnderstatSource:
                 result["errors"].append(f"normalize: {e}")
                 continue
 
-            # 匹配已有 Match(天级)
-            existing = await find_existing_match(db, league_obj.id, nm.home_team, nm.away_team, nm.date)
+            # 匹配已有 Match(天级) - 使用 Repository
+            home_team = await team_repo.get_by_name(nm.home_team)
+            away_team = await team_repo.get_by_name(nm.away_team)
+            if home_team is None or away_team is None:
+                result["unmatched"] += 1
+                continue
+
+            existing = await match_repo.find_by_teams_and_date(
+                league_obj.id, home_team.id, away_team.id, nm.date
+            )
             if existing is None:
                 result["unmatched"] += 1
                 continue
 
             # 回填 xG
             if existing.stats is None and (nm.home_xg is not None or nm.away_xg is not None):
-                existing.stats = MatchStats(match_id=existing.id)
+                now = datetime.now(timezone.utc)
+                existing.stats = MatchStats(
+                    match_id=existing.id,
+                    source="understat",
+                    source_event_id=str(raw.get("id", "")),
+                    retrieved_at=now,
+                    available_at=now,
+                )
                 db.add(existing.stats)
                 await db.flush()
             if existing.stats is not None:
@@ -129,5 +154,5 @@ class UnderstatSource:
                 if existing.stats.away_xg is None and nm.away_xg is not None:
                     existing.stats.away_xg = nm.away_xg
 
-        await db.commit()
+        # 注意: 不在此处 commit,由调用方 UnitOfWork 控制事务
         return result

src/db/base.py

@@ -53,6 +53,17 @@ async def get_db_read() -> AsyncIterator[AsyncSession]:
 
 
 async def init_db() -> None:
-    """开发/测试用:建表。生产建议用 alembic。"""
+    """验证数据库连接(不建表)。
+
+    生产环境 schema 由 Alembic 管理。
+    本地开发/测试需要建表时调用 `create_all()`。
+    """
+    async with engine.begin() as conn:
+        # 只验证连接,不自动建表
+        await conn.run_sync(lambda conn: None)
+
+
+async def create_all() -> None:
+    """创建所有表(仅用于本地开发/测试)。"""
     async with engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)

src/db/models.py

@@ -1,10 +1,11 @@
-"""5 张表 ORM: leagues / teams / matches / match_stats / predictions。"""
+"""6 张表 ORM: leagues / teams / matches / match_stats / predictions / injuries。"""
 from __future__ import annotations
 
 from datetime import date, datetime, timezone
 
 from sqlalchemy import (
     Boolean,
+    CheckConstraint,
     Date,
     DateTime,
     Float,
@@ -74,10 +75,20 @@ class Match(Base):
     created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_utcnow)
     updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_utcnow, onupdate=_utcnow)
 
-    league: Mapped[League] = relationship(back_populates="matches")
-    home_team: Mapped[Team] = relationship(foreign_keys=[home_team_id], back_populates="home_matches")
-    away_team: Mapped[Team] = relationship(foreign_keys=[away_team_id], back_populates="away_matches")
-    stats: Mapped["MatchStats | None"] = relationship(back_populates="match", cascade="all, delete-orphan")
+    league: Mapped[League] = relationship(back_populates="matches", lazy="selectin")
+    # lazy="selectin": 这些关系在业务里几乎总是一起读取(切片/回测/展示)。
+    # 默认的 lazy="select" 在 async SQLAlchemy 下,于 session 之外或未显式
+    # eager-load 时访问会抛 MissingGreenlet —— 已因此导致 form/stats/h2h
+    # 三个专家切片静默失败。统一改为预加载,从根上消除这类问题。
+    home_team: Mapped[Team] = relationship(
+        foreign_keys=[home_team_id], back_populates="home_matches", lazy="selectin"
+    )
+    away_team: Mapped[Team] = relationship(
+        foreign_keys=[away_team_id], back_populates="away_matches", lazy="selectin"
+    )
+    stats: Mapped["MatchStats | None"] = relationship(
+        back_populates="match", cascade="all, delete-orphan", lazy="selectin"
+    )
     predictions: Mapped[list["Prediction"]] = relationship(back_populates="match", cascade="all, delete-orphan")
 
     __table_args__ = (
@@ -114,9 +125,19 @@ class MatchStats(Base):
     home_red_cards: Mapped[int | None] = mapped_column(Integer)
     away_red_cards: Mapped[int | None] = mapped_column(Integer)
     updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_utcnow, onupdate=_utcnow)
+    # 数据血缘:追踪统计数据的来源和可用时间
+    source: Mapped[str | None] = mapped_column(String(30))  # bzzoiro / understat
+    source_record_id: Mapped[str | None] = mapped_column(String(100))
+    retrieved_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    available_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
 
     match: Mapped[Match] = relationship(back_populates="stats")
 
+    __table_args__ = (
+        # 数据血缘时间过滤查询用(按 available_at 取「赛前已可得」的统计)
+        Index("ix_match_stats_available_at", "available_at"),
+    )
+
 
 class Injury(Base):
     """球员伤停记录(api-football 数据源)。"""
@@ -156,12 +177,19 @@ class Prediction(Base):
     pred_home_goals: Mapped[float | None] = mapped_column(Float)
     pred_away_goals: Mapped[float | None] = mapped_column(Float)
     pred_1x2: Mapped[str | None] = mapped_column(String(3))
-    confidence: Mapped[float | None] = mapped_column(Float)
+    subjective_confidence: Mapped[float | None] = mapped_column(Float)  # LLM 主观置信度,非概率
     reasoning: Mapped[str | None] = mapped_column(Text)
     raw_response: Mapped[dict | None] = mapped_column(JSONB)
     # multi-agent 模式: 各专家报告
     mode: Mapped[str] = mapped_column(String(20), nullable=False, default="single")
     agent_outputs: Mapped[dict | None] = mapped_column(JSONB)
+    # 预测状态: success / failed / degraded
+    status: Mapped[str] = mapped_column(String(20), nullable=False, default="success")
+    # 时间语义:区分比赛时间、预测创建时间、数据截止时间
+    match_kickoff_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    prediction_created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_utcnow)
+    prediction_cutoff_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    input_hash: Mapped[str | None] = mapped_column(String(64))
     created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_utcnow)
     actual_home_goals: Mapped[int | None] = mapped_column(Integer)
     actual_away_goals: Mapped[int | None] = mapped_column(Integer)
@@ -172,4 +200,13 @@ class Prediction(Base):
     __table_args__ = (
         Index("ix_predictions_match", "match_id"),
         Index("ix_predictions_provider_model", "provider", "model"),
+        # 数据截止时间过滤查询用(按 prediction_cutoff_at 取「赛前已生成」的预测)
+        Index("ix_predictions_cutoff_at", "prediction_cutoff_at"),
+        # 数据库级约束:最后一道防线
+        CheckConstraint("pred_home_goals >= 0", name="ck_pred_home_goals_nonneg"),
+        CheckConstraint("pred_away_goals >= 0", name="ck_pred_away_goals_nonneg"),
+        CheckConstraint("subjective_confidence >= 0 AND subjective_confidence <= 1", name="ck_confidence_range"),
+        CheckConstraint("pred_1x2 IN ('1', 'X', '2')", name="ck_pred_1x2_enum"),
+        CheckConstraint("mode IN ('single', 'multi')", name="ck_mode_enum"),
+        CheckConstraint("status IN ('success', 'failed', 'degraded')", name="ck_status_enum"),
     )

src/db/repositories.py

@@ -0,0 +1,129 @@
+"""Repository 层:封装数据访问。
+
+Repository 只负责查询,不负责事务提交。
+事务由 Application Service 通过 UnitOfWork 控制。
+"""
+from __future__ import annotations
+
+from sqlalchemy import func, select
+from sqlalchemy.orm import selectinload
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.db.models import League, Match, Prediction, Team
+
+
+class MatchRepository:
+    """比赛数据访问。"""
+
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    async def get_by_id(self, match_id: int) -> Match | None:
+        return await self._session.get(Match, match_id)
+
+    async def get_with_relations(self, match_id: int) -> Match | None:
+        stmt = (
+            select(Match)
+            .options(
+                selectinload(Match.league),
+                selectinload(Match.home_team),
+                selectinload(Match.away_team),
+                selectinload(Match.stats),
+            )
+            .where(Match.id == match_id)
+        )
+        return (await self._session.execute(stmt)).scalar_one_or_none()
+
+    async def find_by_teams_and_date(
+        self, league_id: int, home_team_id: int, away_team_id: int, date
+    ) -> Match | None:
+        """按联赛+主队+客队+日期查找比赛(天级匹配)。
+
+        预加载 stats:调用方(understat 回填)会读取 existing.stats,
+        async session 下惰性加载会抛 MissingGreenlet。
+        """
+        if hasattr(date, "date"):
+            date = date.date()
+
+        stmt = (
+            select(Match)
+            .options(selectinload(Match.stats))
+            .where(Match.league_id == league_id)
+            .where(Match.home_team_id == home_team_id)
+            .where(Match.away_team_id == away_team_id)
+            .where(func.date(Match.match_date) == date)
+        )
+        return (await self._session.execute(stmt)).scalar_one_or_none()
+
+    async def add(self, match: Match) -> None:
+        self._session.add(match)
+        await self._session.flush()
+
+
+class TeamRepository:
+    """球队数据访问。"""
+
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    async def get_by_name(self, name: str) -> Team | None:
+        stmt = select(Team).where(Team.name == name)
+        return (await self._session.execute(stmt)).scalar_one_or_none()
+
+    async def get_or_create(self, name: str) -> Team:
+        """按名获取球队,不存在则创建。"""
+        team = await self.get_by_name(name)
+        if team is None:
+            team = Team(name=name)
+            self._session.add(team)
+            await self._session.flush()
+        return team
+
+    async def get_all_by_names(self, names: list[str]) -> dict[str, Team]:
+        """批量获取球队,返回 name → Team 映射。"""
+        if not names:
+            return {}
+        stmt = select(Team).where(Team.name.in_(names))
+        teams = (await self._session.execute(stmt)).scalars().all()
+        return {t.name: t for t in teams}
+
+    async def add(self, team: Team) -> None:
+        self._session.add(team)
+        await self._session.flush()
+
+
+class LeagueRepository:
+    """联赛数据访问。"""
+
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    async def get_by_code(self, code: str) -> League | None:
+        stmt = select(League).where(League.code == code)
+        return (await self._session.execute(stmt)).scalar_one_or_none()
+
+    async def get_or_create(self, code: str, name: str, country: str | None = None) -> League:
+        league = await self.get_by_code(code)
+        if league is None:
+            league = League(code=code, name=name, country=country)
+            self._session.add(league)
+            await self._session.flush()
+        return league
+
+    async def add(self, league: League) -> None:
+        self._session.add(league)
+        await self._session.flush()
+
+
+class PredictionRepository:
+    """预测记录数据访问。"""
+
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    async def get_by_id(self, prediction_id: int) -> Prediction | None:
+        return await self._session.get(Prediction, prediction_id)
+
+    async def add(self, prediction: Prediction) -> None:
+        self._session.add(prediction)
+        await self._session.flush()

src/db/unit_of_work.py

@@ -0,0 +1,33 @@
+"""工作单元(Unit of Work):统一事务边界。
+
+使用方式:
+    async with get_uow() as uow:
+        await uow.session.get(Match, 1)
+        await uow.commit()
+"""
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+
+from src.db.base import AsyncSessionLocal
+
+
+@asynccontextmanager
+async def get_uow() -> AsyncIterator[AsyncSessionLocal]:
+    """创建新的工作单元(用于非路由上下文)。
+
+    用法:
+        async with get_uow() as session:
+            await session.get(...)
+            # 退出时自动 commit(无异常) 或 rollback(有异常)
+    """
+    session = AsyncSessionLocal()
+    try:
+        yield session
+        await session.commit()
+    except Exception:
+        await session.rollback()
+        raise
+    finally:
+        await session.close()

src/llm/agents/base.py

@@ -12,7 +12,7 @@ import logging
 from dataclasses import dataclass, field
 from pathlib import Path
 
-from src.llm.context_builder import MatchHeader
+from src.llm.context_builder import MatchHeader, SliceResult
 from src.llm.provider import LLMProvider, LLMResponse
 
 logger = logging.getLogger(__name__)
@@ -48,7 +48,7 @@ class AgentReport:
     data_sufficiency: str = "medium"              # high | medium | low | none
     analysis: str = ""
     home_edge: float | None = None                # -1.0 ~ 1.0, 正=利主队
-    confidence: float | None = None               # 0.0 ~ 1.0
+    subjective_confidence: float | None = None               # 0.0 ~ 1.0
     key_evidence: list[str] = field(default_factory=list)
     # xg agent 专属
     exp_home_goals: float | None = None
@@ -67,7 +67,7 @@ class AgentReport:
             "data_sufficiency": self.data_sufficiency,
             "analysis": self.analysis,
             "home_edge": self.home_edge,
-            "confidence": self.confidence,
+            "subjective_confidence": self.subjective_confidence,
             "key_evidence": self.key_evidence,
             "exp_home_goals": self.exp_home_goals,
             "exp_away_goals": self.exp_away_goals,
@@ -80,7 +80,12 @@ class AgentReport:
 
 
 def _is_no_data(slice_text: str) -> bool:
-    """切片是否全无数据(除了标题行全是无数据)。"""
+    """兜底: 判断纯字符串切片是否全无数据。
+
+    仅用于 slice_fn 返回 `str`(未升级为 SliceResult)的场景。
+    新代码应让切片返回 SliceResult 并显式声明 has_data —— 字符串子串匹配
+    依赖具体文案(「无比分数据」「无伤停数据」等变体会漏判),不可靠。
+    """
     body = [ln.strip() for ln in slice_text.splitlines() if ln.strip()]
     # 去掉标题行(── 开头)
     content = [ln for ln in body if not ln.startswith("──")]
@@ -89,6 +94,18 @@ def _is_no_data(slice_text: str) -> bool:
     return all(any(s in ln for s in NO_DATA_SENTINELS) for ln in content)
 
 
+def _slice_has_data(slice_result) -> tuple[str, bool]:
+    """把切片返回值统一成 (text, has_data)。
+
+    优先使用 SliceResult.has_data(结构化,可信);若切片函数仍返回 str,
+    则回退到文案子串匹配(向后兼容)。
+    """
+    if isinstance(slice_result, SliceResult):
+        return slice_result.text, slice_result.has_data
+    text = str(slice_result)
+    return text, not _is_no_data(text)
+
+
 def _stub_no_data(agent: str) -> AgentReport:
     return AgentReport(
         agent=agent,
@@ -99,36 +116,34 @@ def _stub_no_data(agent: str) -> AgentReport:
 
 
 def _parse_report(agent: str, parsed: dict, resp: LLMResponse, model: str) -> AgentReport:
-    """把 LLM JSON 输出解析为 AgentReport,字段宽容处理。"""
-    def _f(v, default=None):
-        try:
-            return float(v) if v is not None else default
-        except (TypeError, ValueError):
-            return default
+    """把 LLM JSON 输出解析为 AgentReport,经过严格校验。"""
+    from src.llm.validation import validate_agent_output
 
-    suff = str(parsed.get("data_sufficiency", "medium")).lower()
-    if suff not in ("high", "medium", "low", "none"):
-        suff = "medium"
-
-    evidence = parsed.get("key_evidence") or []
-    if isinstance(evidence, str):
-        evidence = [evidence]
-
-    score = parsed.get("probable_score")
-    if isinstance(score, dict):
-        score = f"{score.get('home', '?')}-{score.get('away', '?')}"
+    try:
+        validated = validate_agent_output(parsed)
+    except Exception as e:
+        # 校验失败 → 返回 parse_error 而非静默降级
+        return AgentReport(
+            agent=agent,
+            status="parse_error",
+            analysis=f"输出校验失败: {e}",
+            model=model,
+            latency_ms=resp.latency_ms,
+            prompt_tokens=resp.prompt_tokens,
+            completion_tokens=resp.completion_tokens,
+        )
 
     return AgentReport(
         agent=agent,
         status="ok",
-        data_sufficiency=suff,
-        analysis=str(parsed.get("analysis", ""))[:600],
-        home_edge=_f(parsed.get("home_edge")),
-        confidence=_f(parsed.get("confidence")),
-        key_evidence=[str(e)[:120] for e in evidence[:5]],
-        exp_home_goals=_f(parsed.get("exp_home_goals")),
-        exp_away_goals=_f(parsed.get("exp_away_goals")),
-        probable_score=score if isinstance(score, str) else None,
+        data_sufficiency=validated.data_sufficiency,
+        analysis=validated.analysis,
+        home_edge=validated.home_edge,
+        subjective_confidence=validated.subjective_confidence,
+        key_evidence=validated.key_evidence,
+        exp_home_goals=validated.exp_home_goals,
+        exp_away_goals=validated.exp_away_goals,
+        probable_score=validated.probable_score,
         model=model,
         latency_ms=resp.latency_ms,
         prompt_tokens=resp.prompt_tokens,
@@ -147,13 +162,14 @@ async def run_agent(
     """执行单个专家 agent: 切片 → no_data 门控 → 调 LLM → 解析报告。"""
     # 1. 数据切片
     try:
-        slice_text = await spec.slice_fn(header, before=before)
+        slice_result = await spec.slice_fn(header, before=before)
     except Exception as e:
         logger.exception("agent %s slice failed", spec.name)
         return AgentReport(agent=spec.name, status="error", analysis=f"数据切片失败: {e}")
 
-    # 2. no_data 门控: 切片无数据 → 不调 LLM
-    if _is_no_data(slice_text):
+    # 2. no_data 门控: 切片显式声明无数据 → 不调 LLM
+    slice_text, has_data = _slice_has_data(slice_result)
+    if not has_data:
         logger.debug("agent %s: slice is no_data, skipping LLM", spec.name)
         return _stub_no_data(spec.name)
 

src/llm/agents/orchestrator.py

@@ -2,14 +2,17 @@
 from __future__ import annotations
 
 import asyncio
+import hashlib
 import json
 import logging
 import time
 from dataclasses import dataclass
+from datetime import datetime, timezone
 
 from src.core.config import settings
 from src.db.base import AsyncSessionLocal
 from src.db.models import Match, Prediction
+from src.db.unit_of_work import get_uow
 from src.llm.agents.base import AgentReport, AgentSpec, load_agent_prompt
 from src.llm.context_builder import (
     MatchHeader,
@@ -68,7 +71,7 @@ class MultiPredictResult:
     pred_home_goals: float | None
     pred_away_goals: float | None
     pred_1x2: str | None
-    confidence: float | None
+    subjective_confidence: float | None
     reasoning: str | None
     agent_outputs: list[dict]
     agent_weights: dict | None
@@ -164,6 +167,9 @@ async def predict_match_multi(
 
     # 1. 比赛头(各 agent 共享;不存在则 404)
     header = await load_match_header(match_id)
+    match_kickoff_at = header.match_dt
+    prediction_cutoff_at = header.match_dt  # 默认:比赛时间作为数据截止
+    now = datetime.now(timezone.utc)
 
     # 2. 并行专家
     specialist_provider = _get_specialist_provider()
@@ -177,13 +183,26 @@ async def predict_match_multi(
 
     latency_ms = int((time.perf_counter() - start) * 1000)
 
-    # 4. 存库
-    async with AsyncSessionLocal() as db:
-        m = await db.get(Match, match_id)
+    # 3.5 计算输入 hash(基于终裁报告)
+    input_hash = hashlib.sha256(
+        _reports_to_json(reports).encode("utf-8")
+    ).hexdigest()
+
+    # 4. 存库(使用 UnitOfWork)
+    async with get_uow() as session:
+        m = await session.get(Match, match_id)
         if m is None:
             raise ValueError(f"match {match_id} not found")
 
-        agent_weights = final.get("agent_weights")
+        # 严格校验终裁输出
+        from src.llm.validation import validate_agent_weights, validate_prediction_output
+        try:
+            validated = validate_prediction_output(final)
+        except Exception as e:
+            raise RuntimeError(f"终裁输出校验失败: {e}")
+
+        # agent_weights 同样必须过校验(旧实现直接取 raw 值落库,未做任何检查)
+        agent_weights = validate_agent_weights(final.get("agent_weights"))
         pred = Prediction(
             match_id=match_id,
             provider=settings.LLM_PROVIDER,
@@ -193,17 +212,21 @@ async def predict_match_multi(
             prompt_tokens=sum(r.prompt_tokens or 0 for r in reports) + agg_prompt_tokens,
             completion_tokens=sum(r.completion_tokens or 0 for r in reports) + agg_completion_tokens,
             latency_ms=latency_ms,
-            pred_home_goals=final.get("pred_home_goals"),
-            pred_away_goals=final.get("pred_away_goals"),
-            pred_1x2=final.get("1x2"),
-            confidence=final.get("confidence"),
-            reasoning=final.get("reasoning"),
+            pred_home_goals=validated.pred_home_goals,
+            pred_away_goals=validated.pred_away_goals,
+            pred_1x2=validated.pred_1x2,
+            subjective_confidence=validated.subjective_confidence,
+            reasoning=validated.reasoning,
             raw_response=final,
             agent_outputs=[r.to_dict() for r in reports],
+            status="success",
+            match_kickoff_at=match_kickoff_at,
+            prediction_cutoff_at=prediction_cutoff_at,
+            prediction_created_at=now,
+            input_hash=input_hash,
         )
-        db.add(pred)
-        await db.commit()
-        await db.refresh(pred)
+        session.add(pred)
+        await session.refresh(pred)
 
         return MultiPredictResult(
             prediction_id=pred.id,
@@ -214,7 +237,7 @@ async def predict_match_multi(
             pred_home_goals=pred.pred_home_goals,
             pred_away_goals=pred.pred_away_goals,
             pred_1x2=pred.pred_1x2,
-            confidence=pred.confidence,
+            subjective_confidence=pred.subjective_confidence,
             reasoning=pred.reasoning,
             agent_outputs=pred.agent_outputs,
             agent_weights=agent_weights,

src/llm/backtest.py

@@ -8,11 +8,13 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass, field
+from datetime import datetime
 
-from sqlalchemy import and_, select
+from sqlalchemy import select
+from sqlalchemy.orm import selectinload
 
-from src.db.base import AsyncSessionLocal
-from src.db.models import League, Match, Prediction
+from src.db.models import Match
+from src.db.unit_of_work import get_uow
 from src.llm.eval import settle_prediction
 from src.llm.predict import predict_match
 
@@ -33,11 +35,28 @@ class BacktestMatchResult:
     pred_home: float | None
     pred_away: float | None
     pred_1x2: str | None
-    confidence: float | None
+    subjective_confidence: float | None
     correct_1x2: bool
     prediction_id: int
 
 
+@dataclass
+class BacktestCandidate:
+    """回测候选比赛(字段快照,不持有 ORM 对象)。
+
+    session 关闭后仍可安全读取:所有需要的关系字段已在查询时物化为普通值,
+    避免在 session 之外访问惰性加载的关系属性(会抛 MissingGreenlet)。
+    """
+    match_id: int
+    league_code: str | None
+    home_team: str
+    away_team: str
+    match_date: datetime
+    home_goals: int
+    away_goals: int
+
+
+
 @dataclass
 class BacktestSummary:
     """回测汇总统计。"""
@@ -45,7 +64,7 @@ class BacktestSummary:
     scored: int
     accuracy_1x2: float | None = None
     avg_score_rmse: float | None = None
-    avg_confidence: float | None = None
+    avg_subjective_confidence: float | None = None
     calibration: list[dict] = field(default_factory=list)
     results: list[BacktestMatchResult] = field(default_factory=list)
 
@@ -66,10 +85,20 @@ async def _get_historical_matches(
     date_from: str | None = None,
     date_to: str | None = None,
     limit: int = 50,
-) -> list[Match]:
-    """查询已完赛且有比分的比赛(回测候选)。"""
+) -> list[BacktestCandidate]:
+    """查询已完赛且有比分的比赛(回测候选)。
+
+    返回普通值快照而非 ORM 对象:调用方在 session 关闭后仍需使用这些字段,
+    而 league / home_team / away_team 是惰性加载关系,在 async 下于 session
+    之外访问会抛 MissingGreenlet。这里用 selectinload 预加载后立即物化。
+    """
     stmt = (
         select(Match)
+        .options(
+            selectinload(Match.league),
+            selectinload(Match.home_team),
+            selectinload(Match.away_team),
+        )
         .where(Match.match_status == "finished")
         .where(Match.home_goals.is_not(None))
         .where(Match.away_goals.is_not(None))
@@ -83,7 +112,19 @@ async def _get_historical_matches(
 
     stmt = stmt.order_by(Match.match_date.desc()).limit(limit)
     result = await db.execute(stmt)
-    return list(result.scalars().all())
+    # 在 session 内物化为纯数据,切断与 ORM 会话的耦合
+    return [
+        BacktestCandidate(
+            match_id=m.id,
+            league_code=m.league.code if m.league else None,
+            home_team=m.home_team.name if m.home_team else "?",
+            away_team=m.away_team.name if m.away_team else "?",
+            match_date=m.match_date,
+            home_goals=m.home_goals,
+            away_goals=m.away_goals,
+        )
+        for m in result.scalars().all()
+    ]
 
 
 async def run_backtest(
@@ -108,45 +149,50 @@ async def run_backtest(
     Returns:
         BacktestSummary 含逐场结果 + 汇总统计
     """
-    async with AsyncSessionLocal() as db:
-        matches = await _get_historical_matches(
-            db, league_id=league_id, date_from=date_from, date_to=date_to, limit=limit
+    async with get_uow() as session:
+        candidates = await _get_historical_matches(
+            session, league_id=league_id, date_from=date_from, date_to=date_to, limit=limit
         )
 
-    summary = BacktestSummary(total=len(matches), scored=0)
+    summary = BacktestSummary(total=len(candidates), scored=0)
 
-    for m in matches:
+    for c in candidates:
         try:
-            # 预测 (build_context 内部已用 before=match_date 防泄漏)
-            result = await predict_match(m.id, mode=mode, model=model)
+            # 预测 (build_context 内部已用 before=match_date 防泄漏,
+            # injuries_slice 也使用 as_of=match_date 过滤 retrieved_at)
+            # 回测必须禁用结果缓存: 否则命中缓存会复用同一 prediction_id,
+            # 导致 settle 反复覆盖同一条记录(见 P1-3)。
+            result = await predict_match(c.match_id, mode=mode, model=model, use_cache=False)
 
             # 用实际比分 settle
-            await settle_prediction(result.prediction_id, m.home_goals, m.away_goals)
+            await settle_prediction(result.prediction_id, c.home_goals, c.away_goals)
 
-            actual = _actual_1x2(m.home_goals, m.away_goals)
+            actual = _actual_1x2(c.home_goals, c.away_goals)
             correct = result.pred_1x2 == actual
 
             bt = BacktestMatchResult(
-                match_id=m.id,
-                league_code=m.league.code if m.league else None,
-                home_team=m.home_team.name if m.home_team else "?",
-                away_team=m.away_team.name if m.away_team else "?",
-                match_date=m.match_date.strftime("%Y-%m-%d") if m.match_date else "?",
-                actual_home=m.home_goals,
-                actual_away=m.away_goals,
+                match_id=c.match_id,
+                league_code=c.league_code,
+                home_team=c.home_team,
+                away_team=c.away_team,
+                match_date=c.match_date.strftime("%Y-%m-%d") if c.match_date else "?",
+                actual_home=c.home_goals,
+                actual_away=c.away_goals,
                 actual_1x2=actual,
                 pred_home=result.pred_home_goals,
                 pred_away=result.pred_away_goals,
                 pred_1x2=result.pred_1x2,
-                confidence=result.confidence,
+                subjective_confidence=result.subjective_confidence,
                 correct_1x2=correct,
                 prediction_id=result.prediction_id,
             )
             summary.results.append(bt)
             summary.scored += 1
 
-        except Exception as e:
-            logger.warning("backtest match %s failed: %s", m.id, e)
+        except Exception:
+            # 用 exception 而非 warning:保留堆栈,否则集成层缺陷(如惰性加载
+            # 在 session 外触发)会只剩一行无堆栈的 warning,极难定位。
+            logger.exception("backtest match %s failed", c.match_id)
 
     # 汇总统计
     if summary.scored > 0:
@@ -162,10 +208,10 @@ async def run_backtest(
         if errors:
             summary.avg_score_rmse = round(sum(errors) / len(errors), 2)
 
-        # 平均置信度
-        confs = [r.confidence for r in summary.results if r.confidence is not None]
+        # 平均主观置信度
+        confs = [r.subjective_confidence for r in summary.results if r.subjective_confidence is not None]
         if confs:
-            summary.avg_confidence = round(sum(confs) / len(confs), 2)
+            summary.avg_subjective_confidence = round(sum(confs) / len(confs), 2)
 
         # 校准:按置信度分桶,看实际准确率是否匹配
         summary.calibration = _compute_calibration(summary.results)
@@ -183,11 +229,11 @@ def _compute_calibration(results: list[BacktestMatchResult]) -> list[dict]:
         "0.0-0.3": {"range": (0.0, 0.3), "total": 0, "correct": 0},
     }
     for r in results:
-        if r.confidence is None:
+        if r.subjective_confidence is None:
             continue
         for key, b in buckets.items():
             lo, hi = b["range"]
-            if lo <= r.confidence <= hi:
+            if lo <= r.subjective_confidence <= hi:
                 b["total"] += 1
                 if r.correct_1x2:
                     b["correct"] += 1

src/llm/context_builder.py

@@ -30,12 +30,38 @@ def _outcome(home_goals: int, away_goals: int, side: str) -> str:
     return "W" if away_goals > home_goals else ("D" if away_goals == home_goals else "L")
 
 
+def _is_stats_available(stats, before) -> bool:
+    """检查统计数据在 cutoff 时间是否已可用。"""
+    if before is None:
+        return True
+    if stats.available_at is None:
+        return True  # 无时间信息时保守处理:允许使用
+    return stats.available_at <= before
+
+
+@dataclass
+class SliceResult:
+    """数据切片的显式结果(替代「靠文案子串猜有无数据」)。
+
+    旧实现用 `"无数据" in slice_text` 判断,依赖具体文案 —— 一旦某个切片
+    写成「无比分数据」「无伤停数据」这类变体,判断就会静默失配
+    (见审查报告 P2-1)。这里让切片函数直接声明 `has_data`,不再猜。
+    """
+    text: str
+    has_data: bool
+    n_records: int = 0
+
+    def __str__(self) -> str:  # 让老调用点可直接当 str 用
+        return self.text
+
+
 @dataclass
 class MatchContext:
     match_id: int
     text: str
     has_stats: bool
     has_injuries: bool
+    match_dt: object | None = None  # 比赛时间(回测防泄漏 + 快照用)
 
 
 @dataclass
@@ -88,16 +114,18 @@ def header_text(h: MatchHeader) -> str:
 # 切片函数: 每个领域 agent 一个
 # ============================================================
 
-async def h2h_slice(header: MatchHeader, *, limit: int = 8, before=None) -> str:
+async def h2h_slice(header: MatchHeader, *, limit: int = 8, before=None) -> SliceResult:
     """E - 历史交锋切片: 过去数年 + 近期交手数据,提取交手规律。before=match_date 用于回测。"""
     async with AsyncSessionLocal() as db:
         h2h = await _get_h2h(db, header.home_team_id, header.away_team_id, before=before, limit=limit)
     lines = [f"── 历史交锋(近 {limit} 次) ──"]
+    n_with_score = 0
     if h2h:
         home_wins = draws = away_wins = 0
         for hm in h2h:
             d = hm.match_date.strftime("%Y-%m") if hm.match_date else "?"
             if hm.home_goals is not None:
+                n_with_score += 1
                 if hm.home_goals > hm.away_goals: home_wins += 1
                 elif hm.home_goals == hm.away_goals: draws += 1
                 else: away_wins += 1
@@ -109,15 +137,17 @@ async def h2h_slice(header: MatchHeader, *, limit: int = 8, before=None) -> str:
             lines.append(f"  总计 {total} 场: 主队 {home_wins}胜 {draws}平 {away_wins}负")
     else:
         lines.append("  无数据")
-    return "\n".join(lines)
+    # has_data 以「有比分的交锋」为准:仅有对阵无比分时不足以支撑分析
+    return SliceResult(text="\n".join(lines), has_data=n_with_score > 0, n_records=n_with_score)
 
 
-async def form_slice(header: MatchHeader, *, limit: int = 5, before=None) -> str:
+async def form_slice(header: MatchHeader, *, limit: int = 5, before=None) -> SliceResult:
     """A - 近期状态切片: 两队近 N 场赛果、关键事件、走势判断。before=match_date 用于回测。"""
     async with AsyncSessionLocal() as db:
         home_form = await _get_form(db, header.home_team_id, before=before, limit=limit)
         away_form = await _get_form(db, header.away_team_id, before=before, limit=limit)
     lines = []
+    n_scored = 0
     for label, name, form, side in (
         ("主队", header.home_name, home_form, "home"),
         ("客队", header.away_name, away_form, "away"),
@@ -130,9 +160,11 @@ async def form_slice(header: MatchHeader, *, limit: int = 5, before=None) -> str
                 if o == "W": wins += 1
                 elif o == "D": draws += 1
                 else: losses += 1
+                if fm.home_goals is not None:
+                    n_scored += 1
                 score = f"{fm.home_goals}-{fm.away_goals}" if fm.home_goals is not None else "vs"
                 xg = ""
-                if fm.stats and fm.stats.home_xg is not None:
+                if fm.stats and _is_stats_available(fm.stats, before) and fm.stats.home_xg is not None:
                     own = fm.stats.home_xg if side == "home" else fm.stats.away_xg
                     xg = f" (xG {own:.1f})"
                 opp = fm.away_team.name if side == "home" else fm.home_team.name
@@ -140,15 +172,16 @@ async def form_slice(header: MatchHeader, *, limit: int = 5, before=None) -> str
             lines.append(f"  近 {len(form)} 场: {wins}胜 {draws}平 {losses}负")
         else:
             lines.append("  无数据")
-    return "\n".join(lines)
+    return SliceResult(text="\n".join(lines), has_data=n_scored > 0, n_records=n_scored)
 
 
-async def stats_slice(header: MatchHeader, *, limit: int = 10, before=None) -> str:
+async def stats_slice(header: MatchHeader, *, limit: int = 10, before=None) -> SliceResult:
     """B - 攻防数据切片: 进球、射门、控球,评估攻防强度。before=match_date 用于回测。"""
     async with AsyncSessionLocal() as db:
         home_form = await _get_form(db, header.home_team_id, before=before, limit=limit)
         away_form = await _get_form(db, header.away_team_id, before=before, limit=limit)
     lines = [f"── 攻防数据(近 {limit} 场) ──"]
+    n_total = 0
     for label, name, form, side in (
         ("主队", header.home_name, home_form, "home"),
         ("客队", header.away_name, away_form, "away"),
@@ -161,7 +194,8 @@ async def stats_slice(header: MatchHeader, *, limit: int = 10, before=None) -> s
                 gf += fm.home_goals if side == "home" else fm.away_goals
                 ga += fm.away_goals if side == "home" else fm.home_goals
                 n += 1
-                if fm.stats:
+                # 只使用 cutoff 之前已可用的统计数据
+                if fm.stats and _is_stats_available(fm.stats, before):
                     if fm.stats.home_shots is not None:
                         shots += fm.stats.home_shots if side == "home" else fm.stats.away_shots
                         sot += fm.stats.home_shots_on_target if side == "home" else fm.stats.away_shots_on_target
@@ -173,6 +207,7 @@ async def stats_slice(header: MatchHeader, *, limit: int = 10, before=None) -> s
                         xg += fm.stats.home_xg if side == "home" else fm.stats.away_xg
                         xga += fm.stats.away_xg if side == "home" else fm.stats.home_xg
                         n_xg += 1
+            n_total += n
             if n > 0:
                 lines.append(f"  {label} {name}:")
                 lines.append(f"    场均进球 {gf/n:.2f}, 场均失球 {ga/n:.2f}")
@@ -183,15 +218,16 @@ async def stats_slice(header: MatchHeader, *, limit: int = 10, before=None) -> s
                 lines.append(f"  {label} {name}: 无比分数据")
         else:
             lines.append(f"  {label} {name}: 无数据")
-    return "\n".join(lines)
+    return SliceResult(text="\n".join(lines), has_data=n_total > 0, n_records=n_total)
 
 
-async def home_away_slice(header: MatchHeader, *, limit: int = 10, before=None) -> str:
+async def home_away_slice(header: MatchHeader, *, limit: int = 10, before=None) -> SliceResult:
     """C - 主客因素切片: 主场战绩 vs 客场战绩,评估地理优势影响。before=match_date 用于回测。"""
     async with AsyncSessionLocal() as db:
         home_home = await _get_home_away(db, header.home_team_id, "home", before=before, limit=limit)
         away_away = await _get_home_away(db, header.away_team_id, "away", before=before, limit=limit)
     lines = ["── 主客因素 ──"]
+    n_total = 0
     for label, name, matches, side in (
         ("主队主场", header.home_name, home_home, "home"),
         ("客队客场", header.away_name, away_away, "away"),
@@ -207,6 +243,7 @@ async def home_away_slice(header: MatchHeader, *, limit: int = 10, before=None)
                 gf += m.home_goals if side == "home" else m.away_goals
                 ga += m.away_goals if side == "home" else m.home_goals
             n = wins + draws + losses
+            n_total += n
             if n > 0:
                 pct = wins / n * 100
                 lines.append(f"  {label} {name}(近 {n} 场): {wins}胜 {draws}平 {losses}负, 胜率 {pct:.0f}%")
@@ -215,22 +252,26 @@ async def home_away_slice(header: MatchHeader, *, limit: int = 10, before=None)
                 lines.append(f"  {label} {name}: 无比分数据")
         else:
             lines.append(f"  {label} {name}: 无数据")
-    return "\n".join(lines)
+    return SliceResult(text="\n".join(lines), has_data=n_total > 0, n_records=n_total)
 
 
-async def injuries_slice(header: MatchHeader, *, before=None) -> str:
-    """D - 阵容完整性切片: 伤停与停赛名单,评估战力缺失程度。"""
+async def injuries_slice(header: MatchHeader, *, before=None) -> SliceResult:
+    """D - 阵容完整性切片: 伤停与停赛名单,评估战力缺失程度。
+
+    before=cutoff: 只使用 cutoff 之前已采集的伤停数据,防回测泄漏。
+    """
     from src.data.injuries import get_injuries_for_match
 
+    cutoff = before or header.match_dt
     async with AsyncSessionLocal() as db:
-        home_injuries = await get_injuries_for_match(db, header.home_team_id, before or header.match_dt)
-        away_injuries = await get_injuries_for_match(db, header.away_team_id, before or header.match_dt)
+        home_injuries = await get_injuries_for_match(db, header.home_team_id, cutoff, as_of=cutoff)
+        away_injuries = await get_injuries_for_match(db, header.away_team_id, cutoff, as_of=cutoff)
 
     lines = ["── 阵容完整性 ──"]
-    has_data = False
+    n_records = 0
     for label, injuries in (("主队", home_injuries), ("客队", away_injuries)):
         if injuries:
-            has_data = True
+            n_records += len(injuries)
             lines.append(f"  {label}伤停({len(injuries)}人):")
             for inj in injuries[:8]:  # 最多显示 8 条
                 reason = inj.reason or inj.injury_type or "未知"
@@ -240,10 +281,10 @@ async def injuries_slice(header: MatchHeader, *, before=None) -> str:
         else:
             lines.append(f"  {label}: 无伤停数据")
 
-    if not has_data:
-        return "── 阵容完整性 ──\n  无数据"
+    if n_records == 0:
+        return SliceResult(text="── 阵容完整性 ──\n  无数据", has_data=False, n_records=0)
 
-    return "\n".join(lines)
+    return SliceResult(text="\n".join(lines), has_data=True, n_records=n_records)
 
 
 # ============================================================
@@ -251,42 +292,39 @@ async def injuries_slice(header: MatchHeader, *, before=None) -> str:
 # ============================================================
 
 async def build_context(match_id: int, *, form_last: int = 5, h2h_last: int = 5) -> MatchContext:
-    """单 agent 路径的完整上下文: 拼接全部切片(before=比赛时间,防未来信息)。"""
+    """单 agent 路径的完整上下文: 拼接全部切片(before=比赛时间,防未来信息)。
+
+    has_stats / has_injuries 直接取切片显式声明的 has_data,
+    不再靠文案子串匹配(见审查报告 P2-1)。
+    """
     header = await load_match_header(match_id)
     parts = [header_text(header), ""]
-    has_stats = False
-    has_injuries = False
 
-    form_text = await form_slice(header, limit=form_last, before=header.match_dt)
-    if "无数据" not in form_text:
-        has_stats = True
-    parts.append(form_text)
+    form_res = await form_slice(header, limit=form_last, before=header.match_dt)
+    parts.append(form_res.text)
     parts.append("")
 
-    h2h_text = await h2h_slice(header, limit=h2h_last, before=header.match_dt)
-    parts.append(h2h_text)
+    h2h_res = await h2h_slice(header, limit=h2h_last, before=header.match_dt)
+    parts.append(h2h_res.text)
     parts.append("")
 
-    stats_text = await stats_slice(header, before=header.match_dt)
-    if "无数据" not in stats_text:
-        has_stats = True
-    parts.append(stats_text)
+    stats_res = await stats_slice(header, before=header.match_dt)
+    parts.append(stats_res.text)
     parts.append("")
 
-    home_away_text = await home_away_slice(header, before=header.match_dt)
-    parts.append(home_away_text)
+    home_away_res = await home_away_slice(header, before=header.match_dt)
+    parts.append(home_away_res.text)
     parts.append("")
 
-    injuries_text = await injuries_slice(header, before=header.match_dt)
-    if "无数据" not in injuries_text:
-        has_injuries = True
-    parts.append(injuries_text)
+    injuries_res = await injuries_slice(header, before=header.match_dt)
+    parts.append(injuries_res.text)
 
     return MatchContext(
         match_id=match_id,
         text="\n".join(parts),
-        has_stats=has_stats,
-        has_injuries=has_injuries,
+        has_stats=form_res.has_data or stats_res.has_data,
+        has_injuries=injuries_res.has_data,
+        match_dt=header.match_dt,
     )
 
 
@@ -312,9 +350,19 @@ async def _load_match(db, match_id: int) -> Match:
 
 
 async def _get_form(db, team_id: int, before, *, limit: int = 5) -> list[Match]:
-    """某队近 N 场(已完赛)。before=None 表示不限制(预测赛前的场景由调用方保证)。"""
+    """某队近 N 场(已完赛)。before=None 表示不限制(预测赛前的场景由调用方保证)。
+
+    必须预加载 stats / home_team / away_team:切片函数会读取这些关系,
+    而 async session 下惰性加载会抛 MissingGreenlet。
+    (models.py 已声明 lazy="selectin",此处显式声明以固化查询意图。)
+    """
     stmt = (
         select(Match)
+        .options(
+            selectinload(Match.stats),
+            selectinload(Match.home_team),
+            selectinload(Match.away_team),
+        )
         .where(Match.match_status == "finished")
         .where(Match.home_goals.is_not(None))
         .where((Match.home_team_id == team_id) | (Match.away_team_id == team_id))
@@ -328,9 +376,13 @@ async def _get_form(db, team_id: int, before, *, limit: int = 5) -> list[Match]:
 
 
 async def _get_h2h(db, home_id: int, away_id: int, before, *, limit: int = 5) -> list[Match]:
-    """两队交锋史。"""
+    """两队交锋史。需预加载 home_team / away_team(切片输出队名)。"""
     stmt = (
         select(Match)
+        .options(
+            selectinload(Match.home_team),
+            selectinload(Match.away_team),
+        )
         .where(Match.match_status == "finished")
         .where(Match.home_goals.is_not(None))
         .where(
@@ -347,9 +399,17 @@ async def _get_h2h(db, home_id: int, away_id: int, before, *, limit: int = 5) ->
 
 
 async def _get_home_away(db, team_id: int, side: str, before, *, limit: int = 10) -> list[Match]:
-    """某队主场/客场近 N 场。side='home' 取主场,'away' 取客场。"""
+    """某队主场/客场近 N 场。side='home' 取主场,'away' 取客场。
+
+    当前只用标量字段,但统一预加载以免后续扩展时踩坑。
+    """
     stmt = (
         select(Match)
+        .options(
+            selectinload(Match.stats),
+            selectinload(Match.home_team),
+            selectinload(Match.away_team),
+        )
         .where(Match.match_status == "finished")
         .where(Match.home_goals.is_not(None))
         .order_by(Match.match_date.desc())

src/llm/eval.py

@@ -5,23 +5,21 @@ import logging
 
 from sqlalchemy import select
 
-from src.db.base import AsyncSessionLocal
 from src.db.models import Prediction
+from src.db.unit_of_work import get_uow
 
 logger = logging.getLogger(__name__)
 
 
 async def settle_prediction(prediction_id: int, home_goals: int, away_goals: int) -> Prediction:
     """回填实际结果。"""
-    async with AsyncSessionLocal() as db:
-        pred = await db.get(Prediction, prediction_id)
+    async with get_uow() as session:
+        pred = await session.get(Prediction, prediction_id)
         if pred is None:
             raise ValueError(f"prediction {prediction_id} not found")
         pred.actual_home_goals = home_goals
         pred.actual_away_goals = away_goals
         pred.settled = True
-        await db.commit()
-        await db.refresh(pred)
         return pred
 
 
@@ -36,12 +34,12 @@ def _actual_1x2(home: int, away: int) -> str:
 
 async def get_eval_summary() -> dict:
     """按 provider × 模型聚合评估。"""
-    async with AsyncSessionLocal() as db:
+    async with get_uow() as session:
         stmt = (
             select(Prediction)
             .where(Prediction.settled == True)
         )
-        result = await db.execute(stmt)
+        result = await session.execute(stmt)
         rows = list(result.scalars().all())
 
         from collections import defaultdict
@@ -61,8 +59,8 @@ async def get_eval_summary() -> dict:
                 err = ((p.pred_home_goals - p.actual_home_goals) ** 2 +
                        (p.pred_away_goals - p.actual_away_goals) ** 2) ** 0.5
                 b["score_errors"].append(err)
-            if p.confidence is not None:
-                b["conf_sum"] += p.confidence
+            if p.subjective_confidence is not None:
+                b["conf_sum"] += p.subjective_confidence
                 b["conf_count"] += 1
 
         summary = []
@@ -76,6 +74,6 @@ async def get_eval_summary() -> dict:
                 "total": b["total"],
                 "accuracy_1x2": round(acc, 1),
                 "avg_score_rmse": round(avg_err, 2) if avg_err is not None else None,
-                "avg_confidence": round(avg_conf, 2) if avg_conf is not None else None,
+                "avg_subjective_confidence": round(avg_conf, 2) if avg_conf is not None else None,
             })
         return {"summary": summary}

src/llm/predict.py

@@ -2,15 +2,18 @@
 from __future__ import annotations
 
 import functools
+import hashlib
 import logging
 import time
 from dataclasses import dataclass
+from datetime import datetime, timezone
 from pathlib import Path
 from threading import Lock
 
 from src.core.config import settings
 from src.db.base import AsyncSessionLocal
 from src.db.models import Match, Prediction
+from src.db.unit_of_work import get_uow
 from src.llm.context_builder import build_context
 from src.llm.provider import LLMProvider, get_default_provider
 
@@ -24,12 +27,18 @@ _cache: dict[str, tuple[float, PredictResult]] = {}
 _cache_lock = Lock()
 
 
-def _cache_key(match_id: int, provider: str, model: str, version: str) -> str:
-    return f"{match_id}:{provider}:{model}:{version}"
+def _cache_key(match_id: int, provider: str, model: str, version: str, tpl_hash: str) -> str:
+    """缓存键:含 prompt 模板内容 hash。
+
+    仅用 version 做键不够 —— 编辑器里改动 `match_prediction_v1.md` 而版本号
+    不变时,进程内缓存仍会返回旧模板产生的旧结果(见审查报告 P2-6)。
+    把模板内容 hash 纳入键,模板一改缓存自动失效。
+    """
+    return f"{match_id}:{provider}:{model}:{version}:{tpl_hash[:12]}"
 
 
-def _get_cached(match_id: int, provider: str, model: str, version: str) -> PredictResult | None:
-    key = _cache_key(match_id, provider, model, version)
+def _get_cached(match_id: int, provider: str, model: str, version: str, tpl_hash: str) -> PredictResult | None:
+    key = _cache_key(match_id, provider, model, version, tpl_hash)
     with _cache_lock:
         if key in _cache:
             ts, result = _cache[key]
@@ -39,12 +48,22 @@ def _get_cached(match_id: int, provider: str, model: str, version: str) -> Predi
     return None
 
 
-def _set_cached(match_id: int, provider: str, model: str, version: str, result: PredictResult) -> None:
-    key = _cache_key(match_id, provider, model, version)
+def _set_cached(match_id: int, provider: str, model: str, version: str, tpl_hash: str, result: PredictResult) -> None:
+    key = _cache_key(match_id, provider, model, version, tpl_hash)
     with _cache_lock:
         _cache[key] = (time.time(), result)
 
 
+def clear_prompt_cache() -> None:
+    """清空 prompt 模板缓存(供开发/热更新时手动调用)。
+
+    lru_cache 的模板缓存是进程级的,改完 .md 需要重启进程才能生效;
+    提供显式清理入口,避免"改了模板却看不到变化"的困惑(见审查报告 P2-5)。
+    """
+    _load_prompt_template.cache_clear()
+    logger.info("prompt 模板缓存已清空")
+
+
 @functools.lru_cache(maxsize=8)
 def _load_prompt_template(version: str = "v1") -> str:
     """缓存 prompt 模板(进程生命周期内每个版本只读一次)。"""
@@ -55,6 +74,11 @@ def _load_prompt_template(version: str = "v1") -> str:
         return f.read()
 
 
+def _prompt_template_hash(version: str) -> str:
+    """prompt 模板内容 hash(用于缓存键,模板变更即失效)。"""
+    return hashlib.sha256(_load_prompt_template(version).encode("utf-8")).hexdigest()
+
+
 @dataclass
 class PredictResult:
     prediction_id: int
@@ -64,7 +88,7 @@ class PredictResult:
     pred_home_goals: float | None
     pred_away_goals: float | None
     pred_1x2: str | None
-    confidence: float | None
+    subjective_confidence: float | None
     reasoning: str | None
     context: str
     latency_ms: int | None
@@ -78,11 +102,22 @@ async def predict_match(
     model: str | None = None,
     prompt_version: str | None = None,
     mode: str = "multi",
+    use_cache: bool = True,
 ) -> "PredictResult | MultiPredictResult":
-    """预测入口。mode=multi(默认)走多 agent;mode=single 走单次调用。"""
+    """预测入口。mode=multi(默认)走多 agent;mode=single 走单次调用。
+
+    Args:
+        use_cache: 是否允许返回进程内缓存结果。回测必须传 False——
+            缓存命中不会新建 prediction 行,调用方会对同一个 prediction_id
+            反复 settle,把不同比赛的真实比分覆盖到同一条记录上。
+    """
     if mode == "single":
         return await _predict_single(
-            match_id, provider=provider, model=model, prompt_version=prompt_version
+            match_id,
+            provider=provider,
+            model=model,
+            prompt_version=prompt_version,
+            use_cache=use_cache,
         )
     from src.llm.agents.orchestrator import predict_match_multi
 
@@ -95,6 +130,7 @@ async def _predict_single(
     provider: LLMProvider | None = None,
     model: str | None = None,
     prompt_version: str | None = None,
+    use_cache: bool = True,
 ) -> PredictResult:
     """单次调用路径(原有实现)。"""
     if provider is None:
@@ -102,16 +138,24 @@ async def _predict_single(
     if model:
         provider.model = model
     version = prompt_version or "v1"
+    tpl_hash = _prompt_template_hash(version)
 
-    # 0. 查缓存(同 match+provider+model+version 5 分钟内直接返)
-    cached = _get_cached(match_id, settings.LLM_PROVIDER, provider.model, version)
-    if cached is not None:
-        logger.debug("predict cache hit match=%s", match_id)
-        return cached
+    # 0. 查缓存(同 match+provider+model+version+模板hash 5 分钟内直接返)
+    if use_cache:
+        cached = _get_cached(match_id, settings.LLM_PROVIDER, provider.model, version, tpl_hash)
+        if cached is not None:
+            logger.debug("predict cache hit match=%s", match_id)
+            return cached
 
     # 1. 拼上下文
     ctx = await build_context(match_id)
 
+    # 1.5 计算快照元数据(用于可复现性)
+    now = datetime.now(timezone.utc)
+    match_kickoff_at = ctx.match_dt
+    prediction_cutoff_at = ctx.match_dt  # 默认:比赛时间作为数据截止
+    input_hash = hashlib.sha256(ctx.text.encode("utf-8")).hexdigest()
+
     # 2. 拼 prompt(指定版本)
     template = _load_prompt_template(version)
     user_prompt = template.replace("{{context}}", ctx.text)
@@ -130,10 +174,17 @@ async def _predict_single(
 
     parsed = resp.parsed or {}
 
-    # 4. 存预测(独立 session,因为 context 用的是自己的 session)
-    async with AsyncSessionLocal() as db:
+    # 3.5 严格校验 LLM 输出
+    from src.llm.validation import validate_prediction_output
+    try:
+        validated = validate_prediction_output(parsed)
+    except Exception as e:
+        raise RuntimeError(f"LLM 输出校验失败: {e}")
+
+    # 4. 存预测(使用 UnitOfWork 统一事务)
+    async with get_uow() as session:
         # 验证 match 存在
-        m = await db.get(Match, match_id)
+        m = await session.get(Match, match_id)
         if m is None:
             raise ValueError(f"match {match_id} not found")
 
@@ -145,16 +196,20 @@ async def _predict_single(
             prompt_tokens=resp.prompt_tokens,
             completion_tokens=resp.completion_tokens,
             latency_ms=resp.latency_ms,
-            pred_home_goals=parsed.get("pred_home_goals"),
-            pred_away_goals=parsed.get("pred_away_goals"),
-            pred_1x2=parsed.get("1x2"),
-            confidence=parsed.get("confidence"),
-            reasoning=parsed.get("reasoning"),
+            pred_home_goals=validated.pred_home_goals,
+            pred_away_goals=validated.pred_away_goals,
+            pred_1x2=validated.pred_1x2,
+            subjective_confidence=validated.subjective_confidence,
+            reasoning=validated.reasoning,
             raw_response=resp.raw,
+            status="success",
+            match_kickoff_at=match_kickoff_at,
+            prediction_cutoff_at=prediction_cutoff_at,
+            prediction_created_at=now,
+            input_hash=input_hash,
         )
-        db.add(pred)
-        await db.commit()
-        await db.refresh(pred)
+        session.add(pred)
+        await session.refresh(pred)
 
         result = PredictResult(
             prediction_id=pred.id,
@@ -164,13 +219,14 @@ async def _predict_single(
             pred_home_goals=pred.pred_home_goals,
             pred_away_goals=pred.pred_away_goals,
             pred_1x2=pred.pred_1x2,
-            confidence=pred.confidence,
+            subjective_confidence=pred.subjective_confidence,
             reasoning=pred.reasoning,
             context=ctx.text,
             latency_ms=resp.latency_ms,
             raw=resp.raw,
         )
 
-        # 5. 写入缓存
-        _set_cached(match_id, settings.LLM_PROVIDER, provider.model, version, result)
+        # 5. 写入缓存(仅当允许缓存时)
+        if use_cache:
+            _set_cached(match_id, settings.LLM_PROVIDER, provider.model, version, tpl_hash, result)
         return result

src/llm/validation.py

@@ -0,0 +1,203 @@
+"""LLM 输出严格校验。
+
+所有 LLM JSON 输出必须经过 Pydantic 校验 + 语义一致性检查后才能落库。
+"""
+from __future__ import annotations
+
+import logging
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+logger = logging.getLogger(__name__)
+
+# 已知的 5 个专家 agent 名(与 orchestrator.SPECIALIST_SPECS 保持一致)
+KNOWN_AGENT_NAMES: tuple[str, ...] = ("form", "stats", "home_away", "injuries", "h2h")
+
+
+class AgentReportSchema(BaseModel):
+    """单个专家 Agent 输出的校验 schema。"""
+
+    data_sufficiency: str = "medium"
+    analysis: str = ""
+    home_edge: float | None = Field(None, ge=-1.0, le=1.0)
+    subjective_confidence: float | None = Field(None, ge=0.0, le=1.0)
+    key_evidence: list[str] = Field(default_factory=list)
+    exp_home_goals: float | None = Field(None, ge=0.0, le=10.0)
+    exp_away_goals: float | None = Field(None, ge=0.0, le=10.0)
+    probable_score: str | None = None
+
+    @field_validator("data_sufficiency")
+    @classmethod
+    def validate_sufficiency(cls, v: str) -> str:
+        allowed = {"high", "medium", "low", "none"}
+        return v.lower() if v.lower() in allowed else "medium"
+
+    @field_validator("key_evidence", mode="before")
+    @classmethod
+    def normalize_evidence(cls, v) -> list[str]:
+        if v is None:
+            return []
+        if isinstance(v, str):
+            return [v]
+        if isinstance(v, list):
+            return [str(e)[:120] for e in v[:5]]
+        return []
+
+    @field_validator("analysis")
+    @classmethod
+    def truncate_analysis(cls, v: str) -> str:
+        return str(v)[:600]
+
+
+class PredictionOutputSchema(BaseModel):
+    """最终预测输出的校验 schema。"""
+
+    pred_home_goals: float = Field(ge=0.0, le=10.0)
+    pred_away_goals: float = Field(ge=0.0, le=10.0)
+    pred_1x2: str
+    subjective_confidence: float = Field(ge=0.0, le=1.0)
+    reasoning: str = ""
+
+    @field_validator("pred_1x2")
+    @classmethod
+    def validate_1x2(cls, v: str) -> str:
+        if v not in ("1", "X", "2"):
+            raise ValueError(f"pred_1x2 must be '1', 'X', or '2', got '{v}'")
+        return v
+
+    @model_validator(mode="after")
+    def check_consistency(self) -> "PredictionOutputSchema":
+        """验证比分与胜平负一致。
+
+        不一致时以比分为准修正 pred_1x2(比分是更结构化的输出),
+        但**必须告警** —— 静默修正会掩盖 LLM 的自相矛盾,让问题无法被发现。
+        """
+        expected = _score_to_1x2(self.pred_home_goals, self.pred_away_goals)
+        if self.pred_1x2 != expected:
+            logger.warning(
+                "1x2 与比分不一致: 比分 %.1f-%.1f 推出 '%s',但 LLM 给出 '%s';以比分修正",
+                self.pred_home_goals, self.pred_away_goals, expected, self.pred_1x2,
+            )
+            self.pred_1x2 = expected
+        return self
+
+
+def _score_to_1x2(home: float, away: float) -> str:
+    """从比分推导胜平负。"""
+    if home > away:
+        return "1"
+    if home < away:
+        return "2"
+    return "X"
+
+
+class AgentWeightsSchema(BaseModel):
+    """终裁给出的各专家权重校验 schema。
+
+    权重含义:各专家报告在最终决策中的相对影响力。约束:
+      - key 必须是已知的 5 个专家名
+      - value ∈ [0, 1]
+      - 总和允许有 0.05 的浮点误差(LLM 常凑不到精确 1.0),
+        超出则归一化到 1.0 而不是直接拒收
+    """
+    weights: dict[str, float] = Field(default_factory=dict)
+
+    @field_validator("weights", mode="before")
+    @classmethod
+    def coerce_weights(cls, v):
+        if v is None:
+            return {}
+        if not isinstance(v, dict):
+            raise ValueError(f"agent_weights 必须是 dict,得到 {type(v).__name__}")
+        out: dict[str, float] = {}
+        for k, raw in v.items():
+            key = str(k).strip().lower()
+            if key not in KNOWN_AGENT_NAMES:
+                logger.warning("agent_weights 含未知专家 '%s',已忽略", k)
+                continue
+            f = _safe_float(raw)
+            if f is None:
+                logger.warning("agent_weights['%s']=%r 非数值,已忽略", k, raw)
+                continue
+            # 负数直接钳到 0;超过 1 的钳到 1
+            out[key] = min(max(f, 0.0), 1.0)
+        return out
+
+    @model_validator(mode="after")
+    def normalize_sum(self) -> "AgentWeightsSchema":
+        """权重和不为 1 时归一化(而非拒收),并在偏离较大时告警。"""
+        if not self.weights:
+            return self
+        total = sum(self.weights.values())
+        if total <= 0:
+            return self
+        if abs(total - 1.0) > 0.05:
+            logger.warning("agent_weights 总和为 %.3f,已归一化到 1.0", total)
+            self.weights = {k: v / total for k, v in self.weights.items()}
+        return self
+
+
+def validate_agent_weights(raw) -> dict[str, float]:
+    """校验并规范化终裁给出的 agent_weights。非法输入返回空 dict。"""
+    if raw is None:
+        return {}
+    try:
+        return AgentWeightsSchema(weights=raw).weights
+    except Exception as e:
+        logger.warning("agent_weights 校验失败,丢弃: %s", e)
+        return {}
+
+
+def validate_agent_output(raw: dict) -> AgentReportSchema:
+    """校验并规范化单个 Agent 输出。"""
+    return AgentReportSchema(
+        data_sufficiency=raw.get("data_sufficiency", "medium"),
+        analysis=raw.get("analysis", ""),
+        home_edge=_safe_float(raw.get("home_edge")),
+        subjective_confidence=_safe_float(raw.get("subjective_confidence") or raw.get("confidence")),
+        key_evidence=raw.get("key_evidence", []),
+        exp_home_goals=_safe_float(raw.get("exp_home_goals")),
+        exp_away_goals=_safe_float(raw.get("exp_away_goals")),
+        probable_score=_format_score(raw.get("probable_score")),
+    )
+
+
+def validate_prediction_output(raw: dict) -> PredictionOutputSchema:
+    """校验最终预测输出。"""
+    # 优先新字段,旧字段仅兼容并打日志
+    conf = raw.get("subjective_confidence")
+    if conf is None and "confidence" in raw:
+        logger.warning("Deprecated field 'confidence' used, prefer 'subjective_confidence'")
+        conf = raw["confidence"]
+
+    return PredictionOutputSchema(
+        pred_home_goals=float(raw.get("pred_home_goals", 0)),
+        pred_away_goals=float(raw.get("pred_away_goals", 0)),
+        pred_1x2=raw.get("1x2") or raw.get("pred_1x2", "X"),
+        subjective_confidence=float(conf if conf is not None else 0.5),
+        reasoning=str(raw.get("reasoning", ""))[:1000],
+    )
+
+
+def _safe_float(v) -> float | None:
+    """安全转 float,失败返回 None。"""
+    if v is None:
+        return None
+    try:
+        f = float(v)
+        if not (f == f):  # NaN check
+            return None
+        return f
+    except (TypeError, ValueError):
+        return None
+
+
+def _format_score(v) -> str | None:
+    """格式化比分输出。"""
+    if v is None:
+        return None
+    if isinstance(v, str):
+        return v
+    if isinstance(v, dict):
+        return f"{v.get('home', '?')}-{v.get('away', '?')}"
+    return None

tests/test_agents.py

@@ -59,14 +59,14 @@ class TestReportParsing:
             "data_sufficiency": "high",
             "analysis": "主队交锋占优",
             "home_edge": 0.6,
-            "confidence": 0.8,
+            "subjective_confidence": 0.8,
             "key_evidence": ["近5次交锋主队4胜", "主场交锋3连胜"],
         }
         resp = LLMResponse(content="{}", parsed=parsed, prompt_tokens=100, completion_tokens=50, latency_ms=500)
         r = _parse_report("h2h", parsed, resp, "gpt-4o-mini")
         assert r.status == "ok"
         assert r.home_edge == 0.6
-        assert r.confidence == 0.8
+        assert r.subjective_confidence == 0.8
         assert len(r.key_evidence) == 2
         assert r.data_sufficiency == "high"
 
@@ -78,7 +78,7 @@ class TestReportParsing:
             "data_sufficiency": "medium",
             "analysis": "主队火力更强",
             "home_edge": 0.4,
-            "confidence": 0.7,
+            "subjective_confidence": 0.7,
             "key_evidence": ["场均xG 2.1"],
             "exp_home_goals": 2.1,
             "exp_away_goals": 1.2,
@@ -96,16 +96,24 @@ class TestReportParsing:
 
         parsed = {
             "data_sufficiency": "bogus",   # 非法 → medium
-            "home_edge": "very strong",    # 非法 → None
-            "confidence": None,
+            "home_edge": "very strong",    # 非法 → None (宽容降级)
+            "subjective_confidence": None,
             "key_evidence": "单字符串",      # → [str]
         }
         resp = LLMResponse(content="{}", parsed=parsed)
         r = _parse_report("form", parsed, resp, "m")
+        # 宽容降级: 不抛异常,非法字段变 None 或默认值
+        assert r.status == "ok"
         assert r.data_sufficiency == "medium"
         assert r.home_edge is None
         assert r.key_evidence == ["单字符串"]
 
+        # 验证范围约束: confidence > 1 会被截断或拒绝
+        parsed2 = {"subjective_confidence": 1.5, "home_edge": 2.0}
+        r2 = _parse_report("form", parsed2, resp, "m")
+        # Pydantic 会拒绝越界值 → parse_error
+        assert r2.status == "parse_error"
+
 
 class TestRunAgent:
     """run_agent 执行器: 门控 + fail-open。"""
@@ -167,7 +175,7 @@ class TestRunAgent:
                 assert "A 2-1 B" in user
                 return LLMResponse(
                     content="{}",
-                    parsed={"data_sufficiency": "high", "analysis": "ok", "home_edge": 0.5, "confidence": 0.9},
+                    parsed={"data_sufficiency": "high", "analysis": "ok", "home_edge": 0.5, "subjective_confidence": 0.9},
                     prompt_tokens=10, completion_tokens=5, latency_ms=100,
                 )
 
@@ -192,7 +200,7 @@ class TestOrchestratorAggregation:
         import json
 
         reports = [
-            AgentReport(agent="h2h", status="ok", home_edge=0.5, confidence=0.8, analysis="a"),
+            AgentReport(agent="h2h", status="ok", home_edge=0.5, subjective_confidence=0.8, analysis="a"),
             AgentReport(agent="injuries", status="no_data", data_sufficiency="none"),
         ]
         text = _reports_to_json(reports)
@@ -211,3 +219,100 @@ class TestOrchestratorAggregation:
         )
         assert "{{match_header}}" not in rendered
         assert "{{agent_reports}}" not in rendered
+
+
+class TestSliceResultGate:
+    """P2-1: 结构化 has_data 门控(替代脆弱的文案子串匹配)。"""
+
+    def test_sliceresult_empty_is_no_data(self):
+        from src.llm.agents.base import _slice_has_data
+        from src.llm.context_builder import SliceResult
+
+        text, has = _slice_has_data(SliceResult(text="── x ──\n  无数据", has_data=False))
+        assert has is False
+
+    def test_sliceresult_with_data_beats_text(self):
+        """即使文案里出现「无数据」字样,结构化 has_data=True 也应胜出。
+
+        这正是旧实现的漏洞:文案匹配会把「主队: 无伤停数据 / 客队: 2人伤停」
+        这类混合输出……这里显式验证结构化声明优先。
+        """
+        from src.llm.agents.base import _slice_has_data
+        from src.llm.context_builder import SliceResult
+
+        tricky = SliceResult(
+            text="── 阵容完整性 ──\n  主队: 无伤停数据\n  客队伤停(1人):\n    - X: 拉伤",
+            has_data=True,
+        )
+        _, has = _slice_has_data(tricky)
+        assert has is True
+
+    def test_str_fallback_still_works(self):
+        """旧式 str 切片(测试 mock / 自定义切片)仍走文案回退,保持兼容。"""
+        from src.llm.agents.base import _slice_has_data
+
+        assert _slice_has_data("── 伤停 ──\n  无数据")[1] is False
+        assert _slice_has_data("── 交锋 ──\n  A 2-1 B")[1] is True
+
+    def test_sliceresult_str_compat(self):
+        """SliceResult 可当 str 用(老调用点无需改)。"""
+        from src.llm.context_builder import SliceResult
+
+        s = SliceResult(text="hello", has_data=True)
+        assert str(s) == "hello"
+
+
+class TestAgentWeightsValidation:
+    """P2-2: agent_weights 必须过校验才能落库。"""
+
+    def test_unknown_agent_dropped(self):
+        from src.llm.validation import validate_agent_weights
+
+        w = validate_agent_weights({"form": 0.4, "h2h": 0.4, "bogus": 0.2, "stats": 0.4})
+        assert "bogus" not in w
+        assert set(w) <= {"form", "stats", "home_away", "injuries", "h2h"}
+
+    def test_out_of_range_clamped(self):
+        from src.llm.validation import validate_agent_weights
+
+        w = validate_agent_weights({"form": 5.0, "h2h": -1.0})
+        assert w["form"] == 1.0
+        assert w["h2h"] == 0.0
+
+    def test_sum_normalized(self):
+        from src.llm.validation import validate_agent_weights
+
+        w = validate_agent_weights({"form": 2.0, "stats": 2.0})
+        assert abs(sum(w.values()) - 1.0) < 1e-9
+
+    def test_no_weights_returns_empty(self):
+        from src.llm.validation import validate_agent_weights
+
+        assert validate_agent_weights(None) == {}
+        assert validate_agent_weights("not a dict") == {}
+
+
+class TestPredictionConsistencyWarn:
+    """P2-3: 比分与 1x2 不一致 → 以比分修正(且告警)。"""
+
+    def test_mismatch_is_corrected_to_score(self):
+        from src.llm.validation import validate_prediction_output
+
+        v = validate_prediction_output({
+            "pred_home_goals": 2.0,
+            "pred_away_goals": 1.0,
+            "pred_1x2": "X",   # 与 2-1 矛盾
+            "subjective_confidence": 0.7,
+        })
+        assert v.pred_1x2 == "1"   # 按比分修正
+
+    def test_consistent_passes_through(self):
+        from src.llm.validation import validate_prediction_output
+
+        v = validate_prediction_output({
+            "pred_home_goals": 0.0,
+            "pred_away_goals": 0.0,
+            "pred_1x2": "X",
+            "subjective_confidence": 0.5,
+        })
+        assert v.pred_1x2 == "X"

tests/test_core.py

@@ -96,7 +96,7 @@ class TestProviderMock:
                 def raise_for_status(self): pass
                 def json(self):
                     return {
-                        "choices": [{"message": {"content": '{"pred_home_goals": 1.5, "pred_away_goals": 1.0, "1x2": "1", "confidence": 0.7, "reasoning": "test"}'}}],
+                        "choices": [{"message": {"content": '{"pred_home_goals": 1.5, "pred_away_goals": 1.0, "1x2": "1", "subjective_confidence": 0.7, "reasoning": "test"}'}}],
                         "usage": {"prompt_tokens": 100, "completion_tokens": 50},
                     }
             return FakeResp()

tests/test_regressions.py

@@ -0,0 +1,99 @@
+"""回归测试:锁定 P0 三项「静默失效」缺陷不再复发。
+
+这些用例不依赖数据库 —— 它们用静态分析检查代码结构,
+因为三个 P0 的本质都是「集成方式错误」,在 mock 掉 slice_fn /
+provider 的单元测试里永远照不出来(这正是它们当初漏网的原因)。
+
+- P0-1/P0-2: 查询 Match 的函数必须 eager-load 切片会访问的关系
+- P0-3: bzzoiro 写 source_event_id 时用的 raw 必须与 nm 配对
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+SRC = Path(__file__).resolve().parent.parent / "src"
+
+# 切片函数会读取的关系属性 → 查询时必须 eager-load
+MATCH_RELATIONS = ("stats", "home_team", "away_team", "league")
+
+
+def _read(rel: str) -> str:
+    return (SRC / rel).read_text(encoding="utf-8")
+
+
+class TestEagerLoadCoverage:
+    """P0-1 / P0-2: 凡是 select(Match) 且后续访问关系的函数,必须有 eager-load。"""
+
+    def test_context_builder_getters_eager_load(self):
+        """_get_form / _get_h2h / _get_home_away 必须预加载关系。
+
+        models.py 已声明 lazy="selectin" 兜底,但这里同时检查显式
+        selectinload —— 显式声明是查询意图的固化,也被 P0 修复所依赖。
+        """
+        src = _read("llm/context_builder.py")
+        for fn in ("_get_form", "_get_h2h", "_get_home_away"):
+            # 截取函数体
+            m = re.search(rf"async def {fn}\(.*?(?=\nasync def |\n# =|\Z)", src, re.S)
+            assert m, f"{fn} 未找到"
+            body = m.group(0)
+            assert "selectinload" in body, (
+                f"{fn} 查询 Match 但未 eager-load 关系 —— "
+                "this would raise MissingGreenlet in async SQLAlchemy (P0-2)"
+            )
+
+    def test_backtest_candidates_eager_load(self):
+        """回测取历史比赛必须 eager-load(否则 session 关闭后访问关系必炸)。"""
+        src = _read("llm/backtest.py")
+        assert "selectinload" in src, "backtest 未 eager-load 关系 (P0-1)"
+
+    def test_relationship_default_is_selectin(self):
+        """models.py 中 Match 的高频关系应声明 lazy='selectin' 作为兜底。"""
+        src = _read("db/models.py")
+        # 找到 Match 类定义段
+        m = re.search(r"class Match\(Base\):.*?(?=\nclass )", src, re.S)
+        assert m, "Match 类未找到"
+        body = m.group(0)
+        for rel in MATCH_RELATIONS:
+            # 关系声明可能跨多行(stats/home_team/away_team 都是),因此按
+            # 「从 `rel: Mapped` 到下一个 `xxx: Mapped` 之前」整段匹配。
+            m_rel = re.search(
+                rf"^\s*{rel}: Mapped.*?(?=^\s*\w+: Mapped|\Z)", body, re.M | re.S
+            )
+            assert m_rel, f"Match.{rel} 未找到"
+            assert 'lazy="selectin"' in m_rel.group(0), (
+                f"Match.{rel} 未声明 lazy='selectin' —— 兜底缺失 (P0-2)"
+            )
+
+
+class TestBzzoiroLineage:
+    """P0-3: source_event_id 必须取配对的 raw,不能是循环残留变量。"""
+
+    def test_normalized_matches_carries_raw(self):
+        src = _read("data/bzzoiro.py")
+        # 规范化结果必须与原始 event 成对保存
+        assert "normalized_matches.append((nm, raw))" in src, (
+            "normalized_matches 未携带 (nm, raw) 元组 —— raw 变量泄漏会回归 (P0-3)"
+        )
+        # 内层消费循环必须解包成对变量
+        assert re.search(r"for nm, raw in normalized_matches", src), (
+            "消费循环未解包 (nm, raw) —— 血缘字段会取到错误 event (P0-3)"
+        )
+
+    def test_no_orphan_raw_use(self):
+        """source_event_id 所在行必须在解包循环内(用缩进 + 上下文粗判)。"""
+        src = _read("data/bzzoiro.py")
+        lines = src.splitlines()
+        # 找到 "for nm, raw in normalized_matches" 所在行号
+        start = next(
+            (i for i, ln in enumerate(lines) if "for nm, raw in normalized_matches" in ln),
+            None,
+        )
+        assert start is not None
+        # 该循环之后、下一个同/更低缩进的顶层语句之前的范围
+        seg = "\n".join(lines[start:])
+        uses = [ln for ln in seg.splitlines() if "source_event_id" in ln]
+        assert uses, "未找到 source_event_id 赋值"
+        assert all("raw.get(" in ln for ln in uses), (
+            "source_event_id 未使用配对的 raw (P0-3)"
+        )