MenuPilot 0.1.1__tar.gz → 0.2.0__tar.gz

{menupilot-0.1.1 → menupilot-0.2.0/MenuPilot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MenuPilot
-Version: 0.1.1
+Version: 0.2.0
 Summary: 智能 POS 模板映射助手 — 自动将主数据 SOP 代码填入 POS 模板
 Author-email: yuan wu <694904422@qq.com>
 License-Expression: MIT

{menupilot-0.1.1 → menupilot-0.2.0}/MenuPilot.egg-info/SOURCES.txt

@@ -14,6 +14,10 @@ menupilot/main.py
 menupilot/wizard.py
 menupilot/agent/__init__.py
 menupilot/agent/agent_loop.py
+menupilot/agent/composite_token_resolver.py
+menupilot/agent/conflict_resolver.py
+menupilot/agent/context_mode.py
+menupilot/agent/mapping_parser.py
 menupilot/agent/matching_engine.py
 menupilot/agent/option_expander.py
 menupilot/agent/orchestration.py

{menupilot-0.1.1/MenuPilot.egg-info → menupilot-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MenuPilot
-Version: 0.1.1
+Version: 0.2.0
 Summary: 智能 POS 模板映射助手 — 自动将主数据 SOP 代码填入 POS 模板
 Author-email: yuan wu <694904422@qq.com>
 License-Expression: MIT

{menupilot-0.1.1 → menupilot-0.2.0}/menupilot/__init__.py

@@ -1,3 +1,3 @@
 """MenuPilot — 智能 POS 模板映射助手。"""
 
-__version__ = "0.1.1"
+__version__ = "0.2.0"

{menupilot-0.1.1 → menupilot-0.2.0}/menupilot/agent/agent_loop.py

@@ -11,10 +11,14 @@ import hashlib
 import json
 import os
 from collections import deque
+from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
 from menupilot import config
+from menupilot.agent.context_mode import ContextMode, filter_tools
+from menupilot.agent.conflict_resolver import FieldBinding, apply_patch
+from menupilot.agent.mapping_parser import ParseResult
 
 # ── 常量 ──────────────────────────────────────────────────────────
 
@@ -77,6 +81,100 @@ class SessionMemory:
         return len(self.messages) // 2
 
 
+# ═══════════════════════════════════════════════════════════════════
+# ProgressTracker — 基于业务语义的卡死检测
+# ═══════════════════════════════════════════════════════════════════
+
+@dataclass(frozen=True)
+class ProgressSnapshot:
+    """一次工具调用后的进度快照。"""
+    stage: str
+    confirmed_matches: frozenset
+    unresolved_fields: frozenset
+    turn: int
+
+    @staticmethod
+    def _extract_unresolved(result: dict) -> frozenset:
+        """从工具返回值中提取 unresolved 信息。"""
+        items = set()
+        if not isinstance(result, dict):
+            return frozenset()
+        err = result.get("error", "")
+        if err:
+            items.add(str(err)[:80])
+        low = result.get("low_conf", 0)
+        if low:
+            items.add(f"low_conf:{low}")
+        if "缺少" in str(err) or "缺失" in str(err):
+            items.add("missing_fields")
+        return frozenset(items)
+
+    @staticmethod
+    def _extract_confirmed(result: dict) -> frozenset:
+        """从工具返回值中提取已确认的匹配。"""
+        items = set()
+        if not isinstance(result, dict):
+            return frozenset()
+        high = result.get("high_conf", 0)
+        if high:
+            items.add(f"high_conf:{high}")
+        if result.get("ok") is True:
+            items.add("ok")
+        return frozenset(items)
+
+
+class ProgressTracker:
+    """基于业务语义的进度追踪器，区分「推进中」和「真卡死」。"""
+
+    def __init__(self, patience: int = 3):
+        self.history: list[ProgressSnapshot] = []
+        self.patience = patience
+
+    def push(self, snap: ProgressSnapshot):
+        self.history.append(snap)
+
+    def is_stuck(self) -> bool:
+        if len(self.history) < self.patience:
+            return False
+
+        recent = self.history[-self.patience:]
+        last = recent[-1]
+
+        # 收敛到终态 → 不是 stuck
+        if last.stage in ("done", "finalization"):
+            return False
+        # 初始态（什么都没有）→ 不判断
+        if not last.unresolved_fields and not last.confirmed_matches:
+            return False
+
+        # unresolved_fields 在缩小 → 有推进，不是 stuck
+        fields_shrinking = bool(
+            recent[-1].unresolved_fields and
+            recent[-1].unresolved_fields < recent[0].unresolved_fields
+        )
+        if fields_shrinking:
+            return False
+
+        # confirmed_matches 单调不减才算推进，回滚/抖动不算
+        matches_monotone = all(
+            recent[i].confirmed_matches >= recent[i - 1].confirmed_matches
+            for i in range(1, len(recent))
+        )
+        matches_growing = bool(
+            recent[-1].confirmed_matches and
+            recent[-1].confirmed_matches > recent[0].confirmed_matches
+        )
+
+        no_progress = (
+            not fields_shrinking
+            and not matches_growing
+            and not matches_monotone
+        )
+
+        # stage 没变 且 业务没推进 → stuck
+        return len({r.stage for r in recent}) == 1 and no_progress
+
+
 def _build_system_prompt(cwd: str = "") -> str:
     from menupilot.agent.tools import TOOLS
 
@@ -112,13 +210,23 @@ def _build_system_prompt(cwd: str = "") -> str:
 禁止：收到 ok:false 后调用 execute_python 自行调试 —— 你应该问用户，不是自己查数据
 禁止：在无法获取新信息的情况下，重复读取同一个 Excel 文件超过 2 次
 
+## 确认阶段规则
+- 所有待确认项必须在一条 ask_user 消息里一次性提出，禁止分多轮分别询问
+- 进入确认阶段后，禁止调用 query_token_dict / read_excel_info 等分析工具
+- 用户回复后：
+  - 若用户明确确认（是/yes/ok/执行等），立即进入执行阶段
+  - 若用户补充了新规则或修改了参数，将补充内容纳入方案后重新确认，但只允许追加确认一次
+
 ## 交互效率
 - 展示信息和确认操作合并为一次 ask_user 调用
 - 禁止对同一任务的不同字段分多次 ask_user 确认
 - 格式：先展示完整方案，再问"是否执行"
 - 用户说 --sheet N → 传 template_sheet=N
-- 管线完成后用 execute_python 读取 report_path 指向的 txt 报告
-- 以表格展示：商品名 | 不匹配原因 | 行数，表格后给出检查建议
+- 管线完成后，工具返回值中已包含 product_summary（按产品聚合的全量明细）
+- 你无需再读取任何文件，直接从返回值的 report 字段中提取数据
+- 以表格展示摘要（按涉及行数降序），分析主要原因分布规律，给出修复优先级建议
+- 例："杨枝甘露奶茶的奶底「牛奶」缺失，涉及 1000 行不匹配，建议优先补充主数据中杨枝甘露的牛奶奶底"
+- 禁止用 execute_python 读取 report_path 文件
 
 ## 领域知识
 - 奶茶规格维度: 糖度/温度/规格/奶底/茶底
@@ -156,28 +264,268 @@ class AgentLoop:
         self.memory = SessionMemory()
         self.memory.system_prompt = _build_system_prompt(self.cwd)
 
+        # ── Context Mode 状态机 ──
+        self.context_mode: ContextMode = ContextMode.NORMAL
+        self.pending_mapping: dict[str, FieldBinding] = {}
+        self._current_turn: int = 0
+
     def run(self, user_input: str) -> str:
-        """新会话：清空记忆，开始 Agent loop。"""
+        """新会话：清空记忆 + 重置 context_mode，开始 Agent loop。"""
         if config.DEBUG:
             print(f"[DEBUG agent] run() — new session, user_input: {user_input[:200]}")
         self.memory.reset_task()
+        self.context_mode = ContextMode.NORMAL
+        self.pending_mapping = {}
         self.memory.add({"role": "user", "content": user_input})
         return self._loop()
 
     def continue_conversation(self, user_input: str) -> str:
-        """继续已有会话：追加用户消息，继续 loop。"""
+        """继续已有会话：根据 context_mode 路由到对应处理逻辑。"""
+        if config.DEBUG:
+            print(f"[DEBUG agent] continue_conversation() — mode={self.context_mode}, input={user_input[:200]}")
+
+        # ── AWAITING_CONFIRMATION：只接受 yes/no ──
+        if self.context_mode == ContextMode.AWAITING_CONFIRMATION:
+            return self._handle_awaiting_confirmation(user_input)
+
+        # ── MAPPING_BUILDING：直接进 MappingParser，不走通用 LLM ──
+        if self.context_mode == ContextMode.MAPPING_BUILDING:
+            return self._handle_mapping_building(user_input)
+
+        # ── EXECUTING：只允许执行工具，跳过 Intent Router ──
+        if self.context_mode == ContextMode.EXECUTING:
+            self.memory.add({"role": "user", "content": user_input})
+            return self._loop()
+
+        # ── NORMAL：先检测意图，可能切换 mode ──
+        intent = self._detect_intent(user_input)
         if config.DEBUG:
-            print(f"[DEBUG agent] continue_conversation() — user_input: {user_input[:200]}")
+            print(f"[DEBUG agent] Intent detected: {intent}")
+
+        if intent == "PROVIDE_MAPPING_RULE":
+            self.context_mode = ContextMode.MAPPING_BUILDING
+            return self._handle_mapping_building(user_input)
+
+        if intent == "EXECUTE_TASK":
+            self.context_mode = ContextMode.EXECUTING
+            self.memory.add({"role": "user", "content": user_input})
+            return self._loop()
+
+        # intent == "ASK_QUESTION" 或其他 → 正常 LLM 回复
         self.memory.add({"role": "user", "content": user_input})
         return self._loop()
 
+    # ═════════════════════════════════════════════════════════════
+    # Intent Detection + Context Mode Handlers
+    # ═════════════════════════════════════════════════════════════
+
+    def _detect_intent(self, user_input: str) -> str:
+        """判断用户意图。动词不参与路由，对象类型是主分类。
+
+        Step 1: classify_object_type → FILE / FIELD / UNKNOWN
+        Step 2: 同时命中裁决 — FILE 降级为上下文，FIELD 是真正的操作对象
+        """
+        # Step 0: 快速 yes/no
+        stripped = user_input.strip().lower()
+        if stripped in ("是", "yes", "y", "执行", "开始", "确认", "ok", "好的", "可以"):
+            return "EXECUTE_TASK"
+
+        # Step 1: 对象分类
+        schema_keys = self._get_schema_keys()
+        has_file = self._is_file_object(user_input)
+        has_field = self._is_field_object(user_input, schema_keys)
+
+        if config.DEBUG:
+            print(f"[DEBUG agent] Intent: has_file={has_file}, has_field={has_field}, schema_keys={schema_keys}")
+
+        # Step 3: 同时命中裁决
+        # FILE 降级为上下文（"在 mainproduct.xlsx 里…"），FIELD 是操作对象
+        if has_file and has_field:
+            return "PROVIDE_MAPPING_RULE"
+        elif has_file:
+            return "EXECUTE_TASK"
+        elif has_field:
+            return "PROVIDE_MAPPING_RULE"
+        else:
+            return "ASK_QUESTION"  # 对象不明确，交给 LLM 正常回复
+
+    def _is_file_object(self, text: str) -> bool:
+        """判断输入是否涉及文件/路径/数据源。"""
+        file_indicators = (
+            ".xlsx", ".xls", ".csv", "Sheet", "sheet",
+            "testdata", "输出", "文件", "路径",
+        )
+        # 路径特征：盘符:\ 或 \\
+        has_path = ":" in text and "\\" in text
+        return has_path or any(k in text for k in file_indicators)
+
+    def _is_field_object(self, text: str, schema_keys: frozenset) -> bool:
+        """判断输入是否涉及 schema 字段。
+
+        schema_keys 从 pending_mapping 的 key 集合 + 对话中已知的列名动态生成。
+        不用写死关键词。
+        """
+        if not schema_keys:
+            return False
+        return any(k in text for k in schema_keys)
+
+    def _get_schema_keys(self) -> frozenset:
+        """从 pending_mapping + 对话中 LLM 展示的列名动态提取。"""
+        keys = set(self.pending_mapping.keys())
+
+        # 从最近的 assistant 消息中提取列名
+        # LLM 展示映射方案时用的格式：
+        #   | 规格价格 | → | 规格名称 |  或  规格价格 → 规格名称
+        #   | **一级商品分类** | **默认值 AUUUU** |
+        import re
+        recent_text = ""
+        for msg in list(self.memory.messages)[-10:]:
+            if msg.get("role") == "assistant":
+                recent_text += str(msg.get("content", ""))[:3000]
+
+        # 匹配 markdown 表格中的中文 cell（含可选的 * 标记）
+        # "| 规格价格 |"、"| *规格名称_1 |"、"| **一级商品分类** |"
+        col_names = set(re.findall(
+            r'\|\s*\*{0,2}([一-鿿][一-鿿_a-zA-Z0-9\*]{1,20})\*{0,2}\s*\|',
+            recent_text
+        ))
+        # 也匹配 "中文名 → 中文名" 格式
+        arrow_names = set(re.findall(
+            r'([一-鿿]{2,12})\s*[→]\s*',
+            recent_text
+        ))
+        keys.update(col_names)
+        keys.update(arrow_names)
+        # 过滤掉非列名的通用词
+        generic = {"是", "否", "说明", "注意", "默认值", "必填项", "模板列", "主数据列",
+                    "请问", "是否", "确认", "执行", "输出", "路径", "文件"}
+        keys.difference_update(generic)
+
+        return frozenset(keys)
+
+    def _handle_mapping_building(self, user_input: str) -> str:
+        """MAPPING_BUILDING 模式：用 MappingParser 解析用户映射规则。"""
+        self.memory.add({"role": "user", "content": user_input})
+
+        # 调用 MappingParser（专用 LLM prompt）
+        from menupilot.agent.mapping_parser import (
+            build_parser_messages, parse_llm_response,
+        )
+        msgs = build_parser_messages(
+            self.pending_mapping,
+            user_input,
+            list(self.memory.messages),
+        )
+
+        try:
+            completion = self.llm.chat.completions.create(
+                model=self.llm.model,
+                messages=msgs,
+                temperature=0.1,
+                max_tokens=1024,
+            )
+            raw = completion.choices[0].message.content or ""
+            result = parse_llm_response(raw)
+        except Exception as e:
+            result = ParseResult(is_unambiguous=False, patch=None, ambiguity_reason=str(e))
+
+        if config.DEBUG:
+            print(f"[DEBUG agent] MappingParser result: is_unambiguous={result.is_unambiguous}")
+
+        if result.is_unambiguous and result.patch:
+            # 通过 Conflict Resolver 应用 patch
+            new_mapping, conflicts = apply_patch(self.pending_mapping, result.patch)
+            self.pending_mapping = new_mapping
+
+            conflict_msgs = []
+            for c in conflicts:
+                if c["decision"] == "BLOCK":
+                    conflict_msgs.append(
+                        f"⚠️ 「{c['field']}」已有用户指定值「{c['existing_value']}」，"
+                        f"新值「{c['incoming_value']}」优先级较低，已忽略。"
+                    )
+                elif c["decision"] == "REQUIRE_CONFIRMATION":
+                    conflict_msgs.append(
+                        f"❓ 「{c['field']}」之前设为「{c['existing_value']}」，"
+                        f"现在改为「{c['incoming_value']}」，需要确认。"
+                    )
+
+            summary_lines = ["已更新字段映射："]
+            for k, v in result.patch.items():
+                if k in new_mapping and new_mapping[k] is v:
+                    summary_lines.append(f"  ✅ {k} → {v.value}")
+            summary = "\n".join(summary_lines)
+            if conflict_msgs:
+                summary += "\n\n" + "\n".join(conflict_msgs)
+
+            # 进入等待确认
+            self.context_mode = ContextMode.AWAITING_CONFIRMATION
+
+            return (
+                f"{summary}\n\n"
+                f"当前映射配置：\n{self._format_pending_mapping()}\n\n"
+                f"是否确认此映射方案？（输入是/否）"
+            )
+
+        # is_unambiguous=False
+        self.context_mode = ContextMode.AWAITING_CONFIRMATION
+        reason = result.ambiguity_reason or "无法唯一确定映射"
+        return (
+            f"❓ 无法完全确定您的映射意图。\n\n"
+            f"原因：{reason}\n\n"
+            f"当前映射配置：\n{self._format_pending_mapping()}\n\n"
+            f"请补充说明，或输入「是」确认当前方案、输入「否」放弃。"
+        )
+
+    def _handle_awaiting_confirmation(self, user_input: str) -> str:
+        """AWAITING_CONFIRMATION 模式：只接受 yes/no。"""
+        stripped = user_input.strip().lower()
+        is_yes = stripped in ("是", "yes", "y", "确认", "ok", "好的", "可以", "执行")
+        is_no = stripped in ("否", "no", "n", "取消", "不要", "不对")
+
+        if is_yes:
+            EXECUTE_MIN_TURNS = 4
+            turns_remaining = MAX_TURNS - self._current_turn
+            if turns_remaining < EXECUTE_MIN_TURNS:
+                msg = (
+                    f"当前已用 {self._current_turn} 轮，剩余 {turns_remaining} 轮"
+                    f"不足以完成执行（至少需要 {EXECUTE_MIN_TURNS} 轮）。"
+                    f"请重新发起任务。"
+                )
+                self.memory.add({"role": "assistant", "content": msg})
+                return msg
+            self.context_mode = ContextMode.EXECUTING
+            self.memory.add({"role": "user", "content": "确认执行。当前映射配置已生效，请使用 run_sop_matching 执行。"})
+            return self._loop()
+
+        if is_no:
+            self.context_mode = ContextMode.MAPPING_BUILDING
+            return "已取消确认。请重新描述映射规则，或输入 /exit 退出。"
+
+        # 不是 yes/no → 当作映射规则补充
+        self.context_mode = ContextMode.MAPPING_BUILDING
+        return self._handle_mapping_building(user_input)
+
+    def _format_pending_mapping(self) -> str:
+        """格式化 pending_mapping 为可读文本。"""
+        if not self.pending_mapping:
+            return "  （暂无映射配置）"
+        lines = []
+        for k, v in self.pending_mapping.items():
+            src_label = {"explicit_user": "用户指定", "llm_inferred": "LLM推断", "default": "默认"}.get(v.source, v.source)
+            lines.append(f"  {k} → {v.value}  ({src_label})")
+        return "\n".join(lines)
+
     def _loop(self) -> str:
         """内部循环：LLM ↔ 工具执行。"""
         last_error = None
         last_tool_ok = True        # 上一个工具是否返回 ok（非 False）
-        recent_names: list = []    # 滑动窗口：最近调用的工具名
+        _last_failed_name = None   # 上一个 ok:false 的工具名
+        _last_failed_args = None   # 上一个 ok:false 的工具参数
+        tracker = ProgressTracker(patience=3)
 
         for turn in range(1, MAX_TURNS + 1):
+            self._current_turn = turn
             if config.DEBUG:
                 print(f"\n[DEBUG agent] === Turn {turn}/{MAX_TURNS} ===")
                 msgs = self.memory.to_llm_input()
@@ -200,6 +548,35 @@ class AgentLoop:
 
             for tc in response["tool_calls"]:
                 name = tc.get("_name", "")
+                args = tc.get("_parsed_args", {})
+
+                # ── 工程兜底 0：ok:false 后禁止同工具同参数重试 ──
+                if not last_tool_ok and _last_failed_name is not None:
+                    if name == _last_failed_name and args == _last_failed_args:
+                        real_error = ""
+                        if isinstance(last_error, dict):
+                            real_error = last_error.get("error") or ""
+                        block_msg = {
+                            "error_type": "identical_retry",
+                            "error": (
+                                f"工具 '{name}' 上一次调用已失败（ok:false），"
+                                f"当前参数与上次完全相同，禁止无意义重试。"
+                            ),
+                            "hint": (
+                                f"上一次失败原因: {real_error}\n"
+                                f"请根据此错误信息修改参数后重试（如补充 column_mapping），"
+                                f"或调用 ask_user 将错误展示给用户。"
+                            ),
+                            "fatal": False,
+                        }
+                        if config.DEBUG:
+                            print(f"[DEBUG agent] Guard 0: BLOCKED identical retry of '{name}'")
+                        self.memory.add({"role": "assistant", "content": None,
+                                         "tool_calls": [self._make_tool_msg(tc)]})
+                        self.memory.add({"role": "tool", "tool_call_id": tc["id"],
+                                         "content": json.dumps(block_msg, ensure_ascii=False)})
+                        # 不更新 _last_failed_* — 保持原始失败信息，防止 LLM 反复试探
+                        continue
 
                 # ── 工程兜底 1：ok:false 之后禁止调用 execute_python ──
                 if not last_tool_ok and name == "execute_python":
@@ -218,15 +595,12 @@ class AgentLoop:
                         f"💡 {fatal_msg['hint']}"
                     )
 
-                # ── 工程兜底 2：滑动窗口频率检测 ──
-                recent_names.append(name)
-                if len(recent_names) > 5:
-                    recent_names.pop(0)
-                if recent_names.count("execute_python") >= 3:
+                # ── 工程兜底 2：ProgressTracker 卡死检测 ──
+                if tracker.is_stuck():
                     fatal_msg = {
-                        "error_type": "debug_loop",
-                        "error": f"检测到 execute_python 在最近 5 轮中调用了 {recent_names.count('execute_python')} 次，疑似进入调试死循环。",
-                        "hint": "请停止自行调试，用 ask_user 告知用户当前状态，询问下一步操作。",
+                        "error_type": "stuck_loop",
+                        "error": f"最近 {tracker.patience} 轮无业务推进（stage 未变，confirmed_matches 无增长，unresolved_fields 无缩小），疑似卡死。",
+                        "hint": "请用 ask_user 告知用户当前状态，询问下一步操作。",
                         "fatal": True,
                     }
                     self.memory.add({"role": "assistant", "content": None,
@@ -240,11 +614,24 @@ class AgentLoop:
 
                 result = self._execute_tool(tc)
 
-                # 更新 last_tool_ok
+                # ── 更新 last_tool_ok ──
                 if isinstance(result, dict) and "ok" in result:
                     last_tool_ok = result["ok"] is not False
+                    if not last_tool_ok:
+                        _last_failed_name = name
+                        _last_failed_args = dict(args) if isinstance(args, dict) else args
                 else:
-                    last_tool_ok = True  # 非 ok:false 的返回视为正常
+                    last_tool_ok = True
+
+                # ── 推送进度快照 ──
+                if isinstance(result, dict) and "ok" in result:
+                    snapshot = ProgressSnapshot(
+                        stage=name,
+                        confirmed_matches=ProgressSnapshot._extract_confirmed(result),
+                        unresolved_fields=ProgressSnapshot._extract_unresolved(result),
+                        turn=turn,
+                    )
+                    tracker.push(snapshot)
 
                 # 不可恢复错误 → 立即终止，告知用户
                 if isinstance(result, dict) and result.get("fatal"):
@@ -272,23 +659,22 @@ class AgentLoop:
             print(f"[DEBUG agent] MAX_TURNS ({MAX_TURNS}) reached! Task incomplete.")
             print(f"[DEBUG agent] last_error: {last_error}")
             print(f"[DEBUG agent] Recent calls: {list(self.recent_calls)[-5:]}")
-            print(f"[DEBUG agent] Recent names: {recent_names}")
+            history_stages = [s.stage for s in tracker.history[-5:]]
+            print(f"[DEBUG agent] Recent stages: {history_stages}")
 
-        # 工程兜底 3：MAX_TURNS 耗尽时，从 recent_names 推断原因
-        if not last_error and recent_names:
-            py_count = recent_names.count("execute_python")
-            ask_count = recent_names.count("ask_user")
-            if py_count >= 3:
+        # 工程兜底 3：MAX_TURNS 耗尽时，从 tracker 推断原因
+        if not last_error and tracker.history:
+            if tracker.is_stuck():
                 last_error = {
-                    "error": f"最近 {len(recent_names)} 轮中 execute_python 被调用 {py_count} 次，疑似调试死循环。",
+                    "error": "进度追踪器判定卡死：最近几轮无业务推进。",
                     "hint": "用命令行模式直接执行 menupilot -m ... -t ... -o ... 可绕过 Agent 交互避免轮次消耗。",
                 }
 
         if last_error:
             return (
                 f"已执行 {MAX_TURNS} 轮，仍未能完成任务。\n\n"
-                f"最后一次失败：{last_error.get('error', '未知')}\n"
-                f"💡 {last_error.get('hint', '请简化需求后重试')}"
+                f"最后一次失败：{last_error.get('error') or '未知'}\n"
+                f"💡 {last_error.get('hint') or '请简化需求后重试'}"
             )
         return f"已执行 {MAX_TURNS} 轮工具调用，仍未完成任务。请简化需求后重试。"
 
@@ -302,12 +688,17 @@ class AgentLoop:
         }
 
     def _call_llm(self, messages: list) -> dict:
+        # 根据 context_mode 过滤可用工具
+        active_tools = filter_tools(self.tools, self.context_mode)
+        if config.DEBUG and active_tools != self.tools:
+            removed = set(self.tools) - set(active_tools)
+            print(f"[DEBUG agent] Tools filtered by mode={self.context_mode}: removed={removed}")
         tool_schemas = [
             {"type": "function", "function": {
                 "name": t["name"], "description": t["description"],
                 "parameters": t["parameters"],
             }}
-            for t in self.tools.values()
+            for t in active_tools.values()
         ]
         if config.DEBUG and messages:
             last = messages[-1]
@@ -369,7 +760,23 @@ class AgentLoop:
                 print(f"[DEBUG agent] Tool result (duplicate): {json.dumps(result, ensure_ascii=False)[:200]}")
             return result
         try:
+            # ── task_context 注入：LLM 遗漏的 sheet_name/master_sheet 等 ──
+            if name in ("run_option_expansion", "run_sop_matching"):
+                tc = self.memory.task_context
+                if "sheet_name" not in args and "master_sheet" in tc:
+                    args = dict(args)
+                    args["sheet_name"] = tc["master_sheet"]
+                if "template_sheet" not in args and "template_sheet" in tc:
+                    args = dict(args)
+                    args["template_sheet"] = tc["template_sheet"]
             result = tool["handler"](**args)
+            # ── 提取 task_context 信息（read_excel_info 结果） ──
+            if name == "read_excel_info" and isinstance(result, dict):
+                fp = result.get("filepath", "")
+                if fp and "sheet_name" in args:
+                    # 记住：此文件在本会话中已读取的 sheet
+                    pass
+                # 如果有明确的 sheet 分配，写入 task_context
             if config.DEBUG:
                 rstr = json.dumps(self._sanitize(result), ensure_ascii=False, default=str)[:300]
                 print(f"[DEBUG agent] Tool result: {rstr}")