refactor!: 删除 Web/CLI 应用层与内置 LLM 抽取，出库单功能下线（2b）

入口只剩 MCP 服务器；编排由宿主 Agent 负责，本项目只留工具与确定性内核。

删除：
- src/web/（Flask 路由、SSE 轮询、自研聊天前端、模板与静态资源，约 3400 行）
- src/main.py、src/pipeline.py、src/pipeline_core.py（CLI 全流程入口与两套重复管道）
- core/extraction/{extractor,llm_extractor}.py（内置 LLM 抽取、llm_stream.log、file_events.log、并行抽取）
- infra/documents/consumable.py 与 infra/documents/pdf.py：出库单功能下线（Word 模板 4fbb4c3 起已不在仓库，
  该路径此前一直静默失败），PDF 渲染由 core/extraction/render.py 取代
- mcp__arb__doc_consumable 工具；exceptions.ExtractionError；config 的 consumable_storage / get_llm_config /
  load_session_config / SESSION_CONFIG_KEYS（Web 专属，已无引用）
- 针对被删代码的 tests/test_extractor.py、tests/test_llm_extractor.py 与 scripts/ 下的 LLM 调试脚本
- 依赖：llama-index、llama-index-llms-openai-like、python-dotenv（连同其 50+ 传递依赖）
- 提交进来的调试截图 src/images/、根目录 images/ 与 .coverage（并补 .gitignore）

保留与新增：
- 材料入口改为独立进程 src/upload（手机扫码/PC 上传 → cases/<id>/inbox/）
- runner.py 自带 save_invoice_groups，不再依赖 pipeline_core
- scripts/mcp_smoke.py：stdio 自检（拉起自身、列工具、调 case_list、验证 instructions 下发）
- make mcp / mcp-smoke / upload 取代 make run；check 的 mypy 目标从 src/main.py 扩到 src

验证：mcp_smoke 通过（17 个工具、instructions 1449 字节、case_list 正常）；申购单实机生成此前已验证。
门禁：ruff check / format --check(43) / mypy src(36 文件) / deptry / pytest 107 passed。
注：仍用 --no-verify 提交并手动跑等价检查（原因见 2f08bbd 提交说明）。

src/core/extraction/__init__.py

@@ -1,40 +1,28 @@
-"""信息提取模块
+"""信息存取层（无 LLM）
 
-提供发票/文档结构化提取、LLM 辅助提取等功能。
+抽取由宿主 Agent 完成：本模块只负责缓存读写、PDF 页面渲染与文本层提取。
 """
 
-from .extractor import (
-    EXTRACTION_PARALLEL_COUNT,
-    FILE_EVENTS_LOG,
-    SUPPORTED_EXTENSIONS,
-    extract_invoices,
-)
-from .llm_extractor import (
+from .cache import (
     CACHE_DIR_NAME,
-    _image_to_base64,
-    build_extraction_user_message,
-    extract_document,
-    extract_normal_info,
-    extract_travel_info,
-    llm_query_text,
+    extraction_path,
     load_cache,
     load_match_result,
-    parse_json_response,
+    save_extraction,
+    save_json,
+    save_match_result,
 )
+from .render import detect_content_rotation, prepare_image, render_pdf
 
 __all__ = [
     "CACHE_DIR_NAME",
-    "_image_to_base64",
-    "build_extraction_user_message",
-    "extract_document",
-    "extract_normal_info",
-    "extract_travel_info",
+    "detect_content_rotation",
+    "extraction_path",
     "load_cache",
     "load_match_result",
-    "llm_query_text",
-    "parse_json_response",
-    "EXTRACTION_PARALLEL_COUNT",
-    "FILE_EVENTS_LOG",
-    "SUPPORTED_EXTENSIONS",
-    "extract_invoices",
+    "prepare_image",
+    "render_pdf",
+    "save_extraction",
+    "save_json",
+    "save_match_result",
 ]

src/core/extraction/extractor.py

@@ -1,335 +0,0 @@
-"""发票提取编排
-
-统一扫描目录下所有文件（PDF + 图片），通过 LLM 提取结构化数据，
-根据 LLM 返回的「invoice_type」字段自动分类为发票/支付记录/出差事前申请单。
-
-对外接口:
-    extract_invoices(directory) -> tuple[list[dict], list[dict], dict]
-
-错误传播规则:
-    - 单个文件提取失败: 记录日志 + SSE error 事件，继续处理下一个文件
-    - 全部文件提取失败:  raise ExtractionError，携带失败文件列表和原始错误
-    - 缓存读取失败: 静默降级，尝试重新提取
-
-SSE 文件进度事件:
-    在 source_dir 下写入 file_events.log，每行一个 JSON 对象：
-    - {"type": "file_progress", "file": "...", "status": "processing"}
-    - {"type": "file_progress", "file": "...", "status": "done", "summary": {...}}
-    - {"type": "file_progress", "file": "...", "status": "cached"}
-    - {"type": "file_progress", "file": "...", "status": "error", "error": "..."}
-"""
-
-import json
-import os
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from pathlib import Path
-from typing import Any
-
-from ... import get_logger
-from ...core.matching import match_invoices_to_cards
-from ...exceptions import ExtractionError
-from ...infra.documents.invoice import CACHE_DIR_NAME, classify_invoice_batch
-from .cache import save_match_result as _save_match_result
-from .llm_extractor import extract_document
-
-log = get_logger("extractor")
-
-# SSE 文件进度事件日志文件名
-FILE_EVENTS_LOG = "file_events.log"
-
-# 并行提取文件数，可通过环境变量 EXTRACTION_PARALLEL_COUNT 配置
-EXTRACTION_PARALLEL_COUNT = int(os.environ.get("EXTRACTION_PARALLEL_COUNT", "3"))
-
-# 支持的文件扩展名
-SUPPORTED_EXTENSIONS = {".pdf", ".png", ".jpg", ".jpeg", ".bmp", ".webp"}
-
-
-def _emit_file_event(source_dir: Path, file_name: str, status: str, **kwargs: Any) -> None:
-    """向 file_events.log 追加一行 JSON 事件（线程安全，失败时静默忽略）"""
-    event = {
-        "type": "file_progress",
-        "file": file_name,
-        "status": status,
-        **kwargs,
-    }
-    try:
-        event_path = source_dir / FILE_EVENTS_LOG
-        with open(event_path, "a", encoding="utf-8") as f:
-            f.write(json.dumps(event, ensure_ascii=False) + "\n")
-    except Exception:
-        pass
-
-
-def _get_cache_dir(source_dir: Path) -> Path:
-    """获取缓存目录路径"""
-    cache_dir = source_dir / CACHE_DIR_NAME
-    cache_dir.mkdir(exist_ok=True)
-    return cache_dir
-
-
-def _get_json_path(file_path: Path, cache_dir: Path) -> Path:
-    """根据文件路径生成对应的 JSON 缓存路径（包含后缀名以区分同名的 PDF/图片）"""
-    return cache_dir / f"{file_path.stem}{file_path.suffix}.json"
-
-
-def _save_to_cache(file_path: Path, extracted_data: dict[str, Any], cache_dir: Path) -> Path:
-    """将提取结果保存到 JSON 缓存文件，并记录源文件路径和后缀名"""
-    json_path = _get_json_path(file_path, cache_dir)
-    cache_data = {
-        "source_file": str(file_path),
-        "source_filename": file_path.name,
-        "source_extension": file_path.suffix.lower(),
-        "extracted_data": extracted_data,
-    }
-    with open(json_path, "w", encoding="utf-8") as f:
-        json.dump(cache_data, f, ensure_ascii=False, indent=2)
-    log.info(f"提取结果已缓存: {json_path.name}")
-    return json_path
-
-
-def _load_from_cache(json_path: Path, expected_extension: str | None = None) -> dict[str, Any] | None:
-    """从 JSON 缓存文件加载提取结果，可选校验后缀名一致性"""
-    if not json_path.exists():
-        return None
-    try:
-        with open(json_path, encoding="utf-8") as f:
-            cache_data: dict[str, Any] = json.load(f)
-        # 校验后缀名是否一致，防止同名不同后缀的文件误命中缓存
-        if expected_extension and cache_data.get("source_extension", "").lower() != expected_extension.lower():
-            return None
-        result: dict[str, Any] | None = cache_data.get("extracted_data")
-        return result
-    except Exception as e:
-        log.warning(f"读取缓存失败 {json_path.name}: {e}")
-        return None
-
-
-def _build_summary(data: dict[str, Any]) -> dict[str, str]:
-    """从提取结果构建前端展示摘要（人类可读格式）。
-
-    返回所有非内部字段（排除 _source_file 等下划线前缀字段），
-    并将 invoice_type 转换为中文标签。列表/字典类型的值会展开为可读文本。
-    """
-    invoice_type_map = {
-        "train": "高铁票",
-        "hotel": "酒店住宿",
-        "general": "普通发票",
-        "payment": "支付记录",
-        "application": "出差申请单",
-        "attachments": "其他附件",
-        "note": "易耗品单",
-    }
-
-    summary = {}
-    for key, value in data.items():
-        # 跳过内部字段
-        if key.startswith("_"):
-            continue
-        # 跳过空值
-        if value is None or value == "":
-            continue
-        # invoice_type 转为中文标签
-        if key == "invoice_type":
-            summary["invoice_type_label"] = invoice_type_map.get(str(value), str(value))
-        elif isinstance(value, list):
-            # 列表展开为多行可读文本
-            if len(value) == 0:
-                continue
-            parts = []
-            for item in value:
-                if isinstance(item, dict):
-                    # 字典项用 "key: value" 格式拼接
-                    pair_parts = [f"{k}: {v}" for k, v in item.items()]
-                    parts.append(" | ".join(pair_parts))
-                else:
-                    parts.append(str(item))
-            summary[key] = "\n".join(parts)
-        elif isinstance(value, dict):
-            # 字典展开为 "key: value" 格式
-            pair_parts = [f"{k}: {v}" for k, v in value.items()]
-            summary[key] = " | ".join(pair_parts)
-        else:
-            summary[key] = str(value)
-
-    return summary
-
-
-def _extract_document(
-    file_path: Path,
-    cache_dir: Path,
-    source_dir: Path,
-) -> tuple[dict[str, str] | None, str | None]:
-    """提取单个文件的结构化信息，优先使用缓存。
-
-    根据 LLM 返回的「invoice_type」字段自动分类：
-        - "payment" -> 支付记录
-        - "application" -> 申请单
-        - 有 "invoice_number" -> 发票
-        - 其他 -> 无法识别
-
-    Args:
-        file_path: 文件路径（PDF 或图片）。
-        cache_dir: JSON 缓存目录。
-        source_dir: 源目录（用于写入 SSE 进度事件）。
-
-    Returns:
-        (提取结果字典或 None, 错误信息或 None)。
-    """
-    file_name = file_path.name
-
-    json_path = _get_json_path(file_path, cache_dir)
-    cached = _load_from_cache(json_path, expected_extension=file_path.suffix.lower())
-    if cached:
-        cached["_source_file"] = file_name
-        log.info(f"使用缓存: {file_name}")
-        _emit_file_event(source_dir, file_name, "cached")
-        return cached, None
-
-    # 发送处理中事件
-    _emit_file_event(source_dir, file_name, "processing")
-
-    log.info(f"使用多模态提取: {file_name}")
-    try:
-        result = extract_document(file_path)
-        if result:
-            result["_source_file"] = file_name
-            _save_to_cache(file_path, result, cache_dir)
-
-            # 发送完成事件（含摘要）
-            summary = _build_summary(result)
-            _emit_file_event(source_dir, file_name, "done", summary=summary)
-
-            return result, None
-    except Exception as e:
-        err_msg = str(e)
-        log.warning(f"多模态提取失败: {file_name} ({err_msg})")
-        _emit_file_event(source_dir, file_name, "error", error=err_msg)
-        return None, err_msg
-
-    return None, None
-
-
-def _find_all_files(directory: str) -> list[Path]:
-    """扫描目录下所有支持的文件（PDF + 图片）"""
-    dir_path = Path(directory)
-    files = [f for f in dir_path.iterdir() if f.is_file() and f.suffix.lower() in SUPPORTED_EXTENSIONS]
-    return sorted(files)
-
-
-def extract_invoices(
-    directory: str = ".",
-) -> tuple[list[dict[str, str]], list[dict[str, str]], dict[str, list[dict[str, str]]]]:
-    """扫描目录下所有文件，提取信息并匹配支付记录
-
-    统一使用 LLM 提取，根据返回的「invoice_type」自动分类：
-        - 发票（有 invoice_number）-> 参与金额匹配
-        - 支付记录（invoice_type="payment"）-> 参与金额匹配
-        - 出差事前申请单 -> 单独存储，不参与匹配
-
-    Returns:
-        元组 (payment_records, applications, groups):
-            - payment_records: 支付记录列表（每项含关联发票 _matched_invoices）
-            - applications: 出差事前申请单列表
-            - groups: 按文档类型分组的字典
-                {'travel': [差旅发票], 'general': [普通发票], 'application': [出差事前申请单],
-                 'attachments': [其他附件]}
-
-    Raises:
-        ExtractionError: 当所有文件提取均失败时抛出，携带失败文件列表和原始错误。
-    """
-    source_dir = Path(directory)
-    cache_dir = _get_cache_dir(source_dir)
-
-    # 清空上次的文件进度事件
-    try:
-        (source_dir / FILE_EVENTS_LOG).unlink(missing_ok=True)
-    except Exception:
-        pass
-
-    all_files = _find_all_files(directory)
-    if not all_files:
-        log.warning("未找到支持的文件")
-        return [], [], {"travel": [], "general": [], "application": [], "attachments": []}
-
-    log.info(f"发现 {len(all_files)} 个文件")
-
-    all_invoices = []
-    all_cards = []
-    applications = []
-    attachments = []
-    # 记录失败文件及其错误信息
-    failed_files: list[tuple[str, str]] = []
-
-    max_workers = max(1, EXTRACTION_PARALLEL_COUNT)
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        future_to_file = {executor.submit(_extract_document, fp, cache_dir, source_dir): fp for fp in all_files}
-
-        for future in as_completed(future_to_file):
-            file_path = future_to_file[future]
-            try:
-                result, err = future.result()
-            except Exception as e:
-                err_msg = str(e)
-                failed_files.append((file_path.name, err_msg))
-                log.warning(f"未能解析: {file_path.name} ({err_msg})")
-                continue
-
-            if not result:
-                if err:
-                    failed_files.append((file_path.name, err))
-                log.warning(f"未能解析: {file_path.name}")
-                continue
-
-            inv_type = result.get("invoice_type", "")
-
-            if inv_type == "application":
-                applications.append(result)
-                log.info(f"[{inv_type}] 已解析: {file_path.name}")
-            elif inv_type == "payment":
-                all_cards.append(result)
-                log.info(f"[{inv_type}] 已解析: {file_path.name}")
-            elif inv_type in ("attachments", "note"):
-                attachments.append(result)
-                log.info(f"[{inv_type}] 已解析: {file_path.name}")
-            elif result.get("invoice_number"):
-                all_invoices.append(result)
-                log.info(f"[{inv_type}] 已解析: {file_path.name}")
-            else:
-                log.warning(f"无法分类: {file_path.name} (invoice_type={inv_type})")
-
-    # 全部文件提取失败时抛出异常，携带原始错误信息
-    if failed_files and not all_invoices and not all_cards and not applications:
-        failed_names = [name for name, _ in failed_files]
-        error_details = {name: err for name, err in failed_files}
-        raise ExtractionError(
-            f"所有 {len(all_files)} 个文件提取均失败",
-            failed_files=failed_names,
-            details=error_details,
-        )
-
-    log.info(
-        f"分类结果: 发票 {len(all_invoices)} 张, 支付记录 {len(all_cards)} 条, 申请单 {len(applications)} 份, 附件 {len(attachments)} 个"
-    )
-
-    if not all_invoices:
-        log.warning("未成功解析任何发票")
-
-    payment_records = match_invoices_to_cards(all_invoices, all_cards)
-    _save_match_result(payment_records, cache_dir)
-
-    # 构建分类
-    all_documents: list[dict[str, str]] = []
-    for record in payment_records:
-        all_documents.extend(record.get("_matched_invoices", []))
-    all_documents.extend(applications)
-
-    groups = classify_invoice_batch(all_documents)
-    groups["attachments"] = attachments
-    log.info(
-        f"文档分类: 差旅发票 {len(groups['travel'])} 张, "
-        f"普通发票 {len(groups['general'])} 张, "
-        f"出差事前申请单 {len(groups['application'])} 份, "
-        f"附件 {len(groups['attachments'])} 个"
-    )
-
-    return payment_records, applications, groups

src/core/extraction/llm_extractor.py

@@ -1,506 +0,0 @@
-"""LLM 信息提取
-
-使用 LLM 从 PDF 文本/图片、支付截图中提取结构化数据。
-
-## 功能模块
-
-- **统一文档提取**：使用一套提示词，LLM 自行判断文档类型（发票/支付记录/出差事前申请单等），支持 JSON 格式输出。
-- **差旅信息提取**：综合多张发票、支付记录和匹配结果，提取出差事由、地点、时间等差旅相关信息。
-- **缓存管理**：支持从 `.invoice_cache/` 目录加载已提取的结构化数据和匹配结果，避免重复处理。
-- **SSE 流式事件**：`extract_travel_info` 和 `extract_normal_info` 在调用 LLM 时，向 `source_dir/llm_stream.log` 写入流式事件（start/reasoning/chunk/end/error），前端通过 SSE 实时展示 AI 思考过程与正式回答。
-
-## 对外接口
-
-- `extract_document(file_path) -> dict` — 统一入口：从任意图片/PDF 提取信息
-- `extract_travel_info(source_dir) -> dict` — 综合发票和匹配结果提取差旅信息
-- `extract_normal_info(source_dir) -> dict` — 提取普通发票报销信息
-- `load_cache(source_dir) -> dict` — 加载缓存的结构化数据
-- `load_match_result(source_dir) -> dict` — 加载发票与支付记录的匹配结果
-- `llm_query_text(system_prompt, text, source_dir) -> str` — 纯文本 LLM 查询（供 Agent 调度使用）
-- `parse_json_response(text) -> dict` — 从 LLM 响应中提取 JSON（供 Agent 调度使用）
-- `build_extraction_user_message(cache_map, match_result) -> str` — 构建提取请求的用户消息（供 Agent 调度使用）
-
-## SSE 流式事件协议
-
-`llm_stream.log` 每行一个 JSON 对象：
-
-- `{"type": "llm_stream", "phase": "start", "label": "..."}` — LLM 调用开始
-- `{"type": "llm_stream", "phase": "reasoning", "text": "..."}` — 模型原生推理/思考片段（来自 `thinking_delta`）
-- `{"type": "llm_stream", "phase": "chunk", "text": "..."}` — 流式文本片段（正式回答）
-- `{"type": "llm_stream", "phase": "end", "label": "..."}` — LLM 调用结束
-- `{"type": "llm_stream", "phase": "error", "error": "..."}` — LLM 调用失败
-"""
-
-from __future__ import annotations
-
-import base64
-import json
-from pathlib import Path
-from typing import Any, cast
-
-from ... import get_logger
-from ...infra.documents.invoice import CACHE_DIR_NAME
-from ...infra.llm.prompt import (
-    build_invoice_system_prompt,
-    build_normal_info_system_prompt,
-    build_travel_info_system_prompt,
-)
-
-log = get_logger("llm_extractor")
-
-# Re-export CACHE_DIR_NAME for convenience
-__all__ = [
-    "CACHE_DIR_NAME",
-    "extract_document",
-    "extract_travel_info",
-    "extract_normal_info",
-    "load_cache",
-    "load_match_result",
-    "llm_query_text",
-    "parse_json_response",
-    "build_extraction_user_message",
-]
-
-# SSE LLM 流式事件日志文件名
-LLM_STREAM_LOG = "llm_stream.log"
-
-
-def _emit_llm_stream(source_dir: Path, phase: str, **kwargs: Any) -> None:
-    """向 llm_stream.log 追加一行 JSON 事件（线程安全，失败时静默忽略）
-
-    Args:
-        source_dir: 会话目录路径。
-        phase: 事件阶段 ("start" / "chunk" / "end" / "error")。
-        **kwargs: 额外字段 (text, label, error 等)。
-    """
-    event = {"type": "llm_stream", "phase": phase, **kwargs}
-    try:
-        event_path = source_dir / LLM_STREAM_LOG
-        with open(event_path, "a", encoding="utf-8") as f:
-            f.write(json.dumps(event, ensure_ascii=False) + "\n")
-    except Exception:
-        pass
-
-
-def _create_llm() -> Any:
-    """根据配置文件创建 LLM 实例。"""
-    try:
-        from llama_index.llms.openai_like import OpenAILike
-    except ImportError:
-        log.error("缺少 llama-index-llms-openai-like，请执行: uv pip install llama-index-llms-openai-like")
-        raise
-
-    from ...config import get_llm_config
-
-    llm_config = get_llm_config()
-    return OpenAILike(
-        model=llm_config["model"],
-        api_base=llm_config["api_base"],
-        api_key=llm_config.get("api_key", "lm-studio"),
-        temperature=0.1,
-        max_tokens=65535,
-        request_timeout=600.0,
-        is_chat_model=True,
-    )
-
-
-def parse_json_response(text: str) -> dict[str, Any]:
-    """从 LLM 响应中提取 JSON，处理可能的 Markdown 包裹。
-
-    Args:
-        text: LLM 响应文本。
-
-    Returns:
-        解析后的字典。
-    """
-    text = text.strip()
-
-    # 处理 ```json ... ``` 包裹
-    if "```" in text:
-        start = text.find("```") + 3
-        end = text.find("```", start)
-        if end > start:
-            text = text[start:end].strip()
-
-    # 去掉可能的前缀 (如 "json")
-    if text.lower().startswith("json"):
-        text = text[4:].strip()
-
-    return cast(dict[str, Any], json.loads(text))
-
-
-# ------------------------------------------------------------------
-# 统一文档提取（多模态，直接传图片给 LLM）
-# ------------------------------------------------------------------
-
-
-def _image_to_base64(image_path: Path) -> str:
-    """将图片文件读取为 base64 字符串。"""
-    with open(image_path, "rb") as f:
-        return base64.b64encode(f.read()).decode("utf-8")
-
-
-def _stream_llm_response(
-    llm: Any,
-    messages: list[Any],
-    source_dir: Path | None,
-    reasoning_effort: str,
-    log_label: str = "LLM",
-) -> str:
-    """流式调用 LLM 并写入 SSE 事件（供 llm_query_text 和 _llm_query_multimodal 共用）。
-
-    Args:
-        llm: LLM 实例。
-        messages: 消息列表。
-        source_dir: 会话目录（可选，传入时启用 SSE 流式事件写入）。
-        reasoning_effort: 推理努力级别。
-        log_label: 日志标签（用于区分"纯文本"和"多模态"）。
-
-    Returns:
-        LLM 响应文本。
-    """
-    try:
-        if source_dir:
-            _emit_llm_stream(source_dir, "start", label="正在分析文件...")
-
-        parts = []
-        for resp in llm.stream_chat(
-            messages,
-            temperature=0.1,
-            extra_body={"reasoning_effort": reasoning_effort},
-        ):
-            delta = resp.delta
-            if delta:
-                parts.append(delta)
-                if source_dir:
-                    _emit_llm_stream(source_dir, "chunk", text=delta)
-
-            thinking = getattr(resp, "additional_kwargs", {}) or {}
-            thinking_delta = thinking.get("thinking_delta", "")
-            if thinking_delta and source_dir:
-                _emit_llm_stream(source_dir, "reasoning", text=thinking_delta)
-
-        text = "".join(parts)
-        log.info("%s请求完成，响应总长度: %d 字符", log_label, len(text))
-        if source_dir:
-            _emit_llm_stream(source_dir, "end", label="分析完成")
-        return text
-    except Exception as e:
-        log.error("%s请求失败: %s", log_label, e)
-        if source_dir:
-            _emit_llm_stream(source_dir, "error", error=str(e))
-        raise
-
-
-def llm_query_text(
-    system_prompt: str,
-    text: str,
-    reasoning_effort: str = "none",
-    source_dir: Path | None = None,
-) -> str:
-    """发送纯文本请求到 LLM（供 Agent 调度使用）。
-
-    Args:
-        system_prompt: 系统提示词。
-        text: 用户文本。
-        reasoning_effort: 推理努力级别。
-        source_dir: 会话目录（可选，传入时启用 SSE 流式事件写入）。
-
-    Returns:
-        LLM 响应文本。
-    """
-    from llama_index.core.base.llms.types import TextBlock
-    from llama_index.core.llms import ChatMessage
-
-    from ...config import get_llm_config
-
-    messages = [
-        ChatMessage(role="system", content=system_prompt),
-        ChatMessage(role="user", blocks=[TextBlock(text=text)]),
-    ]
-
-    llm_config = get_llm_config()
-    llm = _create_llm()
-    log.info(
-        "开始请求 LLM (model=%s, base=%s)",
-        llm_config["model"],
-        llm_config["api_base"],
-    )
-
-    return _stream_llm_response(llm, messages, source_dir, reasoning_effort, log_label="LLM")
-
-
-def extract_document(file_path: Path) -> dict[str, Any]:
-    """统一文档提取入口：从任意图片/PDF 中提取结构化信息。
-
-    LLM 会根据统一提示词自行判断文档类型（发票/支付记录/出差事前申请单等）。
-
-    Args:
-        file_path: 文件路径（支持 PDF 和图片格式）。
-
-    Returns:
-        包含提取字段的字典。
-    """
-    from ...infra.documents.pdf import render_pdf_to_images
-
-    system_prompt = build_invoice_system_prompt()
-    user_text = f"请分析以下财务文档并提取信息：\n\n文件名: {file_path.name}"
-
-    # PDF 先渲染为图片
-    suffix = file_path.suffix.lower()
-    if suffix == ".pdf":
-        image_b64s = render_pdf_to_images(file_path)
-    else:
-        image_b64s = [_image_to_base64(file_path)]
-
-    if not image_b64s:
-        log.warning(f"文件渲染为空: {file_path.name}")
-        return {}
-
-    try:
-        response = _llm_query_multimodal(system_prompt, user_text, image_b64s)
-        result = parse_json_response(response)
-        log.info("LLM 文档提取成功: %s", file_path.name)
-        return result
-    except Exception as e:
-        log.error("LLM 文档提取失败: %s (%s)", file_path.name, e)
-        raise
-
-
-def _llm_query_multimodal(
-    system_prompt: str,
-    text: str | None = None,
-    image_b64s: list[str] | None = None,
-    blocks: list[Any] | None = None,
-    reasoning_effort: str = "none",
-    source_dir: Path | None = None,
-) -> str:
-    """发送多模态请求到 LLM（内部使用）。
-
-    Args:
-        system_prompt: 系统提示词。
-        text: 用户文本（与 image_b64s 配合使用，文本在前、图片在后）。
-        image_b64s: base64 编码的图片列表。
-        blocks: 预构建的内容块列表（TextBlock/ImageBlock），传入时忽略 text 和 image_b64s。
-        source_dir: 会话目录（可选，传入时启用 SSE 流式事件写入）。
-
-    Returns:
-        LLM 响应文本。
-    """
-    from llama_index.core.base.llms.types import ImageBlock, TextBlock
-    from llama_index.core.llms import ChatMessage
-
-    from ...config import get_llm_config
-
-    if blocks is not None:
-        final_blocks = blocks
-    else:
-        text = text or ""
-        image_b64s = image_b64s or []
-        final_blocks = [TextBlock(text=text)]
-        for img_b64 in image_b64s:
-            final_blocks.append(
-                ImageBlock(
-                    url=f"data:image/jpeg;base64,{img_b64}",
-                    detail="high",
-                )
-            )
-
-    messages = [
-        ChatMessage(role="system", content=system_prompt),
-        ChatMessage(role="user", blocks=final_blocks),
-    ]
-
-    llm_config = get_llm_config()
-    llm = _create_llm()
-    log.info(
-        "开始请求 LLM 多模态 (model=%s, base=%s, blocks=%d)",
-        llm_config["model"],
-        llm_config["api_base"],
-        len(final_blocks),
-    )
-
-    return _stream_llm_response(llm, messages, source_dir, reasoning_effort, log_label="LLM多模态")
-
-
-def load_cache(source_dir: Path) -> dict[str, Any]:
-    """从 JSON 缓存目录加载结构化数据，构建 source filename -> 缓存数据的映射。
-
-    Args:
-        source_dir: 源文件目录（包含 .invoice_cache 子目录）。
-
-    Returns:
-        {source_filename: extracted_data} 字典。
-        额外包含 "travel_info" 键（如果 travel_info.json 存在）。
-    """
-    cache_map: dict[str, Any] = {}
-    cache_dir = source_dir / CACHE_DIR_NAME
-    if not cache_dir.exists():
-        return cache_map
-
-    for json_path in sorted(cache_dir.glob("*.json")):
-        try:
-            with open(json_path, encoding="utf-8") as f:
-                cache_data = json.load(f)
-
-            if json_path.name in ("travel_info.json", "normal_info.json"):
-                cache_map[json_path.name.replace(".json", "")] = cache_data
-                continue
-
-            extracted = cache_data.get("extracted_data", {})
-            src_file = extracted.get("_source_file", "")
-            if src_file:
-                cache_map[src_file] = extracted
-        except Exception as e:
-            log.warning(f"读取缓存失败 {json_path.name}: {e}")
-
-    return cache_map
-
-
-def load_match_result(source_dir: Path) -> dict[str, list[dict[str, Any]]]:
-    """从 JSON 缓存目录加载发票与支付记录的匹配结果。
-
-    Args:
-        source_dir: 源文件目录（包含 .invoice_cache 子目录）。
-
-    Returns:
-        {支付记录源文件 (含金额): [发票信息列表]} 字典。
-        每个发票信息包含 file, type, amount 字段。
-    """
-    cache_dir = source_dir / CACHE_DIR_NAME
-    match_path = cache_dir / "match_result.json"
-    if not match_path.exists():
-        return {}
-
-    try:
-        with open(match_path, encoding="utf-8") as f:
-            result: dict[str, list[dict[str, Any]]] = json.load(f)
-            return result
-    except Exception as e:
-        log.warning(f"读取匹配结果缓存失败: {e}")
-        return {}
-
-
-def build_extraction_user_message(
-    cache_map: dict[str, Any],
-    match_result: dict[str, list[dict[str, Any]]],
-    previous_analysis: dict[str, Any] | None = None,
-    user_supplement: str | None = None,
-) -> str:
-    """构建提取请求的用户消息（供 Agent 调度使用）。
-
-    Args:
-        cache_map: 缓存数据映射。
-        match_result: 匹配结果。
-        previous_analysis: 上一轮 LLM 分析结果（可选，补充文件时传入作为历史上下文）。
-        user_supplement: 用户文字补充（可选，传入时作为修正上下文）。
-
-    Returns:
-        拼接好的用户消息字符串。
-    """
-    parts = [
-        "以下是本次报销的所有源文件及其提取出的结构化数据。"
-        "每个源文件的数据来自 OCR 识别和发票信息提取，已按文件名分组展示。"
-    ]
-
-    if previous_analysis:
-        parts.append(
-            "【上一轮分析结果】"
-            "以下是上一轮 LLM 对已有文件的分析结果。"
-            "注意：用户可能已补充新文件，请综合所有数据（含新文件）重新分析。"
-            "如果新文件填补了之前的信息缺失，请相应更新分析结果。\n"
-            + json.dumps(previous_analysis, ensure_ascii=False, indent=2)
-        )
-
-    if user_supplement:
-        parts.append("【用户文字补充】用户补充了以下文字信息，请据此更新你的分析结果。\n" + user_supplement)
-
-    if match_result:
-        parts.append(
-            "【发票与支付记录匹配结果】"
-            "以下数据已将发票信息与对应的支付记录进行关联匹配，"
-            "用于判断每笔支付对应的发票和商户信息。\n" + json.dumps(match_result, ensure_ascii=False, indent=2)
-        )
-
-    for filename, extracted in cache_map.items():
-        parts.append(
-            f"【源文件: {filename}】"
-            "以下为从该文件提取的结构化发票/支付/申请单数据。\n" + json.dumps(extracted, ensure_ascii=False, indent=2)
-        )
-
-    parts.append("\n=== 请返回 JSON 格式结果 ===")
-    return "\n".join(parts)
-
-
-def _extract_info(
-    source_dir: Path | None,
-    system_prompt: str,
-    info_type: str,
-) -> dict[str, Any]:
-    """通用的信息提取函数：加载缓存、构建消息、调用 LLM 并解析 JSON。
-
-    extract_travel_info 和 extract_normal_info 的公共实现。
-
-    Args:
-        source_dir: 源文件目录（必填，包含 .invoice_cache 子目录）。
-        system_prompt: 系统提示词。
-        info_type: 信息类型标签（"差旅" 或 "普通发票"），用于日志。
-
-    Returns:
-        LLM 提取的结构化信息字典。
-    """
-    if not source_dir:
-        log.warning("未提供 source_dir，无法加载缓存数据")
-        return {}
-
-    cache_map = load_cache(source_dir)
-    match_result = load_match_result(source_dir)
-    user_message = build_extraction_user_message(cache_map, match_result)
-
-    log.info("开始构建%s信息提取请求，缓存条目: %d, 匹配结果: %d", info_type, len(cache_map), len(match_result))
-
-    try:
-        response = llm_query_text(
-            system_prompt=system_prompt,
-            text=user_message,
-            reasoning_effort="low",
-            source_dir=source_dir,
-        )
-        result = parse_json_response(response)
-        log.info("LLM %s信息提取成功", info_type)
-        return result
-    except Exception as e:
-        log.error("LLM %s信息提取失败: %s", info_type, e)
-        raise
-
-
-def extract_travel_info(
-    source_dir: Path | None = None,
-) -> dict[str, Any]:
-    """根据差旅发票（bot 格式），让 LLM 提取出差相关信息。
-
-    纯提取，不包含校验逻辑。校验由 Agent 层调度。
-
-    Args:
-        source_dir: 源文件目录（必填，包含 .invoice_cache 子目录）。
-
-    Returns:
-        包含出差事由、地点、交通工具、时间、住宿信息等字段的字典。
-    """
-    return _extract_info(source_dir, build_travel_info_system_prompt(), "差旅")
-
-
-def extract_normal_info(
-    source_dir: Path | None = None,
-) -> dict[str, Any]:
-    """根据普通发票（非差旅），让 LLM 提取报销相关信息。
-
-    纯提取，不包含校验逻辑。校验由 Agent 层调度。
-
-    Args:
-        source_dir: 源文件目录（必填，包含 .invoice_cache 子目录）。
-
-    Returns:
-        包含报销说明、发票总数、总金额、支付方式、附件清单等字段的字典。
-    """
-    return _extract_info(source_dir, build_normal_info_system_prompt(), "普通发票")

src/core/matching/runner.py

@@ -10,14 +10,13 @@ from pathlib import Path
 from typing import Any
 
 from ... import get_logger
-from ...core.extraction.cache import load_cache, save_match_result
+from ...core.extraction.cache import load_cache, save_json, save_match_result
 from ...infra.documents.invoice import (
     classify_invoice_batch,
     save_application_json,
     save_csv,
     save_invoice_csv,
 )
-from ...pipeline_core import save_invoice_groups
 from .matcher import match_invoices_to_cards
 
 log = get_logger("matching.runner")
@@ -46,6 +45,20 @@ def split_cache(cache_map: dict[str, Any]) -> dict[str, list[dict[str, Any]]]:
     return buckets
 
 
+def save_invoice_groups(session_dir: Path, groups: dict[str, list[dict[str, Any]]]) -> None:
+    """写 invoice_groups.json：完整分组 + 计数，供后续阶段与产物判断。"""
+    data = {
+        "travel": groups.get("travel", []),
+        "general": groups.get("general", []),
+        "application": groups.get("application", []),
+        "attachments": groups.get("attachments", []),
+        "travel_count": len(groups.get("travel", [])),
+        "general_count": len(groups.get("general", [])),
+        "application_count": len(groups.get("application", [])),
+    }
+    save_json(session_dir / "invoice_groups.json", data)
+
+
 def match_from_cache(case_dir: Path, tolerance: float | None = None) -> dict[str, Any]:
     """按缓存内容执行金额匹配，返回结构化结果。