myagent-ai 1.26.4 → 1.26.6

package/agents/main_agent.py

@@ -45,7 +45,7 @@ class MainAgent(BaseAgent):
 
 严格以XML格式化输出以下内容，否则解析器无法解析:"""
 
-    # XML 输出格式规范（头部嵌入 SYSTEM_PROMPT，尾部在 _process_v2_inner 中再次追加，一头一尾确保格式正确）
+    # XML 输出格式规范（嵌入 SYSTEM_PROMPT，只出现一次）
     xml_prompt = """
 
 <output>
@@ -756,7 +756,6 @@ GUI桌面 (仅Windows/macOS):
                 + self.SYSTEM_PROMPT.split("\n", 1)[1]
             )
             system_content = _prompt_with_placeholder.replace(_CONTEXT_PLACEHOLDER, context_xml)
-            system_content = system_content + "\n最后，再检查输出格式，确保满足以下要求:" + self.xml_prompt
             
             # Step 3: 构建 LLM 消息（必须包含 role=user，否则 OpenAI 兼容 API 返回 400）
             messages = [Message(role="system", content=system_content)]
@@ -875,7 +874,13 @@ GUI桌面 (仅Windows/macOS):
                 break
 
             llm_raw = response.content
+            _finish_reason = getattr(response, 'finish_reason', '') or ''
             logger.debug(f"[{task_id}] LLM 输出 (前500字): {llm_raw[:500]}")
+            if _finish_reason == "length":
+                logger.warning(
+                    f"[{task_id}] LLM 输出被 max_tokens 截断 (finish_reason=length)，"
+                    f"输出长度={len(llm_raw)} 字符"
+                )
 
             # 保存 LLM 原始输出到会话记忆（用于回溯和审计，key=llm_output 不出现在对话历史中）
             if self.memory:
@@ -918,137 +923,151 @@ GUI桌面 (仅Windows/macOS):
                 stream_callback,
             )
 
-            # Step 4.2: <output> 块完整性检查
-            # 仅在块不完整且解析未提取到任何有效内容时才触发修正
-            # 如果解析器已经从非完整块中提取到有效内容（response/tools等），则正常继续
-            if not parsed.output_block_complete and not parsed.parse_success:
-                # 打印完整消息列表（系统提示词+对话历史），便于分析模型为何输出不完整
-                logger.warning(
-                    f"[{task_id}] <output> 块不完整且未提取到有效内容\n"
-                    f"====== 发送给LLM的完整消息列表（共{len(messages)}条）======\n"
-                    + "\n".join(
-                        f"--- [{i}] role={m.role} ---\n{m.content[:8000]}{'...(截断)' if len(m.content)>8000 else ''}"
-                        for i, m in enumerate(messages)
-                    )
-                    + f"\n====== 消息列表结束 ======"
-                )
+            # Step 4.2: <output> 块完整性检查 + finish_reason 截断检测
+            # 统一处理三种异常:
+            #   A) finish_reason=length → max_tokens 截断
+            #   B) 缺少 <output> 开始标签
+            #   C) 缺少 </output> 闭合标签
+            _has_output_open = bool(re.search(r"<output[^>]*>", llm_raw, re.IGNORECASE))
+            _has_output_close = bool(re.search(r"</output\s*>", llm_raw, re.IGNORECASE))
+            _is_truncated = (_finish_reason == "length")
+            _block_incomplete = (not _has_output_open or not _has_output_close)
+
+            if _is_truncated or (_block_incomplete and not parsed.parse_success):
+                # 构建诊断信息
+                _diag_parts = []
+                if _is_truncated:
+                    _diag_parts.append("finish_reason=length(max_tokens截断)")
+                if not _has_output_open:
+                    _diag_parts.append("缺少<output>开始标签")
+                if not _has_output_close and _has_output_open:
+                    _diag_parts.append("缺少</output>闭合标签")
+                _diag_msg = ", ".join(_diag_parts)
+
                 logger.warning(
-                    f"[{task_id}] <output> 块不完整且未提取到有效内容，"
-                    f"跳过本轮输出和工具执行"
+                    f"[{task_id}] XML 输出异常: {_diag_msg}，"
+                    f"parse_success={parsed.parse_success}, "
+                    f"输出长度={len(llm_raw)} 字符"
                 )
-                if _xml_correction_retries < 1:
+
+                if _xml_correction_retries < 3:
                     _xml_correction_retries += 1
-                    # [v1.15.73] 在重试前，尝试从不完整的 llm_raw 中提取已有内容
-                    # 防止 reasoning 模型因 max_tokens 截断导致内容完全丢失
+                    # 尝试从不完整输出中提取已有内容，防止内容完全丢失
                     _partial_text = self._try_extract_partial_response(llm_raw)
                     if _partial_text:
                         logger.info(f"[{task_id}] 从不完整XML中提取到部分回复: {_partial_text[:100]}")
                         _v2_reasoning_collected.append(_partial_text)
                         _emitted_reasoning_this_iter = True
                         await self._emit_v2_event("v2_reasoning", {"content": _partial_text}, stream_callback)
-                    correction_prompt = (
-                        "你的输出缺少 </output> 闭合标签，XML块不完整，"
-                        "解析器不会处理不完整的块。\n"
-                        "请严格按照 <output>...</output> 格式重新输出，"
-                        "确保所有标签正确闭合。\n\n"
-                        f"你上一次的原始输出如下：\n{llm_raw}"
-                    )
+
+                    # 根据诊断信息构建精准修正提示词
+                    if _is_truncated:
+                        correction_prompt = (
+                            "你的上一次输出因长度限制被截断，XML块不完整。\n"
+                            "请在回复中只包含精简的核心内容，避免冗长描述。\n"
+                            "如果需要执行工具调用，只保留最关键的工具。\n"
+                            "严格按照 <output>...</output> 格式输出，确保标签完整闭合。\n\n"
+                            f"你上一次被截断的输出如下（供参考，不要照搬）:\n{llm_raw[-2000:]}"
+                        )
+                    elif not _has_output_open:
+                        correction_prompt = (
+                            "你的输出缺少 <output> 开始标签，解析器无法识别。\n"
+                            "请严格按照 <output>...</output> 格式重新输出，"
+                            "确保以 <output> 开头、以 </output> 结尾。\n"
+                            "不要在 <output> 标签前后输出任何其他文字。\n\n"
+                            f"你上一次的原始输出如下：\n{llm_raw[-2000:]}"
+                        )
+                    else:
+                        correction_prompt = (
+                            "你的输出缺少 </output> 闭合标签，XML块不完整，"
+                            "解析器不会处理不完整的块。\n"
+                            "请严格按照 <output>...</output> 格式重新输出，"
+                            "确保所有标签正确闭合。\n\n"
+                            f"你上一次的原始输出如下：\n{llm_raw[-2000:]}"
+                        )
+
+                    # 追加到 history 时使用截断版本，防止 history 膨胀
                     conversation_history.append(
-                        Message(role="assistant", content=llm_raw)
+                        Message(role="assistant", content=llm_raw[-3000:] if len(llm_raw) > 3000 else llm_raw)
                     )
                     conversation_history.append(
                         Message(role="user", content=correction_prompt)
                     )
                     await self._emit_v2_event(
                         "v2_reasoning",
-                        {"content": "⚠️ 模型输出XML块不完整，正在自动修正..."},
+                        {"content": f"⚠️ 模型输出异常({_diag_msg})，正在自动修正({_xml_correction_retries}/3)..."},
                         stream_callback,
                     )
                     continue  # 重新进入循环，让 LLM 重新生成
                 else:
-                    # 已重试过，强制终止并提示用户
-                    logger.warning(f"[{task_id}] XML块仍不完整且已重试，终止循环")
-                    # [v1.15.73] 保存已积累的内容，避免空回复
+                    # 已重试 3 次 → 不终止，提取已有内容作为 response 继续执行
+                    logger.warning(f"[{task_id}] XML输出异常已重试3次，提取已有内容继续执行: {_diag_msg}")
+                    _fallback_save = ""
                     if _v2_reasoning_collected:
                         _fallback_save = "\n".join(_v2_reasoning_collected)
-                        if _fallback_save.strip():
-                            context.working_memory["final_response"] = _fallback_save
-                            if self.memory:
-                                self.memory.add_session(
-                                    session_id=context.session_id,
-                                    role="assistant",
-                                    content=_fallback_save,
-                                )
-                            await self._emit_v2_event(
-                                "v2_reasoning",
-                                {"content": _fallback_save},
-                                stream_callback,
-                            )
-                    else:
-                        context.working_memory["final_response"] = "模型输出格式异常，请重新尝试。"
-                        await self._emit_v2_event(
-                            "v2_reasoning",
-                            {"content": "模型输出格式异常，已自动终止。"},
-                            stream_callback,
-                        )
-                    break
-            elif not parsed.output_block_complete and parsed.parse_success:
+                    if not _fallback_save.strip():
+                        before, after = extract_surrounding_text(llm_raw)
+                        _fallback_save = ((before + "\n" + after) if (before.strip() or after.strip()) else re.sub(r"<[^>]+>", "", llm_raw).strip())
+                    _fallback_save = _fallback_save.strip() if _fallback_save.strip() else "处理完毕。"
+                    parsed.parse_success = True
+                    parsed.response = _fallback_save
+                    parsed.finish = True
+                    parsed.finish_reason = f"输出异常({_diag_msg})，已提取内容继续执行"
+            elif _block_incomplete and parsed.parse_success:
                 # 块不完整但已提取到有效内容，记录日志但正常继续
                 logger.info(
                     f"[{task_id}] <output> 块不完整但已提取到有效内容，跳过修正直接处理"
                 )
 
-            # Step 4.5: 解析失败处理 — 回退给 LLM 修正或提取周边文本
+            # Step 4.5: 解析失败处理 — 三层兜底，确保执行不会因解析错误而中断
+            # 兜底策略（由 output_parser Step 4.5 已完成 L1/L2，此处处理 L3）:
+            #   L1 (parser): 直接搜索 <tool> 块（跳过 toolstocal 包装）
+            #   L2 (parser): 搜索散落的 <toolname>+<parms> 配对
+            #   L3 (此处):  将原始文本回退给 LLM 修正格式，或提取为纯文本继续
             if not parsed.parse_success:
-                # 即使解析失败，如果 regex fallback 提取到了工具调用，仍然继续执行
                 if parsed.tools_to_call:
-                    logger.warning(f"[{task_id}] XML 解析失败但提取到 {len(parsed.tools_to_call)} 个工具调用，跳过修正直接执行")
-                elif parsed.needs_correction and _xml_correction_retries < 1:
-                    # XML 完全无法解析，让 LLM 重新格式化输出
+                    # L1/L2 兜底成功提取到了工具调用 → 标记为成功，继续执行工具
+                    parsed.parse_success = True
+                    logger.warning(f"[{task_id}] 解析兜底成功: 提取到 {len(parsed.tools_to_call)} 个工具调用，继续执行")
+                elif parsed.needs_correction and _xml_correction_retries < 3:
+                    # L3 兜底: 将原始文本回退给 LLM 让它调好格式再输出
                     _xml_correction_retries += 1
                     logger.warning(
-                        f"[{task_id}] XML 解析完全失败，回退给 LLM 修正 "
-                        f"(重试 {_xml_correction_retries}/1)"
+                        f"[{task_id}] 解析兜底L3: 回退给LLM修正格式 "
+                        f"(重试 {_xml_correction_retries}/3)"
                     )
                     correction_prompt = (
-                        "你上一次的输出格式有误，XML解析器无法识别。"
-                        "请严格按照 <output>...</output> 格式重新输出你的回答。"
-                        "注意：不要在 <output> 标签前后输出任何其他文字。\n\n"
-                        f"你上一次的原始输出如下：\n{llm_raw}"
+                        "你上一次的输出格式有误，XML解析器无法识别。\n"
+                        "请严格按照 <output>...</output> 格式重新输出你的回答。\n"
+                        "注意：以 <output> 开头，以 </output> 结尾，"
+                        "不要在 <output> 标签前后输出任何其他文字。\n\n"
+                        f"你上一次的原始输出如下：\n{llm_raw[-2000:]}"
                     )
                     conversation_history.append(
-                        Message(role="assistant", content=llm_raw)
+                        Message(role="assistant", content=llm_raw[-3000:] if len(llm_raw) > 3000 else llm_raw)
                     )
                     conversation_history.append(
                         Message(role="user", content=correction_prompt)
                     )
                     await self._emit_v2_event(
                         "v2_reasoning",
-                        {"content": "⚠️ 模型输出格式异常，正在自动修正..."},
+                        {"content": f"⚠️ 输出格式异常，正在自动修正({_xml_correction_retries}/3)..."},
                         stream_callback,
                     )
                     continue  # 重新进入循环，让 LLM 重新生成
                 else:
-                    # 已重试过或不需要修正，提取周边文本作为备选
-                    logger.warning(f"[{task_id}] XML 解析失败，提取周边文本作为备选")
+                    # 所有兜底都失败 → 把原始文本去除标签后作为 response，不中断执行
+                    logger.warning(f"[{task_id}] 所有解析兜底失败，提取原始文本作为response继续执行")
                     before, after = extract_surrounding_text(llm_raw)
                     if before.strip() or after.strip():
                         final_text = (before + "\n" + after).strip()
                     else:
-                        # 清除残余 XML 标签后作为纯文本
                         final_text = re.sub(r"<[^>]+>", "", llm_raw).strip()
                         final_text = final_text if final_text else "处理完毕。"
-                    context.working_memory["final_response"] = final_text
-                    await self._emit_v2_event(
-                        "v2_reasoning", {"content": final_text}, stream_callback
-                    )
-                    if self.memory:
-                        self.memory.add_session(
-                            session_id=context.session_id,
-                            role="assistant",
-                            content=final_text,
-                        )
-                    break
+                    parsed.parse_success = True
+                    parsed.response = final_text
+                    parsed.finish = True
+                    parsed.finish_reason = "输出格式异常，已提取文本内容作为最终回复"
 
             warnings = validate_output(parsed)
             for w in warnings:

package/config.py

@@ -28,7 +28,7 @@ class LLMConfig:
     base_url: str = "https://api.openai.com/v1"
     model: str = "gpt-4"
     temperature: float = 0.1
-    max_tokens: int = 4096
+    max_tokens: int = 30000
     context_window: int = 128000         # 上下文窗口大小
     input_modes: List[str] = field(default_factory=lambda: ["text"])  # 支持的输入模式
     reasoning: bool = False              # 是否支持推理
@@ -94,7 +94,7 @@ class ModelEntry:
     model: str = ""               # API 调用使用的实际模型字符串
     base_url: str = ""            # 自定义 Base URL（空=使用 provider 默认值）
     api_key: str = ""             # 专用 API Key（空=使用全局默认值）
-    max_tokens: int = 4096
+    max_tokens: int = 30000
     temperature: float = 0.1
     context_window: int = 128000  # 上下文窗口大小（token）
     input_modes: List[str] = field(default_factory=lambda: ["text"])  # 支持的输入模式: text, image, video, audio

package/core/llm.py

@@ -133,7 +133,7 @@ class LLMClient:
         base_url: str = "",
         model: str = "gpt-4",
         temperature: float = 0.1,
-        max_tokens: int = 4096,
+        max_tokens: int = 30000,
         timeout: int = 120,
         max_retries: int = 3,
         reasoning: bool = False,
@@ -567,13 +567,26 @@ class LLMClient:
                     "arguments": args,
                 })
 
+        # 提取推理模型的思考过程 (DeepSeek-R1, o1, o3, QwQ 等)
+        _reasoning = ""
+        _content = choice.message.content or ""
+        # 尝试多种属性名（不同 API 提供商的命名差异）
+        for _attr in ("reasoning_content", "reasoning", "thinking"):
+            _reasoning = getattr(choice.message, _attr, None) or ""
+            if _reasoning:
+                break
+        # 如果 content 为空但 reasoning 有内容，用 reasoning 作为 content
+        if not _content.strip() and _reasoning.strip():
+            _content = _reasoning
+
         return LLMResponse(
-            content=choice.message.content or "",
+            content=_content,
             tool_calls=tool_calls,
             usage=usage,
             model=response.model,
             finish_reason=choice.finish_reason or "",
             raw_response=response,
+            reasoning=_reasoning,
         )
 
     async def _chat_anthropic(self, messages: List[Message], kwargs: dict) -> LLMResponse:
@@ -604,9 +617,16 @@ class LLMClient:
         )
 
         content = ""
+        _reasoning = ""
         for block in response.content:
             if block.type == "text":
                 content += block.text
+            elif block.type == "thinking":
+                _reasoning += getattr(block, "thinking", "") or ""
+
+        # 如果 content 为空但 reasoning 有内容，用 reasoning 作为 content
+        if not content.strip() and _reasoning.strip():
+            content = _reasoning
 
         return LLMResponse(
             content=content,
@@ -616,6 +636,7 @@ class LLMClient:
             },
             model=response.model,
             finish_reason=response.stop_reason or "",
+            reasoning=_reasoning,
         )
 
     async def _chat_ollama(self, kwargs: dict) -> LLMResponse:

package/core/output_parser.py

@@ -429,8 +429,36 @@ def _custom_parse(raw_text: str) -> ParsedOutput:
         parsed.needs_correction = True
         return parsed
 
-    # ── Step 0: Check <output> block completeness ──
-    parsed.output_block_complete = is_output_block_complete(raw_text)
+    # ── Step 0: 检查 <output> 块，处理缺少开始/闭合标签的情况 ──
+    _has_open = bool(re.search(r"<output[^>]*>", raw_text, re.IGNORECASE))
+    _has_close = bool(re.search(r"</output\s*>", raw_text, re.IGNORECASE))
+
+    if not _has_open and not _has_close:
+        # 完全没有 <output> 标签 — 检查是否包含已知子标签
+        _has_known_tags = any(
+            re.search(rf"<{re.escape(t)}[\s>]", raw_text, re.IGNORECASE)
+            for t in KNOWN_TOP_LEVEL_TAGS
+        )
+        if _has_known_tags:
+            # 有子标签但缺少 <output> 包装 — 自动补全后正常解析
+            logger.info(
+                "LLM 输出缺少 <output> 标签但包含已知子标签，"
+                "自动补全 <output> 包装后解析"
+            )
+            raw_text = "<output>\n" + raw_text.strip() + "\n</output>"
+            parsed.output_block_complete = True
+        else:
+            parsed.output_block_complete = False
+    elif _has_open and not _has_close:
+        parsed.output_block_complete = False
+    elif not _has_open and _has_close:
+        # 有闭合标签但没开始标签 — 补全开始标签
+        logger.info("LLM 输出缺少 <output> 开始标签但有 </output>，自动补全")
+        raw_text = "<output>\n" + raw_text.strip()
+        parsed.output_block_complete = True
+    else:
+        parsed.output_block_complete = True
+
     conservative = not parsed.output_block_complete
 
     if conservative:
@@ -520,6 +548,63 @@ def _custom_parse(raw_text: str) -> ParsedOutput:
     if toolstocal_raw.strip():
         parsed.tools_to_call = _parse_toolstocal(toolstocal_raw, conservative=conservative)
 
+    # ── Step 4.5: 兜底机制 — 宽松提取工具调用，确保执行不会因解析错误而中断 ──
+    # 策略优先级:
+    #   1. _parse_toolstocal 已成功提取 → 不做任何事
+    #   2. 直接在整个输出中搜索 <tool>...</tool> 块（跳过 toolstocal 包装）
+    #   3. 搜索散落的 <toolname>...</toolname> + <parms>...</parms> 配对
+    if not parsed.tools_to_call:
+        # 兜底 Level 1: 在整个原始文本中直接搜索 <tool> 块
+        _raw_tool_blocks = _extract_all_tag_blocks(
+            raw_text, "tool", parent_close_tag=None, conservative=False,
+        )
+        for block in _raw_tool_blocks:
+            tn = _safe_strip(_extract_tag_content(block, "toolname", TOOL_INNER_TAGS))
+            if tn:
+                parsed.tools_to_call.append({
+                    "beforecalltext": _safe_strip(_extract_tag_content(block, "beforecalltext", TOOL_INNER_TAGS)),
+                    "toolname": tn,
+                    "parms": _safe_strip(_extract_tag_content(block, "parms", TOOL_INNER_TAGS)),
+                    "timeout": _parse_int(_extract_tag_content(block, "timeout", TOOL_INNER_TAGS), _DEFAULT_TIMEOUT),
+                })
+                logger.info(f"[兜底L1] 从非<toolstocal>区域提取到工具调用: {tn}")
+
+    if not parsed.tools_to_call:
+        # 兜底 Level 2: 搜索散落的 <toolname>...</toolname>，然后在同一段中找最近的 <parms>
+        _toolname_positions = []
+        for m in re.finditer(r"<toolname[^>]*>(.*?)</toolname\s*>", raw_text, re.DOTALL | re.IGNORECASE):
+            tn = html.unescape(m.group(1)).strip()
+            if tn:
+                _toolname_positions.append((m.start(), m.end(), tn))
+
+        if _toolname_positions:
+            logger.info(f"[兜底L2] 找到 {len(_toolname_positions)} 个散落的 <toolname> 标签")
+            for _i, (_start, _end, _tn) in enumerate(_toolname_positions):
+                # 在 toolname 之后的 500 字符内搜索最近的 <parms>
+                _search_region = raw_text[_end:_end + 500]
+                _parms_match = re.search(
+                    r"<parms[^>]*>(.*?)</parms\s*>",
+                    _search_region, re.DOTALL | re.IGNORECASE,
+                )
+                _parms = html.unescape(_parms_match.group(1)).strip() if _parms_match else ""
+
+                # 也尝试在 toolname 之前的 200 字符内搜索（parms 可能在 toolname 前面）
+                if not _parms:
+                    _pre_region = raw_text[max(0, _start - 200):_start]
+                    _parms_match = re.search(
+                        r"<parms[^>]*>(.*?)</parms\s*>",
+                        _pre_region, re.DOTALL | re.IGNORECASE,
+                    )
+                    _parms = html.unescape(_parms_match.group(1)).strip() if _parms_match else ""
+
+                parsed.tools_to_call.append({
+                    "beforecalltext": "",
+                    "toolname": _tn,
+                    "parms": _parms,
+                    "timeout": _DEFAULT_TIMEOUT,
+                })
+                logger.info(f"[兜底L2] 散落提取工具: {_tn}, parms={'有' if _parms else '无'}")
+
     # ── Step 5: Determine parse success ──
     has_content = bool(
         parsed.response

package/main.py

@@ -374,10 +374,6 @@ class MyAgentApp:
 
     def _register_builtin_skills(self):
         """注册内置技能"""
-        from skills.file_skill import (
-            FileReadSkill, FileWriteSkill, FileListSkill,
-            FileDeleteSkill, FileSearchSkill, FileMoveSkill,
-        )
         from skills.search_skill import WebSearchSkill, WebReadSkill, URLReadSkill
         from skills.system_skill import (
             SystemInfoSkill, ProcessListSkill,
@@ -392,13 +388,6 @@ class MyAgentApp:
             TypeTextSkill, HotkeySkill, WindowListSkill, WindowFocusSkill, ScreenElementSkill,
         )
 
-        # 文件技能
-        for skill_cls in [
-            FileReadSkill, FileWriteSkill, FileListSkill,
-            FileDeleteSkill, FileSearchSkill, FileMoveSkill,
-        ]:
-            self.skill_registry.register(skill_cls())
-
         # 搜索技能
         for skill_cls in [WebSearchSkill, WebReadSkill, URLReadSkill]:
             self.skill_registry.register(skill_cls())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.26.4",
+  "version": "1.26.6",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {

package/scripts/cli.py

@@ -9,7 +9,7 @@ scripts/cli.py - MyAgent CLI 工具集
 命令分类:
   感知:    ocr, analyze-image, transcribe
   搜索:    search, read-url, fetch-url
-  文件:    read, write, ls, rm, grep, mv, send-file
+  文件:    send-file
   文档:    docx-create, docx-read, xlsx-create, xlsx-read, xlsx-edit,
            ppt-create, ppt-read, pdf-create, pdf-read
   系统:    sysinfo, ps, env, pathinfo
@@ -90,12 +90,6 @@ async def _run():
         "read-url": cmd_read_url,
         "fetch-url": cmd_fetch_url,
         # 文件操作
-        "read": cmd_read,
-        "write": cmd_write,
-        "ls": cmd_ls,
-        "rm": cmd_rm,
-        "grep": cmd_grep,
-        "mv": cmd_mv,
         "send-file": cmd_send_file,
         # 文档
         "docx-create": cmd_docx_create,
@@ -332,123 +326,6 @@ async def cmd_fetch_url(args):
 # 文件操作命令
 # =============================================================================
 
-async def cmd_read(args):
-    """读取文件内容"""
-    import argparse
-    p = argparse.ArgumentParser(prog="myagent-ai read", description="读取文件内容")
-    p.add_argument("path", help="文件路径")
-    p.add_argument("-e", "--encoding", default="utf-8", help="文件编码 (默认 utf-8)")
-    p.add_argument("--offset", type=int, default=0, help="起始行号 (从0开始)")
-    p.add_argument("--limit", type=int, default=500, help="读取行数 (默认500)")
-    a = p.parse_args(args)
-
-    from skills.file_skill import FileReadSkill
-    skill = FileReadSkill()
-    result = await skill.execute(path=a.path, encoding=a.encoding, offset=a.offset, limit=a.limit)
-    _print_result({"success": result.success, "message": result.message,
-                   "data": result.data, "error": result.error})
-
-
-async def cmd_write(args):
-    """写入文件"""
-    import argparse
-    p = argparse.ArgumentParser(prog="myagent-ai write", description="写入文件")
-    p.add_argument("path", help="文件路径")
-    p.add_argument("-c", "--content", default="", help="写入内容 (或通过 stdin)")
-    p.add_argument("-e", "--encoding", default="utf-8", help="文件编码")
-    p.add_argument("--append", action="store_true", help="追加模式")
-    a = p.parse_args(args)
-
-    content = a.content
-    if not content:
-        content = _read_stdin()
-    if content is None:
-        content = ""
-
-    from skills.file_skill import FileWriteSkill
-    skill = FileWriteSkill()
-    result = await skill.execute(path=a.path, content=content, encoding=a.encoding, append=a.append)
-    _print_result({"success": result.success, "message": result.message,
-                   "data": result.data, "error": result.error})
-
-    # CLI send-file 标记
-    if result.success and result.files:
-        fpath = result.files[0]
-        print(f"\n__SEND_FILE__{fpath}|文件已写入: {Path(fpath).name}__END__")
-
-
-async def cmd_ls(args):
-    """列出目录内容"""
-    import argparse
-    # [v1.23.46] 过滤系统 ls 参数（-l, -a, -la 等）
-    # [v1.23.48] 过滤纯数字参数（LLM 误传如 myagent-ai ls 2）
-    args = [a for a in args if not a.isdigit()]
-    args = _filter_unknown_args(args, allowed_prefixes={"-p", "--pattern", "-r", "--recursive", "--max"})
-    p = argparse.ArgumentParser(prog="myagent-ai ls", description="列出目录内容")
-    p.add_argument("path", nargs="?", default=".", help="目录路径 (默认当前目录)")
-    p.add_argument("-p", "--pattern", default="*", help="文件匹配模式 (如 *.py)")
-    p.add_argument("-r", "--recursive", action="store_true", help="递归列出")
-    p.add_argument("--max", type=int, default=500, help="最大返回条目数 (默认500)")
-    a = p.parse_args(args)
-
-    from skills.file_skill import FileListSkill
-    skill = FileListSkill()
-    result = await skill.execute(path=a.path, pattern=a.pattern, recursive=a.recursive, max_items=a.max)
-    _print_result({"success": result.success, "message": result.message,
-                   "data": result.data, "error": result.error})
-
-
-async def cmd_rm(args):
-    """删除文件或目录"""
-    import argparse
-    p = argparse.ArgumentParser(prog="myagent-ai rm", description="删除文件或目录")
-    p.add_argument("path", help="文件/目录路径")
-    p.add_argument("-r", "--recursive", action="store_true", help="递归删除目录")
-    a = p.parse_args(args)
-
-    from skills.file_skill import FileDeleteSkill
-    skill = FileDeleteSkill()
-    result = await skill.execute(path=a.path, recursive=a.recursive)
-    _print_result({"success": result.success, "message": result.message,
-                   "data": result.data, "error": result.error})
-
-
-async def cmd_grep(args):
-    """搜索文件内容"""
-    import argparse
-    # [v1.23.46] 使用通用过滤器，过滤系统 grep 参数（-n, -i, -r 等）
-    args = _filter_unknown_args(args, allowed_prefixes={"-p", "--pattern", "--max", "--depth"})
-    p = argparse.ArgumentParser(prog="myagent-ai grep", description="在目录中搜索文件内容")
-    p.add_argument("query", help="搜索关键词")
-    p.add_argument("path", help="搜索目录路径")
-    p.add_argument("-p", "--pattern", default="*", help="文件匹配模式 (如 *.py)")
-    p.add_argument("--max", type=int, default=50, help="最大结果数 (默认50)")
-    p.add_argument("--depth", type=int, default=10, help="最大递归深度 (默认10)")
-    a = p.parse_args(args)
-
-    from skills.file_skill import FileSearchSkill
-    skill = FileSearchSkill()
-    result = await skill.execute(path=a.path, query=a.query, pattern=a.pattern,
-                                  max_results=a.max, max_depth=a.depth)
-    _print_result({"success": result.success, "message": result.message,
-                   "data": result.data, "error": result.error})
-
-
-async def cmd_mv(args):
-    """移动/重命名文件"""
-    import argparse
-    p = argparse.ArgumentParser(prog="myagent-ai mv", description="移动或重命名文件/目录")
-    p.add_argument("source", help="源路径")
-    p.add_argument("dest", help="目标路径")
-    a = p.parse_args(args)
-
-    from skills.file_skill import FileMoveSkill
-    skill = FileMoveSkill()
-    result = await skill.execute(source=a.source, destination=a.dest)
-    _print_result({"success": result.success, "message": result.message,
-                   "data": result.data, "error": result.error})
-
-
 async def cmd_send_file(args):
     """发送文件给用户"""
     import argparse

package/skills/file_skill.py

@@ -1,573 +0,0 @@
-"""
-skills/file_skill.py - 文件操作技能
-=====================================
-提供文件读写、目录操作、文件搜索等功能。
-
-[v1.16.18] FileReadSkill 增强:
-- 自动检测 PDF/Excel/Word/PPT 等二进制格式，提取文本内容
-- PDF: pdftotext (poppler-utils) → PyPDF2 双重 fallback
-- Excel: openpyxl 提取表格文本
-- Word/PPT: python-docx/python-pptx 提取文本
-- CSV/JSON: 智能检测编码
-"""
-from __future__ import annotations
-
-import fnmatch
-import io
-import os
-import shutil
-import glob as glob_module
-from pathlib import Path
-from typing import List, Optional
-
-from core.logger import get_logger
-from skills.base import Skill, SkillResult, SkillParameter
-
-logger = get_logger("myagent.skills.file")
-
-
-def _extract_text_from_binary(file_path: Path, max_chars: int = 50000) -> Optional[str]:
-    """[v1.16.18] 从二进制文件中提取文本内容。
-
-    支持: PDF, Excel (.xlsx/.xls), Word (.docx), PPT (.pptx), CSV
-    返回提取的文本，不支持时返回 None。
-    """
-    fname = file_path.name.lower()
-    suffix = file_path.suffix.lower()
-
-    # ── PDF ──
-    if suffix == ".pdf" or fname.endswith(".pdf"):
-        try:
-            data = file_path.read_bytes()
-            # 方法1: pdftotext (系统工具，更快更准)
-            import subprocess
-            try:
-                result = subprocess.run(
-                    ["pdftotext", str(file_path), "-", "-"],
-                    capture_output=True, text=True, timeout=30,
-                )
-                if result.returncode == 0 and result.stdout.strip():
-                    logger.debug(f"PDF 提取成功 (pdftotext): {file_path.name}")
-                    return result.stdout.strip()[:max_chars]
-            except FileNotFoundError:
-                pass
-            # 方法2: PyPDF2 (纯 Python fallback)
-            try:
-                from PyPDF2 import PdfReader
-                reader = PdfReader(io.BytesIO(data))
-                texts = []
-                for page in reader.pages:
-                    text = page.extract_text()
-                    if text:
-                        texts.append(text)
-                if texts:
-                    logger.debug(f"PDF 提取成功 (PyPDF2): {file_path.name}")
-                    return "\n".join(texts)[:max_chars]
-            except ImportError:
-                logger.warning(f"PyPDF2 未安装，无法读取 PDF: {file_path.name}")
-            except Exception as e:
-                logger.warning(f"PyPDF2 读取 PDF 失败: {file_path.name}: {e}")
-            return None
-        except Exception as e:
-            logger.warning(f"PDF 读取异常: {file_path.name}: {e}")
-            return None
-
-    # ── Excel ──
-    if suffix in (".xlsx", ".xls"):
-        try:
-            from openpyxl import load_workbook
-            wb = load_workbook(str(file_path), read_only=True, data_only=True)
-            texts = []
-            for ws in wb.worksheets:
-                rows = []
-                for row in ws.iter_rows(values_only=True):
-                    cells = [str(c) if c is not None else "" for c in row]
-                    rows.append("\t".join(cells))
-                if rows:
-                    texts.append(f"[工作表: {ws.title}]\n" + "\n".join(rows))
-            wb.close()
-            if texts:
-                return "\n\n".join(texts)[:max_chars]
-        except ImportError:
-            logger.warning(f"openpyxl 未安装，无法读取 Excel: {file_path.name}")
-            return None
-        except Exception as e:
-            logger.warning(f"Excel 读取失败: {file_path.name}: {e}")
-            return None
-
-    # ── Word (.docx) ──
-    if suffix == ".docx":
-        try:
-            from docx import Document
-            doc = Document(str(file_path))
-            paragraphs = [p.text for p in doc.paragraphs if p.text.strip()]
-            if paragraphs:
-                return "\n".join(paragraphs)[:max_chars]
-        except ImportError:
-            logger.warning(f"python-docx 未安装，无法读取 Word: {file_path.name}")
-            return None
-        except Exception as e:
-            logger.warning(f"Word 读取失败: {file_path.name}: {e}")
-            return None
-
-    # ── PowerPoint (.pptx) ──
-    if suffix == ".pptx":
-        try:
-            from pptx import Presentation
-            prs = Presentation(str(file_path))
-            texts = []
-            for i, slide in enumerate(prs.slides):
-                slide_texts = []
-                for shape in slide.shapes:
-                    if shape.has_text_frame:
-                        for para in shape.text_frame.paragraphs:
-                            if para.text.strip():
-                                slide_texts.append(para.text)
-                if slide_texts:
-                    texts.append(f"[幻灯片 {i+1}]\n" + "\n".join(slide_texts))
-            if texts:
-                return "\n\n".join(texts)[:max_chars]
-        except ImportError:
-            logger.warning(f"python-pptx 未安装，无法读取 PPT: {file_path.name}")
-            return None
-        except Exception as e:
-            logger.warning(f"PPT 读取失败: {file_path.name}: {e}")
-            return None
-
-    return None
-
-
-# 常见二进制/不可读格式（不尝试文本提取）
-_BINARY_EXTENSIONS = {
-    ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".svg", ".webp", ".tiff",
-    ".mp3", ".mp4", ".avi", ".mkv", ".mov", ".wmv", ".flv", ".wav", ".ogg",
-    ".zip", ".rar", ".7z", ".tar", ".gz", ".bz2",
-    ".exe", ".dll", ".so", ".dylib",
-    ".pyc", ".pyo", ".whl", ".egg",
-    ".doc",  # 旧版 Word (需要特殊处理)
-    ".xls",  # 旧版 Excel (BIFF 格式，openpyxl 不支持)
-    ".ppt",  # 旧版 PowerPoint
-    ".sqlite", ".db", ".mdb",
-}
-
-
-class FileReadSkill(Skill):
-    """读取文件内容
-
-    [v1.16.18] 增强支持:
-    - 自动检测 PDF/Excel/Word/PPT 等二进制格式并提取文本
-    - 纯文本文件保持原有行为（按行读取，支持 offset/limit）
-    """
-    name = "file_read"
-    description = "读取指定文件的内容。支持文本文件和二进制格式（PDF、Excel、Word、PPT、CSV、JSON等），自动检测编码和格式。"
-    category = "file"
-    parameters = [
-        SkillParameter("path", "string", "文件路径(绝对路径或相对路径)", required=True),
-        SkillParameter("encoding", "string", "文件编码(仅文本文件)", required=False, default="utf-8"),
-        SkillParameter("offset", "integer", "起始行号(从0开始，仅文本文件)", required=False, default=0),
-        SkillParameter("limit", "integer", "读取行数限制(仅文本文件)", required=False, default=500),
-    ]
-
-    async def execute(self, path: str = "", encoding: str = "utf-8",
-                      offset: int = 0, limit: int = 500, **kwargs) -> SkillResult:
-        try:
-            file_path = Path(path).expanduser().resolve()
-            if not file_path.exists():
-                return SkillResult(success=False, error=f"文件不存在: {path}")
-            if not file_path.is_file():
-                return SkillResult(success=False, error=f"不是文件: {path}")
-
-            suffix = file_path.suffix.lower()
-
-            # [v1.16.18] 二进制格式检测 — 不可读的格式直接返回错误
-            if suffix in _BINARY_EXTENSIONS:
-                return SkillResult(
-                    success=False,
-                    error=f"不支持的文件格式 ({suffix})。支持的格式: 文本文件、PDF、Excel(.xlsx)、Word(.docx)、PPT(.pptx)、CSV、JSON、XML 等"
-                )
-
-            # [v1.16.18] PDF/Excel/Word/PPT 等格式 — 提取文本内容
-            if suffix in (".pdf", ".xlsx", ".docx", ".pptx"):
-                extracted = _extract_text_from_binary(file_path)
-                if extracted is None:
-                    # PyPDF2/openpyxl 等依赖未安装
-                    dep_hint = {
-                        ".pdf": "pip install PyPDF2 或 apt install poppler-utils",
-                        ".xlsx": "pip install openpyxl",
-                        ".docx": "pip install python-docx",
-                        ".pptx": "pip install python-pptx",
-                    }
-                    hint = dep_hint.get(suffix, "请安装对应的 Python 库")
-                    return SkillResult(
-                        success=False,
-                        error=f"无法读取 {suffix} 文件 {file_path.name}，缺少必要的库。请执行: {hint}"
-                    )
-                if not extracted.strip():
-                    return SkillResult(
-                        success=False,
-                        error=f"文件 {file_path.name} 内容为空（可能是扫描件 PDF 或空文件）"
-                    )
-                total_chars = len(extracted)
-                return SkillResult(
-                    success=True,
-                    data={
-                        "path": str(file_path),
-                        "content": extracted,
-                        "format": suffix,
-                        "total_chars": total_chars,
-                    },
-                    message=f"已读取 {file_path.name} ({suffix})，提取 {total_chars} 字符",
-                )
-
-            # ── 纯文本文件（原有逻辑） ──
-            # 尝试多种编码
-            content = None
-            for enc in [encoding, "utf-8", "gbk", "gb2312", "latin-1"]:
-                try:
-                    with open(file_path, "r", encoding=enc) as f:
-                        content = f.read()
-                    break
-                except (UnicodeDecodeError, UnicodeError):
-                    continue
-                except Exception:
-                    break
-
-            if content is None:
-                return SkillResult(
-                    success=False,
-                    error=f"无法解码文件 {file_path.name}（尝试了 {encoding}/utf-8/gbk/gb2312/latin-1 均失败）"
-                )
-
-            lines = content.splitlines()
-            total_lines = len(lines)
-            selected = lines[offset:offset + limit]
-            text = "\n".join(selected)
-
-            return SkillResult(
-                success=True,
-                data={
-                    "path": str(file_path),
-                    "content": text,
-                    "total_lines": total_lines,
-                    "showed_lines": len(selected),
-                    "offset": offset,
-                },
-                message=f"已读取 {file_path.name} ({len(selected)}/{total_lines} 行)",
-            )
-        except Exception as e:
-            return SkillResult(success=False, error=str(e))
-
-
-class FileWriteSkill(Skill):
-    """写入文件内容"""
-    name = "file_write"
-    description = "将内容写入指定文件，支持创建目录和追加模式"
-    category = "file"
-    parameters = [
-        SkillParameter("path", "string", "文件路径", required=True),
-        SkillParameter("content", "string", "要写入的内容", required=True),
-        SkillParameter("encoding", "string", "文件编码", required=False, default="utf-8"),
-        SkillParameter("append", "boolean", "是否追加模式", required=False, default=False),
-    ]
-    dangerous = True
-
-    async def execute(self, path: str = "", content: str = "",
-                      encoding: str = "utf-8", append: bool = False, **kwargs) -> SkillResult:
-        try:
-            file_path = Path(path).expanduser().resolve()
-            file_path.parent.mkdir(parents=True, exist_ok=True)
-
-            mode = "a" if append else "w"
-            with open(file_path, mode, encoding=encoding) as f:
-                f.write(content)
-
-            return SkillResult(
-                success=True,
-                data={"path": str(file_path), "size": len(content)},
-                message=f"已写入 {file_path.name} ({len(content)} 字符)",
-                files=[str(file_path)],
-            )
-        except Exception as e:
-            return SkillResult(success=False, error=str(e))
-
-
-class FileListSkill(Skill):
-    """列出目录内容
-
-    [v1.16.19] 增加 max_items 限制，防止递归列出时返回过多条目
-    """
-    name = "file_list"
-    description = "列出指定目录下的文件和子目录。递归列出时最多返回 500 条。"
-    category = "file"
-    parameters = [
-        SkillParameter("path", "string", "目录路径", required=True),
-        SkillParameter("pattern", "string", "文件匹配模式(如 *.py)", required=False, default="*"),
-        SkillParameter("recursive", "boolean", "是否递归", required=False, default=False),
-        SkillParameter("max_items", "integer", "最大返回条目数", required=False, default=500),
-    ]
-
-    async def execute(self, path: str = "", pattern: str = "*",
-                      recursive: bool = False, max_items: int = 500, **kwargs) -> SkillResult:
-        try:
-            dir_path = Path(path).expanduser().resolve()
-            if not dir_path.exists():
-                return SkillResult(success=False, error=f"目录不存在: {path}")
-            if not dir_path.is_dir():
-                return SkillResult(success=False, error=f"不是目录: {path}")
-
-            if recursive:
-                items = sorted(dir_path.rglob(pattern))
-            else:
-                items = sorted(dir_path.glob(pattern))
-
-            result = []
-            truncated = False
-            for item in items:
-                if len(result) >= max_items:
-                    truncated = True
-                    break
-                try:
-                    stat = item.stat()
-                    result.append({
-                        "name": item.name,
-                        "path": str(item),
-                        "is_dir": item.is_dir(),
-                        "size": stat.st_size,
-                    })
-                except OSError:
-                    result.append({
-                        "name": item.name,
-                        "path": str(item),
-                        "is_dir": item.is_dir(),
-                        "size": 0,
-                    })
-
-            _msg = f"共 {len(result)} 个项目"
-            if truncated:
-                _msg += f"（已达上限 {max_items}，部分条目未显示）"
-            return SkillResult(
-                success=True,
-                data={"path": str(dir_path), "items": result, "count": len(result), "truncated": truncated},
-                message=_msg,
-            )
-        except Exception as e:
-            return SkillResult(success=False, error=str(e))
-
-
-class FileDeleteSkill(Skill):
-    """删除文件或目录"""
-    name = "file_delete"
-    description = "删除指定文件或目录"
-    category = "file"
-    parameters = [
-        SkillParameter("path", "string", "文件/目录路径", required=True),
-        SkillParameter("recursive", "boolean", "递归删除目录", required=False, default=False),
-    ]
-    dangerous = True
-
-    async def execute(self, path: str = "", recursive: bool = False, **kwargs) -> SkillResult:
-        try:
-            target = Path(path).expanduser().resolve()
-            if not target.exists():
-                return SkillResult(success=False, error=f"不存在: {path}")
-
-            if target.is_dir():
-                if recursive:
-                    shutil.rmtree(target)
-                else:
-                    shutil.rmdir(target)
-            else:
-                target.unlink()
-
-            return SkillResult(
-                success=True,
-                data={"path": str(target), "deleted": True, "was_dir": target.is_dir()},
-                message=f"已删除: {path}",
-            )
-        except Exception as e:
-            return SkillResult(success=False, error=str(e))
-
-
-class FileSearchSkill(Skill):
-    """搜索文件内容
-
-    [v1.16.19] 安全增强:
-    - 搜索深度限制（默认10层，防止遍历整个文件系统）
-    - 排除危险目录（/proc, /sys, /dev 等）
-    - 文件大小限制（跳过>10MB的文件，防止卡在读大文件上）
-    - 超时保护（30秒强制中断）
-    - 搜索根目录 / 时自动警告并缩小范围
-    """
-    name = "file_search"
-    description = "在指定目录的文件中搜索包含指定文本的行。注意：不要搜索 / 根目录，应在具体的子目录中搜索。"
-    category = "file"
-    parameters = [
-        SkillParameter("path", "string", "搜索目录路径", required=True),
-        SkillParameter("query", "string", "搜索关键词或正则表达式", required=True),
-        SkillParameter("pattern", "string", "文件匹配模式(如 *.py, *.txt)", required=False, default="*"),
-        SkillParameter("max_results", "integer", "最大结果数", required=False, default=50),
-        SkillParameter("max_depth", "integer", "最大递归深度(目录层级)", required=False, default=10),
-    ]
-
-    # 排除的系统目录（防止遍历 /proc, /sys 等虚拟文件系统导致卡死）
-    _EXCLUDED_DIRS = {
-        "/proc", "/sys", "/dev", "/run", "/snap", "/boot",
-        "/lib", "/lib64", "/sbin", "/bin", "/usr", "/var/cache",
-    }
-
-    # 不可读的二进制扩展名（跳过，避免读取大文件卡住）
-    _SKIP_EXTENSIONS = {
-        ".pyc", ".pyo", ".whl", ".egg", ".so", ".a", ".o",
-        ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".ico", ".tiff",
-        ".mp3", ".mp4", ".avi", ".mkv", ".mov", ".wmv", ".flv", ".wav", ".ogg",
-        ".zip", ".rar", ".7z", ".tar", ".gz", ".bz2", ".xz",
-        ".exe", ".dll", ".dylib",
-        ".sqlite", ".db",
-        ".iso", ".dmg",
-    }
-
-    async def execute(self, path: str = "", query: str = "", pattern: str = "*",
-                      max_results: int = 50, max_depth: int = 10, **kwargs) -> SkillResult:
-        import time as _time
-
-        _start_time = _time.time()
-        _timeout = 30  # 30 秒超时保护
-
-        try:
-            search_dir = Path(path).expanduser().resolve()
-            if not search_dir.is_dir():
-                return SkillResult(success=False, error=f"不是目录: {path}")
-
-            # [v1.16.19] 安全检查: 禁止搜索根目录和危险路径
-            search_str = str(search_dir)
-            if search_str == "/":
-                return SkillResult(
-                    success=False,
-                    error="不允许搜索根目录 /。请在具体的子目录中搜索，例如 /home 或 /tmp。"
-                )
-            # 检查是否在排除目录下
-            for excl_dir in self._EXCLUDED_DIRS:
-                if search_str == excl_dir or search_str.startswith(excl_dir + "/"):
-                    return SkillResult(
-                        success=False,
-                        error=f"不允许搜索系统目录 {excl_dir}，请在用户目录中搜索。"
-                    )
-
-            results = []
-            _files_scanned = 0
-            _files_skipped = 0
-
-            # 使用 os.walk 替代 rglob，可以精确控制深度
-            for root, dirs, files in os.walk(search_dir):
-                # 检查超时
-                if _time.time() - _start_time > _timeout:
-                    logger.warning(f"file_search 超时 ({_timeout}s)，已扫描 {_files_scanned} 文件")
-                    break
-
-                # 计算当前深度
-                try:
-                    rel_parts = Path(root).relative_to(search_dir).parts
-                    current_depth = len(rel_parts)
-                except ValueError:
-                    current_depth = max_depth + 1
-
-                if current_depth > max_depth:
-                    # 修剪 dirs 列表，阻止 os.walk 继续深入
-                    dirs.clear()
-                    continue
-
-                # 排除系统目录（不进入）
-                dirs[:] = [
-                    d for d in dirs
-                    if not any(str(Path(root) / d).startswith(e) for e in self._EXCLUDED_DIRS)
-                    and not d.startswith(".")  # 跳过隐藏目录
-                    and d not in ("node_modules", "__pycache__", ".git", "venv", ".venv", "env")
-                ]
-
-                for fname in files:
-                    # 再次检查超时
-                    if _time.time() - _start_time > _timeout:
-                        break
-                    if len(results) >= max_results:
-                        break
-
-                    # 文件名模式过滤
-                    if pattern != "*":
-                        if not any(fnmatch.fnmatch(fname, p) for p in pattern.split(",")):
-                            continue
-
-                    file_path = Path(root) / fname
-                    suffix = file_path.suffix.lower()
-
-                    # 跳过不可读的二进制文件
-                    if suffix in self._SKIP_EXTENSIONS:
-                        _files_skipped += 1
-                        continue
-
-                    # 跳过过大的文件（>10MB）
-                    try:
-                        if file_path.stat().st_size > 10 * 1024 * 1024:
-                            _files_skipped += 1
-                            continue
-                    except OSError:
-                        continue
-
-                    _files_scanned += 1
-                    try:
-                        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
-                            for i, line in enumerate(f):
-                                if query.lower() in line.lower():
-                                    results.append({
-                                        "file": str(file_path),
-                                        "line": i + 1,
-                                        "content": line.strip()[:200],
-                                    })
-                                    if len(results) >= max_results:
-                                        break
-                    except (IOError, OSError, PermissionError):
-                        continue
-
-            _elapsed = _time.time() - _start_time
-            logger.debug(f"file_search 完成: {_files_scanned} 文件扫描, {_files_skipped} 跳过, "
-                        f"{len(results)} 匹配, {_elapsed:.1f}s")
-
-            if not results and _files_scanned == 0:
-                return SkillResult(
-                    success=True,
-                    data={"query": query, "results": [], "count": 0, "scanned": 0},
-                    message=f"未找到匹配项（目录中无可搜索的文件）",
-                )
-
-            return SkillResult(
-                success=True,
-                data={"query": query, "results": results, "count": len(results), "scanned": _files_scanned},
-                message=f"找到 {len(results)} 处匹配（扫描 {_files_scanned} 个文件，耗时 {_elapsed:.1f}s）",
-            )
-        except Exception as e:
-            return SkillResult(success=False, error=str(e))
-
-
-class FileMoveSkill(Skill):
-    """移动/重命名文件"""
-    name = "file_move"
-    description = "移动或重命名文件/目录"
-    category = "file"
-    parameters = [
-        SkillParameter("source", "string", "源路径", required=True),
-        SkillParameter("destination", "string", "目标路径", required=True),
-    ]
-    dangerous = True
-
-    async def execute(self, source: str = "", destination: str = "", **kwargs) -> SkillResult:
-        try:
-            src = Path(source).expanduser().resolve()
-            dst = Path(destination).expanduser().resolve()
-            dst.parent.mkdir(parents=True, exist_ok=True)
-            shutil.move(str(src), str(dst))
-            return SkillResult(
-                success=True,
-                data={"source": str(src), "destination": str(dst)},
-                message=f"已移动: {source} → {destination}",
-            )
-        except Exception as e:
-            return SkillResult(success=False, error=str(e))