ot-cli 0.2.1__py3-none-any.whl

openterminal/__init__.py

@@ -0,0 +1,3 @@
+"""OpenTerminal: 自然语言终端 Agent。"""
+
+__version__ = "0.2.1"

openterminal/agent/__init__.py

@@ -0,0 +1,39 @@
+"""agent 域（阶段二 Task 14 重组；终审修复改惰性再导出）。
+
+runner.py——TaskRunner 任务执行与超时看护；build.py——智能体组装
+（build_agent/_with_skills）；middleware.py——审批/拒绝与异常重试中间件；
+prompt.py——系统提示词；model.py——聊天模型工厂；backend.py——
+PtyShellBackend（PTY 桥接 deepagents 工具后端）；token_est.py——token
+计数；sysprobe.py——系统档案探测/缓存与手动预设。
+
+__init__ 用 PEP 562 惰性转发旧 ``agent`` 模块全部公开名——按名字路由到
+所属子模块，且不可急切导入 runner：deepagents/langchain 导入约 4.6s，
+而 core/pipeline.py 模块级 ``from ..agent.sysprobe import ...`` 必先执行
+本 __init__，急切导入会把 AI 栈拖进每次 CLI/Web 启动（击穿 _load_agent_stack
+惰性机制）。sysprobe/token_est 为独立子模块直接导入，不进 __getattr__。
+
+实现注记：转发必须经 importlib.import_module，不能 ``from . import
+runner``——后者的 fromlist 处理对未知名会再触发本 __getattr__，
+形成递归（PEP 562 已知坑）。
+"""
+
+from importlib import import_module
+from typing import Any
+
+# 公开名 → 所属子模块；未登记的名字（TaskRunner/TaskEvent/AGENT_STALL_*
+# 等）默认落在 runner。显式登记保证访问 build_agent 只导入 build.py，
+# 不把 4.6s 的 runner（deepagents/langchain）拖进惰性路径。
+_NAME_MODULE: dict[str, str] = {
+    "build_agent": ".build",
+    "_with_skills": ".build",
+    "DenyMiddleware": ".middleware",
+    "ToolErrorRetryMiddleware": ".middleware",
+    "build_system_prompt": ".prompt",
+    "_DIALECT_TABLE": ".prompt",
+    "build_chat_model": ".model",
+}
+
+
+def __getattr__(name: str) -> Any:
+    module = import_module(_NAME_MODULE.get(name, ".runner"), __name__)
+    return getattr(module, name)

openterminal/agent/backend.py

@@ -0,0 +1,180 @@
+"""把 ShellSession 适配成 deepagents 的 SandboxBackendProtocol。"""
+
+from __future__ import annotations
+
+import asyncio
+import re
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+
+from deepagents.backends import LocalShellBackend
+from deepagents.backends.protocol import (
+    DeleteResult,
+    EditResult,
+    ExecuteResponse,
+    GlobResult,
+    GrepResult,
+    LsResult,
+    ReadResult,
+    WriteResult,
+)
+
+from ..session.base import ShellSession
+
+# 带盘符的路径段（`C:`、`/C:/...`、`\\?\C:\...`）：deepagents 的路径拼接遇到它
+# 会换锚，把结果带出 root
+_DRIVE_SEG_RE = re.compile(r"(?:^|[/\\])[A-Za-z]:")
+
+
+def _local_root(root_dir: str | None, session: ShellSession,
+                remote_target: bool) -> Path:
+    """read_file/write_file 等文件工具的**本机**根目录（虚拟路径 /x 的锚点）。
+
+    只有本机真实存在的绝对目录才配当根：SSH（含嵌套 ssh）会话的 cwd 是远端
+    路径，拿来当根会在本机解析出影子目录——Windows 上 ``Path("/tmp")`` 是无
+    盘符路径，resolve 出 ``<当前盘>:\\tmp``——甚至按远端路径树在本机凭空
+    mkdir。远端目标一律回退到用户主目录：「下载到我本机」的落点，且
+    /Downloads、/Desktop、/Documents 都在根内可写。
+    """
+    if root_dir is not None:
+        # 显式指定照办（测试/调用方自知其意），只做规范化，不改语义
+        return Path(root_dir).expanduser().resolve()
+    cand = "" if remote_target else (getattr(session, "cwd", "") or "")
+    if cand:
+        try:
+            p = Path(cand).expanduser()
+            if p.is_absolute() and p.is_dir():
+                return p.resolve()
+        except (OSError, RuntimeError, ValueError):
+            pass
+    return Path.home()
+
+
+class PtyShellBackend(LocalShellBackend):
+    """文件操作沿用 LocalShellBackend；execute 走持久 PTY 会话。
+
+    文件根是**本机**目录，构造时定死、此后不再跟随 shell 的 cd：虚拟路径
+    /x 的含义必须全程稳定；且 execute 回报的 cwd 可能来自远端 shell，覆盖根
+    会把根打成无盘符/远端路径，之后所有文件工具在 ``relative_to`` 判据下集体
+    报「outside root directory」（真机「write_file ×失败」根因）。
+
+    SSH 模式下注意：内置文件工具作用于本机，Agent 系统提示词中已要求
+    远程文件操作一律走 execute。
+    """
+
+    def __init__(self, session: ShellSession, root_dir: str | None = None, *,
+                 remote_target: bool = False) -> None:
+        super().__init__(root_dir=_local_root(root_dir, session, remote_target),
+                         inherit_env=True)
+        self.session = session
+        # CLI 在任务开始前设置、结束后清空（rich console 实时打印）
+        self.on_output: Callable[[str], None] | None = None
+        # 命令实际开始执行（审批通过之后）/结束（带 exit code）时的同步回调，
+        # 供展示层打印“执行”面板、按成败切换详述模式
+        self.on_start: Callable[[str], None] | None = None
+        self.on_finish: Callable[[str, int], None] | None = None
+        # 命令注入前的异步门闩：worker 用它等前端把流底分析卡结账垫满
+        # （ai_boundary/boundary_settled 往返），保证命令回显在 PTY 里落在
+        # pad 空行之后——回显先于空行进缓冲会把卡的连续空白区打断=永久盖帽
+        self.on_boundary: Callable[[], Awaitable[None]] | None = None
+
+    def _resolve_path(self, key: str) -> Path:
+        """越界路径判据补一层：带盘符的段直接判越界。
+
+        deepagents 的 `root / key` 拼接遇 `C:/...` 会换锚跳走，工具层
+        validate_path 只挡 `^[a-zA-Z]:` 开头，挡不住 `/C:/Users/x` 这类「过了
+        校验、解析却越界」的路径（docs/bug.md 上传场景那类）。根落在 C: 盘时
+        它会真逃出沙箱——实测能列出/写入真实桌面。这里与越界路径同口径拒绝，
+        由调用方包成 error 结果回模型。
+        """
+        if _DRIVE_SEG_RE.search(str(key)):
+            raise ValueError(
+                f"Path:{key} outside root directory: {self.cwd}")
+        return super()._resolve_path(key)
+
+    # --- 文件操作：路径 ValueError 不上抛，包成 error 结果 ---
+    # deepagents 的 FilesystemBackend._resolve_path 对越界/穿越路径抛
+    # ValueError，而 read/write 等只兜 (OSError, RuntimeError)；工具层的
+    # validate_path 又拦不住 `/C:/...` 这类「过了校验、解析却越界」的路径
+    # （Windows 桌面文件上传场景的「任务失败：ValueError」根因）。backend
+    # 契约是返回 error 结果而非抛异常——这里补上，模型看到错误文本后自行
+    # 换方案；其余未预期异常交给 ToolErrorRetryMiddleware 统一收口。
+
+    def read(self, file_path: str, offset: int = 0, limit: int = 2000) -> ReadResult:
+        try:
+            return super().read(file_path, offset=offset, limit=limit)
+        except ValueError as e:
+            return ReadResult(error=f"Error reading file '{file_path}': {e}")
+
+    def write(self, file_path: str, content: str) -> WriteResult:
+        try:
+            return super().write(file_path, content)
+        except ValueError as e:
+            return WriteResult(error=f"Error writing file '{file_path}': {e}")
+
+    def edit(self, file_path: str, old_string: str, new_string: str,
+             replace_all: bool = False) -> EditResult:
+        try:
+            return super().edit(file_path, old_string, new_string, replace_all)
+        except ValueError as e:
+            return EditResult(error=f"Error editing file '{file_path}': {e}")
+
+    def delete(self, file_path: str) -> DeleteResult:
+        try:
+            return super().delete(file_path)
+        except ValueError as e:
+            return DeleteResult(error=f"Error deleting '{file_path}': {e}")
+
+    def ls(self, path: str) -> LsResult:
+        try:
+            return super().ls(path)
+        except ValueError as e:
+            return LsResult(error=f"Cannot list '{path}': {e}", entries=None)
+
+    def glob(self, pattern: str, path: str | None = None) -> GlobResult:
+        try:
+            return super().glob(pattern, path=path)
+        except ValueError as e:
+            return GlobResult(error=f"Error globbing '{pattern}': {e}")
+
+    def grep(self, pattern: str, path: str | None = None, glob: str | None = None,
+             *, max_count: int | None = None, context_lines: int = 0) -> GrepResult:
+        try:
+            return super().grep(pattern, path=path, glob=glob,
+                                max_count=max_count, context_lines=context_lines)
+        except ValueError as e:
+            return GrepResult(error=f"Error searching '{pattern}': {e}", matches=[])
+
+    async def aexecute(self, command: str, *, timeout: int | None = None) -> ExecuteResponse:
+        if self.on_boundary is not None:
+            await self.on_boundary()
+        if self.on_start is not None:
+            self.on_start(command)
+        try:
+            result = await self.session.run(
+                command, timeout=timeout, on_output=self.on_output
+            )
+        except BaseException:
+            # 取消/异常路径也要收束输出块括号（term_close），否则前端
+            # _cmdOut 悬空，后续终端字节会被误写进僵尸输出块
+            if self.on_finish is not None:
+                self.on_finish(command, 130)
+            raise
+        # 这里刻意不动 self.cwd：文件根构造时定死（见类文档）。曾经的
+        # `self.cwd = Path(result.cwd)` 会把远端 shell 的 cwd（/tmp 这类无盘符
+        # 路径）灌成本机根，随后每个文件工具都因 relative_to 判据失败而报
+        # 「outside root directory: \\tmp」——真机 write_file 连续 ×失败 的根因。
+        if self.on_finish is not None:
+            self.on_finish(command, result.exit_code)
+        return ExecuteResponse(
+            output=result.output,
+            exit_code=result.exit_code,
+            truncated=result.truncated,
+        )
+
+    def execute(self, command: str, *, timeout: int | None = None) -> ExecuteResponse:
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.run(self.aexecute(command, timeout=timeout))
+        raise RuntimeError("同步 execute() 不能在事件循环内调用，请用 aexecute()")

openterminal/agent/build.py

@@ -0,0 +1,115 @@
+"""agent 装配：组件黏合成可执行的 LangGraph 智能体（从 runner.py 拆出）。
+
+build_agent 编排 prompt/model/middleware/backend → create_deep_agent；
+_with_skills 给文件后端挂代理 Skills。只在真正构建 agent 时 import。
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from deepagents import create_deep_agent
+from deepagents.backends import CompositeBackend, FilesystemBackend
+from deepagents.middleware.skills import SkillsMiddleware
+from langchain.agents.middleware import (
+    HumanInTheLoopMiddleware,
+    ModelRetryMiddleware,
+)
+from langgraph.checkpoint.memory import MemorySaver
+
+from ..config import Config
+from ..policy import Policy
+from ..skills import skill_routes, skill_sources
+from .backend import PtyShellBackend
+from .middleware import DenyMiddleware, ToolErrorRetryMiddleware
+from .model import build_chat_model
+from .prompt import build_system_prompt
+from .sysprobe import SystemProfile
+
+
+def build_agent(
+    profile: SystemProfile,
+    session,
+    cfg: Config,
+    policy: Policy | None = None,
+    *,
+    model: Any = None,
+    remote_target: bool = False,
+):
+    """返回 (compiled_agent, session_allowed_commands)。
+
+    remote_target：目标是 SSH/远端 shell——此时 session.cwd 是远端路径，不能当
+    本机文件根（见 backend._local_root），文件工具回退到用户主目录。
+    """
+    policy = policy or Policy(
+        mode=cfg.policy.mode,
+        auto_extra=cfg.policy.auto_extra,
+        approve_extra=cfg.policy.approve_extra,
+        deny_extra=cfg.policy.deny_extra,
+    )
+    allowed: set[str] = set()
+    backend = PtyShellBackend(session, remote_target=remote_target)
+
+    def _when(req) -> bool:
+        cmd = req.tool_call.get("args", {}).get("command", "")
+        return policy.needs_approval(cmd, allowed)
+
+    def _description(tc, state, runtime) -> str:
+        cmd = tc.get("args", {}).get("command", "")
+        reasons = "；".join(policy.classify(cmd).reasons) or "高危命令"
+        return f"高危命令需要审批\n\n目标主机：{profile.host}\n风险点：{reasons}\n命令：{cmd}"
+
+    middleware = [
+        # 最外层：任何工具链异常先在这里收口成 ToolMessage，不再打死任务
+        ToolErrorRetryMiddleware(max_retries=3),
+        DenyMiddleware(policy),
+    ]
+
+    def _model_failure(exc: Exception) -> str:
+        # on_failure 只拿到异常；文案对齐「任务失败」口径，成为最终回复
+        return (f"任务失败：模型调用重试 3 次仍未成功"
+                f"（{type(exc).__name__}: {exc}）。"
+                f"请稍后重试；若持续失败请检查模型网关配置。")
+
+    # 模型 API 侧（网关抖动/限流/超时）独立重试，不与工具层重试混计
+    middleware.append(ModelRetryMiddleware(
+        max_retries=3, on_failure=_model_failure,
+    ))
+    middleware.append(HumanInTheLoopMiddleware(interrupt_on={"execute": {
+        "allowed_decisions": ["approve", "edit", "reject"],
+        "when": _when,
+        "description": _description,
+    }}))
+
+    agent = create_deep_agent(
+        model=model or build_chat_model(cfg.model),
+        backend=_with_skills(backend, middleware),
+        # 本机文件根一并告知模型：虚拟路径落地在本机哪里必须能向用户交代，
+        # 否则「下载到我本机」写完只报 /x，用户在磁盘上找不到文件
+        system_prompt=build_system_prompt(profile, str(backend.cwd)),
+        middleware=middleware,
+        checkpointer=MemorySaver(),
+    )
+    return agent, allowed, backend
+
+
+def _with_skills(backend: PtyShellBackend, middleware: list):
+    """给 agent 挂上内置/用户两层 Agent Skills（渐进式披露）。
+
+    skill 目录在文件沙箱（shell cwd）之外，故经 CompositeBackend 以
+    /skills/... 虚拟前缀挂进文件系统：SkillsMiddleware 把 skill 清单
+    注入系统提示词，模型按需 read_file 加载 SKILL.md 全文；用户目录
+    后挂，同名 skill 覆盖内置。backend 本身原样返回给调用方（回调、
+    cwd 语义不变），composite 只作为 agent 的文件/命令入口。
+    """
+    routes = skill_routes()
+    if not routes:
+        return backend
+    agent_backend: Any = CompositeBackend(
+        default=backend,
+        routes={p: FilesystemBackend(root_dir=str(d)) for p, d in routes.items()},
+    )
+    middleware.append(
+        SkillsMiddleware(backend=agent_backend, sources=skill_sources())
+    )
+    return agent_backend

openterminal/agent/middleware.py

@@ -0,0 +1,111 @@
+"""agent 中间件：审批/拒绝（DenyMiddleware）与异常重试（ToolErrorRetryMiddleware）。
+
+从 runner.py 拆出（一事一文件）。两类都做 wrap_tool_call 包装，挂进
+create_deep_agent 的工具链；纯工具层逻辑，不依赖任务执行。
+"""
+
+from __future__ import annotations
+
+from langchain.agents.middleware import AgentMiddleware
+from langchain_core.messages import ToolMessage
+from langgraph.errors import GraphBubbleUp
+
+from ..policy import Policy
+
+
+class DenyMiddleware(AgentMiddleware):
+    """灾难命令：不执行，直接把拒绝原因作为 tool 错误回模型。"""
+
+    def __init__(self, policy: Policy) -> None:
+        self.policy = policy
+
+    async def awrap_tool_call(self, request, handler):
+        tc = request.tool_call
+        if tc.get("name") == "execute":
+            cmd = tc.get("args", {}).get("command", "")
+            d = self.policy.classify(cmd)
+            if d.level == "deny":
+                return ToolMessage(
+                    content=f"命令被 OpenTerminal 安全策略拒绝：{cmd}\n原因："
+                            f"{'；'.join(d.reasons)}。请换一个方案，不要换皮重试。",
+                    tool_call_id=tc["id"],
+                    status="error",
+                )
+        return await handler(request)
+
+
+class ToolErrorRetryMiddleware(AgentMiddleware):
+    """工具执行异常→错误 ToolMessage 回模型重试；用尽后宣告任务失败让模型总结。
+
+    约定（产品诉求）：异常不得直接打死任务。前 max_retries 次失败把异常
+    信息交给模型，由它换方案重试；第 max_retries+1 次失败返回「任务失败」
+    并要求模型停止调用工具、总结失败原因。langgraph 控制流（HITL 中断等）
+    原样上抛，不吞。
+    """
+
+    def __init__(self, max_retries: int = 3) -> None:
+        self.max_retries = max_retries
+        self._failures = 0
+        self._gave_up = False
+
+    def before_agent(self, state, runtime) -> dict | None:
+        # 计数按任务（一次 run/resume 驱动）清零，跨任务不累积
+        self._failures = 0
+        self._gave_up = False
+        return None
+
+    async def abefore_agent(self, state, runtime) -> dict | None:
+        self._failures = 0
+        self._gave_up = False
+        return None
+
+    def _reject(self, tc: dict) -> ToolMessage:
+        return ToolMessage(
+            content="任务失败：重试次数已用尽。请勿再调用工具，"
+                    "直接向用户总结失败原因（已尝试的操作、错误信息和建议）。",
+            tool_call_id=tc["id"],
+            name=tc.get("name", "tool"),
+            status="error",
+        )
+
+    def _feedback(self, tc: dict, exc: Exception) -> ToolMessage:
+        name = tc.get("name", "tool")
+        self._failures += 1
+        detail = f"{type(exc).__name__}: {exc}"
+        if self._failures <= self.max_retries:
+            content = (
+                f"工具 {name} 执行出错（第 {self._failures}/{self.max_retries} 次失败）："
+                f"{detail}\n请根据错误信息调整参数或换一种方案后重试。"
+            )
+        else:
+            self._gave_up = True
+            content = (
+                f"任务失败：已重试 {self.max_retries} 次仍无法完成，不再重试。\n"
+                f"最后一次错误：{detail}\n"
+                f"请停止尝试，向用户总结失败原因（已尝试的操作、错误信息和建议）。"
+            )
+        return ToolMessage(
+            content=content, tool_call_id=tc["id"], name=name, status="error",
+        )
+
+    def wrap_tool_call(self, request, handler):
+        tc = request.tool_call
+        if self._gave_up:
+            return self._reject(tc)
+        try:
+            return handler(request)
+        except GraphBubbleUp:
+            raise
+        except Exception as e:  # noqa: BLE001 - 异常转 tool 错误回模型
+            return self._feedback(tc, e)
+
+    async def awrap_tool_call(self, request, handler):
+        tc = request.tool_call
+        if self._gave_up:
+            return self._reject(tc)
+        try:
+            return await handler(request)
+        except GraphBubbleUp:
+            raise
+        except Exception as e:  # noqa: BLE001 - 异常转 tool 错误回模型
+            return self._feedback(tc, e)

openterminal/agent/model.py

@@ -0,0 +1,41 @@
+"""聊天模型构造（从 runner.py 拆出）。
+
+build_chat_model 独依赖 ModelConfig；anthropic 分支的 ChatAnthropic 在
+模块级导入（同原 runner.py），openai 分支在分支内惰性导入。model 只在
+真正构建 agent 时被 import（build.py 或测试直引），不落在 core 启动热路径。
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from langchain_anthropic import ChatAnthropic
+
+from ..config import ModelConfig
+
+
+def build_chat_model(cfg: ModelConfig) -> Any:
+    """按 cfg.provider 构造 langchain 聊天模型。
+
+    anthropic → ChatAnthropic（缺省，走 base_url 网关）；openai → ChatOpenAI，
+    任何 OpenAI 兼容协议网关（base_url 留空则用 SDK 官方端点）。langchain_openai
+    在分支内惰性导入：anthropic 配置既不付导入耗时也不要求安装该包。
+    """
+    # .env 直配的 key 优先（项目 .env > ~/.openterminal/.env）；否则走环境变量
+    api_key = cfg.api_key or os.environ.get(cfg.api_key_env, "not-set")
+    if cfg.provider == "openai":
+        from langchain_openai import ChatOpenAI
+
+        return ChatOpenAI(
+            model=cfg.model,
+            base_url=cfg.base_url or None,
+            api_key=api_key,
+            max_tokens=4096,
+        )
+    return ChatAnthropic(
+        model=cfg.model,
+        base_url=cfg.base_url,
+        api_key=api_key,
+        max_tokens=4096,
+    )

openterminal/agent/prompt.py

@@ -0,0 +1,63 @@
+"""系统提示词构建（从 runner.py 拆出）。
+
+方言映射表与 build_system_prompt 只依赖 SystemProfile（sysprobe 纯数据
+结构），不触碰 deepagents/langchain 运行时，可安全独立导入。
+"""
+
+from __future__ import annotations
+
+from .sysprobe import SystemProfile
+
+_DIALECT_TABLE = """
+| 意图 | debian/Ubuntu | rhel CentOS7 | rhel Rocky/Fedora | alpine | darwin |
+|---|---|---|---|---|---|
+| 安装软件 jq | sudo apt-get install -y jq | sudo yum install -y jq | sudo dnf install -y jq | sudo apk add jq | brew install jq |
+| 重启 nginx | sudo systemctl restart nginx | 同左 | 同左 | sudo rc-service nginx restart | brew services restart nginx |
+| 查监听端口 | ss -ltnp | netstat -ltnp | ss -ltnp | netstat -ltnp | lsof -i |
+"""
+
+
+def build_system_prompt(p: SystemProfile, local_root: str | None = None) -> str:
+    tools = ", ".join(sorted(p.tools)) or "未探测到额外工具"
+    root_line = (f"- 本机文件根目录：`{local_root}`。工具里的路径是以它为锚的虚拟路径："
+                 f"`/x/y.txt` 实际落在 `{local_root}/x/y.txt`。"
+                 if local_root else
+                 "- 文件工具里的路径是以本机文件根目录为锚的虚拟路径。")
+    return f"""你是 OpenTerminal，一个运行在用户自带终端里的运维助手。
+
+## 当前目标系统
+- 主机：{p.host}
+- 系统：{p.distro}（family={p.os_family}, version={p.version}, kernel={p.kernel}）
+- 包管理器：{p.pkg_manager}；服务管理器：{p.service_mgr}；shell：{p.shell}
+- 已探测工具：{tools}
+
+## 本机文件工具（read_file / write_file / edit_file / ls / glob / grep）
+1. 它们作用于**运行本程序的本机**，不是上面的目标主机；目标主机上的文件一律用
+   execute 读写（cat/sed/tee 等），不要用这些文件工具。
+2. {root_line}
+3. 用户要把文件**下载到本机**时：先用 execute 取到内容，再 write_file 写到
+   `/Downloads/<文件名>`；上传反之（read_file 读本机文件，经 execute 写到目标主机）。
+4. 文件交到用户手上时，回复里必须给出**真实绝对路径**（根目录 + 虚拟路径），让用户
+   能在磁盘上找到它；根目录之外的本机路径读不到也写不了，遇到就如实说明。
+5. 例外：/skills/ 挂载的 SKILL.md 按 Skills 清单指引正常用 read_file 加载。
+
+## 命令翻译规则
+1. 所有命令必须适配上面的系统画像，禁止在非 debian 系上使用 apt。
+2. 方言映射：
+{_DIALECT_TABLE}
+3. 软件安装/服务操作/删除等高危命令会触发用户审批，命令要尽量短小、可读。
+4. 目标主机上的文件读写见「本机文件工具」第 1 条：一律走 execute，不用
+   read_file/write_file。
+5. 命令失败时：先读懂 stderr 与 exit code，再换方案；同一个失败命令原样重试不超过
+   一次；`command not found` 先用 `command -v` 探测；包管理器报错先核对系统画像。
+6. 被安全策略拒绝或被用户拒绝的命令不得换皮重试，要给出替代方案或向用户说明。
+7. 任务完成后用一句中文总结结果；没有完成时说明已尝试的命令、失败原因和建议。
+8. 结论与多条命令的分析结果要美化输出：适合表格呈现的数据（多项对比、结果汇总、
+   参数/指标列表）整理成 Markdown 表格，而不是堆文字；排版前可先 read_file 加载
+   markdown-tables skill（见 Skills 清单）按其规范书写。小节标题单独成行并用 `##`
+   开头（如 `## 内存使用`，可带 emoji）；结尾「结论」等段落用普通段落、关键短语加粗。
+9. 命令保持简单、可读：够用就好，不要画蛇添足。除非用户明确要求，不加单位换算、
+   computed property、内联脚本块、多余管道或 && 拼接，也不手动格式化输出——交给
+   系统默认即可。PowerShell 优先短别名（Sort/Select/Where），POSIX 优先基础命令
+   （ls/find/grep/df）。清晰胜过炫技：用户要的是结果，不是一行看起来很专业的命令。
+"""