@armadra/agent 0.7.6 → 0.8.1

package/dist/bundle/ama.cjs

@@ -41,7 +41,7 @@ var AMA_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    AMA_VERSION = true ? "0.7.6" : readPackageVersion();
+    AMA_VERSION = true ? "0.8.1" : readPackageVersion();
   }
 });
 
@@ -3712,8 +3712,8 @@ var init_config_keys = __esm({
       version: "Config file format version; always 1",
       defaultModel: "Default model provider/model or provider/model@channel; when unset it is picked automatically (ama config show shows which one and why)",
       thinkingLevel: "Thinking level",
-      providers: "Custom providers and overrides of built-in providers (docs/providers.md)",
-      permission: "Permissions (docs/permissions.md)",
+      providers: "Custom providers and overrides of built-in providers (docs/guides/providers.md)",
+      permission: "Permissions (docs/guides/permissions.md)",
       "permission.mode": "Permission mode; project level can only make it stricter",
       "permission.allow": "Allow rules, e.g. bash(npm test); cannot be added at project level",
       "permission.deny": "Deny rules, e.g. write(**/.env); accumulated across levels",
@@ -3740,7 +3740,7 @@ var init_config_keys = __esm({
       "tools.maxToolResultChars": "Character limit for one tool result in the context; beyond it head and tail are kept",
       "tools.bashTimeoutMs": "Default bash timeout (ms; overridable per call, max 600000)",
       "tools.disabled": "Disabled tool names; accumulated across levels",
-      codemode: "codemode: the model writes scripts that call tools in batches (docs/codemode.md)",
+      codemode: "codemode: the model writes scripts that call tools in batches (docs/guides/codemode.md)",
       "codemode.mode": "off | on | only; when unset it follows the preset: default → on (Node ≥ 25; Node 22 / 24 → off), codemode-only → only, minimal / coordinator → off; project level only accepts off",
       "codemode.inlineBudget": "Budget (estimated tokens) for inlining tool declarations in the description in only mode; beyond it only names are listed",
       "codemode.requireStrict": "true: disable codemode when the runtime Node does not isolate the network (Node 22 / 24)",
@@ -3764,7 +3764,7 @@ var init_config_keys = __esm({
       "ui.language": "Interface language: auto decides from LC_ALL / LC_MESSAGES / LANG (zh* is Chinese, anything else English), zh, en; AMA_LANG and --lang override; affects the interface only, text sent to the model is always English",
       "ui.replyLanguage": "Reply language for the model (e.g. Chinese): one English rule is appended to the end of the rules section at session start; zero-byte change when unset; user level only (effective from wave 6)",
       "ui.agentBar": "Agent bar (sub-agent list above the status line): auto shows it while tasks exist, off hides it; press ↓ on an empty input to enter it",
-      memory: "Cross-session memory (docs/memory.md): off by default, requests are byte-identical while off; project level can only set enabled: false (effective from wave 6 W6-M)",
+      memory: "Cross-session memory (docs/guides/memory.md): off by default, requests are byte-identical while off; project level can only set enabled: false (effective from wave 6 W6-M)",
       "memory.enabled": "Master switch; --memory / --no-memory and AMA_MEMORY=0|1 override",
       "memory.scopes": "Enabled scopes: user (data directory, across projects), project (keyed by a hash of the repository path)",
       "memory.indexMaxBytes": "Per-scope limit for the index in the system prompt (bytes); truncated by update time beyond it",
@@ -3790,11 +3790,11 @@ var init_config_keys = __esm({
       "cache.minSavingsUsd": "Minimum expected savings (USD) for warming",
       "cache.missNotices": "Show cache misses and remaining context in the message area",
       "cache.warmSubagents": "Also warm sub-sessions (task)",
-      checkpoints: 'Checkpoints: file backups used to roll back code (docs/sessions.md "Checkpoints and file backups")',
+      checkpoints: 'Checkpoints: file backups used to roll back code (docs/guides/sessions.md "Checkpoints and file backups")',
       "checkpoints.mode": "tools: track files changed by edit / write; shadow-git: also snapshot the whole working directory with a shadow git so direct changes (bash etc.) can be rolled back too (needs git; large directories fall back to tools); off: disabled; AMA_CHECKPOINTS overrides; project level only accepts off",
       "checkpoints.maxFileBytes": "Backup limit for a single file (bytes); larger files are not backed up and rollback reports them as unrecoverable; project level can only lower it",
       "checkpoints.keep": "Number of recent checkpoints available for rollback; older ones are no longer listed; user level / profile only",
-      sandbox: 'OS-level sandbox (docs/sandbox.md); user level / profile only, project level only accepts network: "deny"',
+      sandbox: 'OS-level sandbox (docs/guides/sandbox.md); user level / profile only, project level only accepts network: "deny"',
       "sandbox.enabled": "auto: use macOS sandbox-exec / Linux bwrap or unshare when available (codemode child processes are denied network and writes; this isolates codemode's network on Node 22 / 24); off: not used; AMA_SANDBOX=off overrides",
       "sandbox.bash": "auto: run bash through sandbox-exec / bwrap (unshare does not count), writes limited to the workspace, temp dir, output dir and sandbox.writable, and sandboxed commands need no approval in default mode; off: not used; user level / profile only",
       "sandbox.network": "Network inside the bash sandbox: deny blocks it (required for approval-free sandboxed commands); allow permits network but writes stay limited and approval works as usual; project level can only set deny",
@@ -3841,8 +3841,8 @@ var init_config_keys = __esm({
       version: "配置文件格式版本，固定为 1",
       defaultModel: "缺省模型 provider/model 或 provider/model@channel；不写时零配置自动选择（ama config show 显示选了谁、为什么）",
       thinkingLevel: "思考强度",
-      providers: "自定义供应商与对内置供应商的覆盖（docs/providers.md）",
-      permission: "权限（docs/permissions.md）",
+      providers: "自定义供应商与对内置供应商的覆盖（docs/guides/providers.md）",
+      permission: "权限（docs/guides/permissions.md）",
       "permission.mode": "权限模式；项目级只能更严",
       "permission.allow": "放行规则，如 bash(npm test)；项目级不能加",
       "permission.deny": "拒绝规则，如 write(**/.env)；各层累加",
@@ -3869,7 +3869,7 @@ var init_config_keys = __esm({
       "tools.maxToolResultChars": "单条工具结果进上下文的字符上限，超出保留首尾",
       "tools.bashTimeoutMs": "bash 缺省超时（毫秒，单次调用可覆盖，最大 600000）",
       "tools.disabled": "禁用的工具名；各层累加",
-      codemode: "codemode：模型写脚本批量调用工具（docs/codemode.md）",
+      codemode: "codemode：模型写脚本批量调用工具（docs/guides/codemode.md）",
       "codemode.mode": "off | on | only；不写时跟随预设：default → on（Node ≥ 25；Node 22 / 24 → off）、codemode-only → only、minimal / coordinator → off；项目级只接受 off",
       "codemode.inlineBudget": "only 模式在描述里内联工具声明的预算（估算 token），超出只列名字",
       "codemode.requireStrict": "true：运行时 Node 不隔离网络（Node 22 / 24）时直接禁用 codemode",
@@ -3893,7 +3893,7 @@ var init_config_keys = __esm({
       "ui.language": "界面语言：auto 按 LC_ALL / LC_MESSAGES / LANG 判断（zh* 为中文，其余英文），zh，en；AMA_LANG、--lang 覆盖；只影响界面，发给模型的文本固定英文",
       "ui.replyLanguage": "模型回复语言（如 Chinese）：会话开始在 rules 节末尾追加一句英文规则；不设时零字节变化；只认用户级（第六波起生效）",
       "ui.agentBar": "Agent 栏（状态行上方的子 Agent 列表）：auto 有任务时显示，off 不显示；空输入时按 ↓ 进入",
-      memory: "跨会话记忆（docs/memory.md）：缺省关闭，关闭时请求逐字节不变；项目级只能设 enabled: false（第六波 W6-M 起生效）",
+      memory: "跨会话记忆（docs/guides/memory.md）：缺省关闭，关闭时请求逐字节不变；项目级只能设 enabled: false（第六波 W6-M 起生效）",
       "memory.enabled": "总开关；--memory / --no-memory、AMA_MEMORY=0|1 覆盖",
       "memory.scopes": "启用的作用域：user（数据目录，跨项目）、project（按仓库路径哈希）",
       "memory.indexMaxBytes": "每作用域索引进系统提示的上限（字节），超出按更新时间截断",
@@ -3919,11 +3919,11 @@ var init_config_keys = __esm({
       "cache.minSavingsUsd": "保温的最低期望节省（美元）",
       "cache.missNotices": "在消息区提示缓存未命中与上下文余量",
       "cache.warmSubagents": "子会话（task）也保温",
-      checkpoints: "检查点：回滚代码用的文件备份（docs/sessions.md「检查点与文件备份」）",
+      checkpoints: "检查点：回滚代码用的文件备份（docs/guides/sessions.md「检查点与文件备份」）",
       "checkpoints.mode": "tools：跟踪 edit / write 改过的文件；shadow-git：另用影子 git 快照整个工作目录，bash 等直接改动也能回滚（需要 git，大目录自动降级为 tools）；off：关闭；AMA_CHECKPOINTS 覆盖；项目级只接受 off",
       "checkpoints.maxFileBytes": "单个文件的备份上限（字节），超出不备份、回滚时报告无法恢复；项目级只能调小",
       "checkpoints.keep": "可回滚的最近检查点数，更早的不再列为回滚点；只认用户级 / profile",
-      sandbox: '操作系统级沙箱（docs/sandbox.md）；只认用户级 / profile，项目级只接受 network: "deny"',
+      sandbox: '操作系统级沙箱（docs/guides/sandbox.md）；只认用户级 / profile，项目级只接受 network: "deny"',
       "sandbox.enabled": "auto：探测到可用的 macOS sandbox-exec / Linux bwrap、unshare 就用（codemode 子进程拒绝网络与写入；Node 22 / 24 上 codemode 因此网络隔离）；off：不用；AMA_SANDBOX=off 覆盖",
       "sandbox.bash": "auto：bash 经 sandbox-exec / bwrap 运行（unshare 不算），写入只限工作区、临时目录、输出目录与 sandbox.writable，default 模式下沙箱内命令免审批；off：不用；只认用户级 / profile",
       "sandbox.network": "bash 沙箱里的网络：deny 拒绝（沙箱内免审批的前提）；allow 允许联网但写入仍受限、照常审批；项目级只能设 deny",
@@ -4085,7 +4085,7 @@ var init_config = __esm({
       /** config.schema.json 里供应商内部字段的说明（顶层与各段的键用 `keys`）。 */
       jsonSchema: {
         api: "Protocol",
-        compat: 'Protocol compatibility switches (docs/providers.md "compat")',
+        compat: 'Protocol compatibility switches (docs/guides/providers.md "compat")',
         modelId: "Model id (the name sent upstream)",
         modelBaseUrl: "Overrides the channel / provider address",
         contextWindow: "Context tokens; filled from models.dev by default, not guessed when there is no match",
@@ -4201,7 +4201,7 @@ var init_config = __esm({
       },
       jsonSchema: {
         api: "协议",
-        compat: "协议兼容开关（docs/providers.md「compat」）",
+        compat: "协议兼容开关（docs/guides/providers.md「compat」）",
         modelId: "模型 id（发给上游的名字）",
         modelBaseUrl: "覆盖渠道 / 供应商的地址",
         contextWindow: "上下文 token；缺省从 models.dev 补，匹配不到不猜",
@@ -4241,6 +4241,7 @@ var init_drivers = __esm({
         resumeUnsupported: (agent) => `${agent} cannot resume sessions; started a new one`,
         resumeNotFound: (agent, id) => `${agent} cannot find session ${id}; started a new one`,
         noMatchingMode: (agent, mode) => `${agent} has no "${mode}" mode; running in its own default mode (actions that need approval still come to you)`,
+        noMatchingModel: (agent, model) => `${agent} does not offer model "${model}"; using its own default model`,
         noImages: (agent) => `${agent} does not accept images; omitted`,
         noImagesDriver: (agent) => `the ${agent} driver does not pass images yet; omitted`,
         noImagesOneshot: (agent) => `${agent} one-shot mode does not pass images; omitted`,
@@ -4251,6 +4252,7 @@ var init_drivers = __esm({
         error: (agent, message, retrying) => `${agent}: ${message}${retrying ? " (retrying)" : ""}`,
         askedQuestion: (agent, tool) => `${agent} wants to ask you a question (${tool}); ama does not answer for you and asked it to put the question in its final reply`,
         askedQuestionCodex: (agent) => `${agent} wants to ask you a question; ama does not answer for you — have it put the question in its final reply`,
+        extensionDialog: (agent, title) => `${agent}: an extension asked for input (${title}); ama does not answer for you, cancelled`,
         mcpElicitation: (agent) => `${agent}'s MCP server asked for input; ama does not answer for you, cancelled`
       },
       /** Hook 配置与输出的警告（给人看；回给模型的阻止理由固定英文）。 */
@@ -4300,6 +4302,7 @@ var init_drivers = __esm({
         resumeUnsupported: (agent) => `${agent} 不支持续接会话，已新开`,
         resumeNotFound: (agent, id) => `${agent} 找不到会话 ${id}，已新开`,
         noMatchingMode: (agent, mode) => `${agent} 没有「${mode}」模式，按它自己的缺省模式运行（需要授权的操作仍交给你）`,
+        noMatchingModel: (agent, model) => `${agent} 没有模型「${model}」，按它自己的缺省模型运行`,
         noImages: (agent) => `${agent} 不接受图片，已省略`,
         noImagesDriver: (agent) => `${agent} 驱动暂不传图片，已省略`,
         noImagesOneshot: (agent) => `${agent} 一次性模式不传图片，已省略`,
@@ -4310,6 +4313,7 @@ var init_drivers = __esm({
         error: (agent, message, retrying) => `${agent}：${message}${retrying ? "（重试中）" : ""}`,
         askedQuestion: (agent, tool) => `${agent} 想向你提问（${tool}）；ama 不代答，已请它把问题写进最终回复`,
         askedQuestionCodex: (agent) => `${agent} 想向你提问；ama 不代答，请让它把问题写进最终回复`,
+        extensionDialog: (agent, title) => `${agent}：扩展请求输入（${title}）；ama 不代答，已取消`,
         mcpElicitation: (agent) => `${agent} 的 MCP 服务器请求输入；ama 不代答，已取消`
       },
       hooks: {
@@ -5359,6 +5363,7 @@ Then paste the full URL from the address bar (http://127.0.0.1:…/auth/callback
       },
       request: {
         notEligible: "this ChatGPT account cannot share plan usage with ama (403 subscription_sharing_user_not_eligible). Possible causes:\n  1. Plan: plan usage is shared with Plus / Pro only\n  2. Workspace account: Team / Enterprise / Edu workspaces may not offer it\n  3. Region restriction, or not yet rolled out during the preview (most likely when a Pro account still gets this error)\nYou can sign in the other way instead: ama auth login chatgpt --flavor codex",
+        modelUnavailable: (model) => `${model} is not available to this ChatGPT account (400 from the codex backend). The backend's model list changes over time: run ama models discover chatgpt to refresh it, then pick a listed model with /model or --model`,
         flavorMismatch: (current3, ref, pinned) => `signed in with ${current3}, but ${ref} pins the @${pinned} channel. Drop @${pinned} so the channel follows the sign-in, or run ama auth login chatgpt --flavor ${pinned}`
       },
       errors: {
@@ -5467,6 +5472,7 @@ Then paste the full URL from the address bar (http://127.0.0.1:…/auth/callback
       },
       request: {
         notEligible: "这个 ChatGPT 账户不能把套餐额度共享给 ama（403 subscription_sharing_user_not_eligible）。可能的原因：\n  1. 账户套餐：额度共享只对 Plus / Pro 开放\n  2. 工作空间账户：Team / Enterprise / Edu 工作空间可能未开放\n  3. 地区受限，或预览期尚未开放（Pro 账户仍报此错时最可能是这一条）\n可以改用另一种登录方式：ama auth login chatgpt --flavor codex",
+        modelUnavailable: (model) => `${model} 在这个 ChatGPT 账户下不可用（codex 后端回 400）。后端的模型表会变化：运行 ama models discover chatgpt 刷新，再用 /model 或 --model 选表里的模型`,
         flavorMismatch: (current3, ref, pinned) => `当前以 ${current3} 方式登录，但 ${ref} 显式指定了 @${pinned} 渠道。去掉 @${pinned} 让渠道跟随登录方式，或运行 ama auth login chatgpt --flavor ${pinned}`
       },
       errors: {
@@ -7129,7 +7135,7 @@ var init_builtin = __esm({
         baseUrl: "https://openrouter.ai/api/v1",
         envKeys: ["OPENROUTER_API_KEY", "AMA_API_KEY_OPENROUTER"],
         headers: {
-          "HTTP-Referer": "https://github.com/Owlbay/armadra-agent",
+          "HTTP-Referer": "https://github.com/AMA-Link/armadra-agent",
           "X-Title": "ama"
         },
         requiresApiKey: true
@@ -7229,7 +7235,7 @@ var init_builtin = __esm({
         requiresApiKey: true
       },
       {
-        // [W6-O] ChatGPT 订阅（docs/wave6-plan.md §4、D14）：`ama auth login chatgpt` 写 auth.json 的 OAuth 条目；
+        // [W6-O] ChatGPT 订阅（docs/history/wave6-plan.md §4、D14）：`ama auth login chatgpt` 写 auth.json 的 OAuth 条目；
         // 缺省渠道在组装时按条目的 flavor 定（compose-providers.ts）。模型表为空：`chatgpt/<slug>` 任意接受，
         // `ama models discover chatgpt` 列出账户可用的 slug。缓存只有 prompt_cache_key（无 24h / 30m 显式缓存）。
         id: "chatgpt",
@@ -22667,7 +22673,7 @@ var init_system_prompt = __esm({
       "rules",
       "project_context",
       "skills",
-      // [W6-C0] 记忆索引（W6-M，docs/wave6-plan.md §3.4）；未开启时为 undefined，字节不变
+      // [W6-C0] 记忆索引（W6-M，docs/history/wave6-plan.md §3.4）；未开启时为 undefined，字节不变
       "memory",
       "hooks",
       "cwd",
@@ -29410,7 +29416,7 @@ var init_session2 = __esm({
           return Promise.reject(new AmaError("busy", "cannot compact while running"));
         return this.startCycle((signal) => this.compaction.compactManual(instructions, signal, cutAt));
       }
-      // [RW-B] 回滚（docs/rewind-plan.md §3；编排与校验在 session-rewind.ts）
+      // [RW-B] 回滚（docs/history/rewind-plan.md §3；编排与校验在 session-rewind.ts）
       rewindPoints = () => this.rewinder.points();
       rewind = (request) => this.rewinder.rewind(request);
       summarizeFrom = (entryId, instructions) => this.rewinder.summarizeFrom(entryId, instructions);
@@ -33224,6 +33230,16 @@ function candidateCapabilities(c) {
         usage: "tokens",
         images: false
       };
+    case "pi-rpc":
+      return {
+        resume: "resume",
+        list: false,
+        permissions: "interactive",
+        steer: true,
+        modes: ALL_MODES,
+        usage: "usd",
+        images: true
+      };
     case "oneshot":
       return {
         resume: c.oneshot === "gemini" ? "none" : "resume",
@@ -33247,7 +33263,7 @@ function candidateCapabilities(c) {
       };
   }
 }
-var ALL_MODES, DRIVER_CATALOG;
+var ALL_MODES, CLAUDE_ACP_MODES, CODEX_ACP_MODES, COPILOT_MODE, COPILOT_MODES, CURSOR_MODES, DRIVER_CATALOG;
 var init_catalog4 = __esm({
   "src/drivers/catalog.ts"() {
     "use strict";
@@ -33259,12 +33275,48 @@ var init_catalog4 = __esm({
       "auto",
       "full-auto"
     ];
+    CLAUDE_ACP_MODES = {
+      plan: "plan",
+      default: "default",
+      "auto-edit": "acceptEdits",
+      auto: "auto",
+      "full-auto": "auto"
+    };
+    CODEX_ACP_MODES = {
+      plan: "read-only",
+      default: "read-only",
+      "auto-edit": "workspace-write",
+      auto: "agent",
+      "full-auto": "agent"
+    };
+    COPILOT_MODE = "https://agentclientprotocol.com/protocol/session-modes#";
+    COPILOT_MODES = {
+      plan: `${COPILOT_MODE}plan`,
+      default: `${COPILOT_MODE}agent`,
+      "auto-edit": `${COPILOT_MODE}agent`,
+      auto: `${COPILOT_MODE}agent`,
+      "full-auto": `${COPILOT_MODE}agent`
+    };
+    CURSOR_MODES = {
+      plan: "plan",
+      default: "agent",
+      "auto-edit": "agent",
+      auto: "agent",
+      "full-auto": "agent"
+    };
     DRIVER_CATALOG = [
       {
         agentId: "claude",
         label: "Claude Code",
         candidates: [
-          { kind: "acp-adapter", program: "claude-agent-acp", args: [], usage: "usd" },
+          {
+            kind: "acp-adapter",
+            program: "claude-agent-acp",
+            args: [],
+            verified: ">=0.89.0 <1.0.0",
+            usage: "usd",
+            modes: CLAUDE_ACP_MODES
+          },
           {
             kind: "claude-stream",
             program: "claude",
@@ -33279,7 +33331,14 @@ var init_catalog4 = __esm({
         agentId: "codex",
         label: "Codex",
         candidates: [
-          { kind: "acp-adapter", program: "codex-acp", args: [], usage: "tokens" },
+          {
+            kind: "acp-adapter",
+            program: "codex-acp",
+            args: [],
+            verified: ">=2.2.0 <3.0.0",
+            usage: "tokens",
+            modes: CODEX_ACP_MODES
+          },
           {
             kind: "codex-app-server",
             program: "codex",
@@ -33312,15 +33371,44 @@ var init_catalog4 = __esm({
       {
         agentId: "opencode",
         label: "OpenCode",
-        candidates: [{ kind: "acp", program: "opencode", args: ["acp"] }]
+        candidates: [{ kind: "acp", program: "opencode", args: ["acp"], verified: ">=1.18.0 <2.0.0" }]
       },
       {
         agentId: "copilot",
         label: "GitHub Copilot CLI",
         candidates: [
-          { kind: "acp", program: "copilot", args: ["--acp", "--stdio"], usage: "requests" }
+          {
+            kind: "acp",
+            program: "copilot",
+            args: ["--acp", "--stdio"],
+            verified: ">=1.0.95 <2.0.0",
+            usage: "requests",
+            modes: COPILOT_MODES,
+            acpUsage: "session"
+          }
+        ]
+      },
+      {
+        agentId: "pi",
+        label: "Pi",
+        // 社区 ACP 适配器 pi-acp 不发 request_permission（pi 没有审批通道），会让工具不经人直接执行，不收录
+        candidates: [
+          {
+            kind: "pi-rpc",
+            program: "pi",
+            args: ["--mode", "rpc"],
+            verified: ">=1.1.0 <2.0.0",
+            usage: "usd"
+          }
         ]
       },
+      {
+        agentId: "cursor",
+        label: "Cursor CLI",
+        // 未实测（本机未装）：按官方文档 `cursor-agent acp`，模式 agent / plan / ask；`cursor/ask_question`
+        // 等阻塞式扩展方法 ama 不实现（回 method not found，不代答）
+        candidates: [{ kind: "acp", program: "cursor-agent", args: ["acp"], modes: CURSOR_MODES }]
+      },
       {
         agentId: "goose",
         label: "Goose",
@@ -34042,6 +34130,24 @@ function pushAcpUpdate(update, turn) {
       return;
   }
 }
+function acpTurnUsage(usage, previous) {
+  const diff = (key) => {
+    const now = usage[key];
+    if (now === void 0) return void 0;
+    return previous === void 0 ? now : Math.max(0, now - (previous[key] ?? 0));
+  };
+  const input2 = diff("inputTokens");
+  const output = diff("outputTokens");
+  const cacheRead = diff("cachedReadTokens");
+  const { totalTokens: total, inputTokens: rawIn = 0, outputTokens: rawOut = 0 } = usage;
+  const cached = usage.cachedReadTokens ?? 0;
+  const includesCache = total !== void 0 && cached > 0 && Math.abs(total - (rawIn + rawOut)) < Math.abs(total - (rawIn + rawOut + cached));
+  return {
+    ...input2 !== void 0 ? { input: includesCache ? Math.max(0, input2 - (cacheRead ?? 0)) : input2 } : {},
+    ...output !== void 0 ? { output } : {},
+    ...cacheRead !== void 0 ? { cacheRead } : {}
+  };
+}
 function wantedModeIds(mode, candidate) {
   const wanted = [candidate.modes?.[mode] ?? mode];
   if (mode === "allowlist") wanted.push(candidate.modes?.plan ?? "plan");
@@ -34062,6 +34168,14 @@ function pickConfigModeValue(mode, candidate, option2) {
   );
   return wantedModeIds(mode, candidate).find((id) => values.includes(id));
 }
+function pickModelValue(model, options) {
+  const option2 = options?.find((o) => o.category === "model" && o.type === "select");
+  if (option2 === void 0) return void 0;
+  const values = option2.options.flatMap((o) => "options" in o ? o.options : [o]);
+  const lower = model.toLowerCase();
+  const hit = values.find((v) => v.value === model) ?? values.find((v) => v.value.toLowerCase() === lower || v.name.toLowerCase() === lower) ?? values.find((v) => v.value.toLowerCase().split("/").at(-1) === lower);
+  return hit === void 0 ? void 0 : { configId: option2.id, value: hit.value, current: option2.currentValue === hit.value };
+}
 function authMethodText(method, command3) {
   if (method.type !== "terminal") return method.name;
   const words = [...command3, ...method.args ?? []].map(
@@ -34148,6 +34262,9 @@ var init_driver = __esm({
       notices = [];
       /** 本回合已发过 cancel。 */
       cancelling = false;
+      /** Agent 的 usage 是会话累计时，上一回合的原始值（{@link acpTurnUsage}）。 */
+      usageTotals;
+      cumulativeUsage = false;
       get sessionId() {
         return this.id;
       }
@@ -34162,6 +34279,7 @@ var init_driver = __esm({
           onProtocolError: (_line, reason) => this.deps.log?.("debug", `${this.agentId}: ${reason}`)
         });
         const signal = options.signal;
+        this.cumulativeUsage = candidate.acpUsage === "session";
         await this.client.initialize(signal);
         let opened;
         try {
@@ -34188,6 +34306,13 @@ var init_driver = __esm({
         } else if (modes != null || modeOption !== void 0) {
           this.notices.push(msg().drivers.agent.noMatchingMode(this.agentId, options.mode));
         }
+        if (options.model !== void 0) {
+          const model = pickModelValue(options.model, opened.configOptions);
+          if (model === void 0)
+            this.notices.push(msg().drivers.agent.noMatchingModel(this.agentId, options.model));
+          else if (!model.current)
+            await this.client.setConfigOption(this.id, model.configId, model.value);
+        }
       }
       /** 续聊优先 resume（不回放），其次 load（回放丢弃），都不行就新开；设好 `this.id`。 */
       async openSession(options) {
@@ -34248,11 +34373,10 @@ var init_driver = __esm({
           });
           const usage = result.usage;
           if (usage != null) {
-            turn.mergeUsage({
-              ...usage.inputTokens !== void 0 ? { input: usage.inputTokens } : {},
-              ...usage.outputTokens !== void 0 ? { output: usage.outputTokens } : {},
-              ...usage.cachedReadTokens !== void 0 ? { cacheRead: usage.cachedReadTokens } : {}
-            });
+            turn.mergeUsage(
+              acpTurnUsage(usage, this.cumulativeUsage ? this.usageTotals ?? {} : void 0)
+            );
+            if (this.cumulativeUsage) this.usageTotals = usage;
           }
           return turn.result(result.stopReason);
         } finally {
@@ -34361,6 +34485,26 @@ function claudePermissionMode(mode, manualName) {
       return "auto";
   }
 }
+function claudeContextTokens(usage) {
+  if (typeof usage !== "object" || usage === null) return void 0;
+  const u = usage;
+  let total = 0;
+  for (const key of [
+    "input_tokens",
+    "cache_read_input_tokens",
+    "cache_creation_input_tokens",
+    "output_tokens"
+  ])
+    if (typeof u[key] === "number") total += u[key];
+  return total > 0 ? total : void 0;
+}
+function claudeContextWindow(result, model) {
+  const entries = result.modelUsage ?? {};
+  const hit = model !== void 0 ? entries[model]?.contextWindow : void 0;
+  if (typeof hit === "number" && hit > 0) return hit;
+  const windows = Object.values(entries).map((e) => e.contextWindow).filter((w) => typeof w === "number" && w > 0);
+  return windows.length > 0 ? Math.max(...windows) : void 0;
+}
 function claudeStopReason(result, interrupted) {
   if (interrupted) return "cancelled";
   switch (result.subtype) {
@@ -34521,6 +34665,8 @@ var init_claude_stream = __esm({
       interrupted = false;
       sawPartialText = false;
       lastTotalCost = 0;
+      /** 最近一条主线 assistant 消息的上下文占用与模型（result 里查窗口用）。 */
+      context = {};
       closed = false;
       exited = false;
       get sessionId() {
@@ -34612,6 +34758,13 @@ var init_claude_stream = __esm({
           ...u.cache_read_input_tokens !== void 0 ? { cacheRead: u.cache_read_input_tokens } : {},
           ...cost2 !== void 0 ? { costUsd: cost2 } : {}
         });
+        const window2 = claudeContextWindow(result, this.context.model);
+        if (this.context.tokens !== void 0 || window2 !== void 0)
+          turn.push({
+            type: "usage",
+            ...this.context.tokens !== void 0 ? { contextTokens: this.context.tokens } : {},
+            ...window2 !== void 0 ? { contextWindow: window2 } : {}
+          });
         if (typeof result.result === "string" && result.result !== "") turn.setFinalText(result.result);
         const denials = result.permission_denials?.length ?? 0;
         if (denials > 0)
@@ -34729,6 +34882,12 @@ var init_claude_stream = __esm({
         const turn = this.turn;
         if (turn === void 0 || !Array.isArray(message["content"])) return;
         const nested = typeof parent === "string" && parent !== "";
+        const tokens = nested ? void 0 : claudeContextTokens(message["usage"]);
+        if (tokens !== void 0)
+          this.context = {
+            tokens,
+            ...typeof message["model"] === "string" ? { model: message["model"] } : {}
+          };
         for (const block of message["content"]) {
           if (block["type"] === "text" && !nested && !this.sawPartialText && typeof block["text"] === "string")
             turn.push({ type: "message_delta", text: block["text"] });
@@ -35178,11 +35337,12 @@ var init_codex_app_server = __esm({
         const start = this.tokensAtStart;
         const end = this.tokensTotal;
         if (end !== void 0) {
+          const cacheRead = end.cachedInputTokens - (start?.cachedInputTokens ?? 0);
           turn.push({
             type: "usage",
-            input: end.inputTokens - (start?.inputTokens ?? 0),
+            input: end.inputTokens - (start?.inputTokens ?? 0) - cacheRead,
             output: end.outputTokens - (start?.outputTokens ?? 0),
-            cacheRead: end.cachedInputTokens - (start?.cachedInputTokens ?? 0),
+            cacheRead,
             ...this.contextTokens !== void 0 ? { contextTokens: this.contextTokens } : {},
             ...this.contextWindow !== void 0 ? { contextWindow: this.contextWindow } : {}
           });
@@ -35377,7 +35537,14 @@ function oneshotArgs(dialect, options, session, prompt) {
       return args;
     }
     case "codex": {
-      const common = ["--json", "-c", 'sandbox_mode="read-only"', "-c", 'approval_policy="never"'];
+      const common = [
+        "--json",
+        "--skip-git-repo-check",
+        "-c",
+        'sandbox_mode="read-only"',
+        "-c",
+        'approval_policy="never"'
+      ];
       if (options.model !== void 0) common.push("-m", options.model);
       return session.resume ? ["exec", "resume", session.id, ...common, "-"] : ["exec", ...common, "-"];
     }
@@ -35597,9 +35764,10 @@ ${item["text"]}`
           }
           case "turn.completed": {
             const u = msg2["usage"] ?? {};
+            const input2 = u["input_tokens"];
             turn.push({
               type: "usage",
-              ...u["input_tokens"] !== void 0 ? { input: u["input_tokens"] } : {},
+              ...input2 !== void 0 ? { input: input2 - (u["cached_input_tokens"] ?? 0) } : {},
               ...u["output_tokens"] !== void 0 ? { output: u["output_tokens"] } : {},
               ...u["cached_input_tokens"] !== void 0 ? { cacheRead: u["cached_input_tokens"] } : {}
             });
@@ -35663,13 +35831,516 @@ ${item["text"]}`
   }
 });
 
+// src/drivers/native/pi-gate.ts
+function writePiGate() {
+  const dir = (0, import_node_fs41.mkdtempSync)((0, import_node_path60.join)((0, import_node_os11.tmpdir)(), "ama-pi-"));
+  const path = (0, import_node_path60.join)(dir, "ama-approval-gate.ts");
+  (0, import_node_fs41.writeFileSync)(path, PI_GATE_SOURCE, { mode: 384 });
+  return {
+    path,
+    dispose: () => (0, import_node_fs41.rmSync)(dir, { recursive: true, force: true })
+  };
+}
+var import_node_fs41, import_node_os11, import_node_path60, PI_GATE_TITLE, PI_READ_ONLY_TOOLS, PI_GATE_SOURCE;
+var init_pi_gate = __esm({
+  "src/drivers/native/pi-gate.ts"() {
+    "use strict";
+    import_node_fs41 = require("node:fs");
+    import_node_os11 = require("node:os");
+    import_node_path60 = require("node:path");
+    PI_GATE_TITLE = "ama-approval";
+    PI_READ_ONLY_TOOLS = ["read", "grep", "find", "ls"];
+    PI_GATE_SOURCE = `// Generated by ama for one pi run: routes non-read-only tool calls to ama for approval.
+const READ_ONLY = new Set(${JSON.stringify(PI_READ_ONLY_TOOLS)});
+export default function (pi) {
+  pi.on("tool_call", async (event, ctx) => {
+    if (READ_ONLY.has(event.toolName)) return undefined;
+    const ok = await ctx.ui.confirm(
+      ${JSON.stringify(PI_GATE_TITLE)},
+      JSON.stringify({ id: event.toolCallId, tool: event.toolName, input: event.input }),
+    );
+    return ok ? undefined : { block: true, reason: event.toolName + " was not approved by the user" };
+  });
+}
+`;
+  }
+});
+
+// src/drivers/native/pi-rpc.ts
+function piArgs(options, sessionId, gatePath) {
+  const args = ["--session-id", sessionId];
+  if (options.model !== void 0) args.push("--model", options.model);
+  args.push("-e", gatePath);
+  if (isReadOnlyMode(options.mode)) args.push("--tools", PI_READ_ONLY_TOOLS.join(","));
+  return args;
+}
+function piToolKind(tool) {
+  switch (tool) {
+    case "bash":
+    case "powershell":
+      return "execute";
+    case "edit":
+    case "write":
+      return "edit";
+    case "read":
+      return "read";
+    case "grep":
+    case "find":
+    case "ls":
+      return "search";
+    default:
+      return "other";
+  }
+}
+function piToolTitle(tool, input2) {
+  if (typeof input2["command"] === "string") return `$ ${oneLine2(input2["command"], 100)}`;
+  if (typeof input2["path"] === "string") return `${tool} ${input2["path"]}`;
+  if (typeof input2["pattern"] === "string") return `${tool} ${oneLine2(input2["pattern"], 80)}`;
+  return tool;
+}
+function textOf4(message) {
+  const content = message["content"];
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((b) => b["type"] === "text" && typeof b["text"] === "string" ? b["text"] : "").join("");
+}
+var import_node_crypto14, import_node_path61, DIALOG_METHODS, EDIT_TOOLS, PiRpcDriver, PiSession;
+var init_pi_rpc = __esm({
+  "src/drivers/native/pi-rpc.ts"() {
+    "use strict";
+    import_node_crypto14 = require("node:crypto");
+    import_node_path61 = require("node:path");
+    init_errors();
+    init_jsonl();
+    init_base();
+    init_process();
+    init_turn();
+    init_pi_gate();
+    init_i18n();
+    DIALOG_METHODS = /* @__PURE__ */ new Set(["select", "confirm", "input", "editor"]);
+    EDIT_TOOLS = /* @__PURE__ */ new Set(["edit", "write"]);
+    PiRpcDriver = class {
+      constructor(agentId, candidate, deps = {}) {
+        this.agentId = agentId;
+        this.candidate = candidate;
+        this.deps = deps;
+      }
+      agentId;
+      candidate;
+      deps;
+      kind = "pi-rpc";
+      probe() {
+        return probeCandidate(this.candidate, this.deps);
+      }
+      async open(options) {
+        const probed = await probeCandidate(this.candidate, this.deps);
+        const sessionId = options.resume ?? (0, import_node_crypto14.randomUUID)();
+        const gate = writePiGate();
+        const transport = spawnOf(this.deps)({
+          program: probed.path ?? this.candidate.program,
+          args: [...this.candidate.args, ...piArgs(options, sessionId, gate.path)],
+          cwd: options.cwd,
+          env: options.env
+        });
+        const session = new PiSession(
+          this.agentId,
+          sessionId,
+          transport,
+          options,
+          this.deps,
+          () => gate.dispose()
+        );
+        if (probed.warning !== void 0) session.notices.push(probed.warning);
+        try {
+          await session.start(options.signal);
+        } catch (error2) {
+          await session.close();
+          throw new AmaError(
+            "agent_start_failed",
+            `${this.agentId}: failed to start (${error2.message})${stderrHint(transport) !== "" ? `: ${stderrHint(transport)}` : ""}`,
+            { cause: error2 }
+          );
+        }
+        return session;
+      }
+    };
+    PiSession = class {
+      constructor(agentId, id, transport, options, deps, dispose) {
+        this.agentId = agentId;
+        this.id = id;
+        this.transport = transport;
+        this.options = options;
+        this.deps = deps;
+        this.dispose = dispose;
+        createLineReader(
+          transport.stdout,
+          (line2) => this.onLine(line2),
+          () => this.onExit()
+        );
+        transport.stdin.on?.("error", () => void 0);
+      }
+      agentId;
+      id;
+      transport;
+      options;
+      deps;
+      dispose;
+      notices = [];
+      nextId = 1;
+      pending = /* @__PURE__ */ new Map();
+      permissions = /* @__PURE__ */ new Set();
+      turn;
+      hooks;
+      settle;
+      running;
+      usage = { input: 0, output: 0, cacheRead: 0, costUsd: 0, seen: false };
+      lastAssistant;
+      interrupted = false;
+      closed = false;
+      exited = false;
+      exitWaiters = /* @__PURE__ */ new Set();
+      get sessionId() {
+        return this.id;
+      }
+      /** 握手：`get_state` 确认进程起来了，并取 pi 实际使用的会话 id。 */
+      async start(signal) {
+        const aborted = new Promise((_, reject2) => {
+          if (signal.aborted) reject2(new Error("aborted"));
+          signal.addEventListener("abort", () => reject2(new Error("aborted")), { once: true });
+        });
+        void aborted.catch(() => void 0);
+        const state = await Promise.race([this.request({ type: "get_state" }), aborted]);
+        const data2 = state["data"] ?? {};
+        if (typeof data2["sessionId"] === "string" && data2["sessionId"] !== "")
+          this.id = data2["sessionId"];
+      }
+      async prompt(content, hooks) {
+        if (this.closed || this.exited)
+          throw new AmaError("agent_closed", `${this.agentId} session is closed`);
+        if (this.running !== void 0)
+          throw new AmaError("busy", `${this.agentId} is already running`);
+        const turn = new TurnCollector((e) => hooks.onEvent(e));
+        for (const text of this.notices.splice(0)) turn.push({ type: "notice", level: "warn", text });
+        this.turn = turn;
+        this.hooks = hooks;
+        this.interrupted = false;
+        this.usage = { input: 0, output: 0, cacheRead: 0, costUsd: 0, seen: false };
+        this.lastAssistant = void 0;
+        this.running = this.run(content, turn);
+        try {
+          return await this.running;
+        } finally {
+          this.running = void 0;
+          this.turn = void 0;
+          this.hooks = void 0;
+          this.settle = void 0;
+          this.exitWaiters.clear();
+        }
+      }
+      async run(content, turn) {
+        await Promise.resolve();
+        const settled = new Promise((resolve41) => this.settle = resolve41);
+        const response = await this.request({ type: "prompt", ...this.message(content) });
+        if (response["success"] !== true)
+          throw new AmaError(
+            "agent_failed",
+            `${this.agentId} rejected the prompt: ${oneLine2(String(response["error"] ?? "unknown"), 300)}`
+          );
+        const disposition = (response["data"] ?? {})["disposition"];
+        if (disposition === "handled") return turn.result("end_turn");
+        const aborted = await Promise.race([settled, this.exitPromise()]);
+        await this.reportContext(turn);
+        return this.complete(turn, aborted);
+      }
+      async steer(content) {
+        if (this.closed || this.exited)
+          throw new AmaError("agent_closed", `${this.agentId} session is closed`);
+        await this.request({ type: "steer", ...this.message(content) });
+      }
+      async cancel() {
+        const running = this.running;
+        if (running === void 0 || this.closed) return;
+        this.interrupted = true;
+        for (const c of this.permissions) c.abort();
+        void this.request({ type: "abort" }).catch(() => void 0);
+        armCancelWatchdog(
+          this.transport,
+          running.catch(() => void 0),
+          this.deps
+        );
+      }
+      async close() {
+        if (this.closed) return;
+        this.closed = true;
+        for (const c of this.permissions) c.abort();
+        if (this.running !== void 0) {
+          this.interrupted = true;
+          this.write({ type: "abort" });
+        }
+        try {
+          await this.transport.terminate();
+        } finally {
+          this.dispose();
+        }
+      }
+      message(content) {
+        const text = content.map((b) => b.type === "text" ? b.text : "").join("\n");
+        const images = content.flatMap(
+          (b) => b.type === "image" ? [{ type: "image", data: b.data, mimeType: b.mimeType }] : []
+        );
+        return { message: text, ...images.length > 0 ? { images } : {} };
+      }
+      complete(turn, aborted) {
+        const u = this.usage;
+        if (u.seen)
+          turn.push({
+            type: "usage",
+            input: u.input,
+            output: u.output,
+            cacheRead: u.cacheRead,
+            costUsd: u.costUsd
+          });
+        const last = this.lastAssistant;
+        if (last !== void 0) {
+          const text = textOf4(last);
+          if (text !== "") turn.setFinalText(text);
+        }
+        if (aborted || this.interrupted) return turn.result("cancelled");
+        switch (last?.["stopReason"]) {
+          case "error":
+            throw new AmaError(
+              "agent_failed",
+              `${this.agentId} failed: ${oneLine2(String(last["errorMessage"] ?? "unknown error"), 300)}`
+            );
+          case "aborted":
+            return turn.result("cancelled");
+          case "length":
+            return turn.result("max_tokens");
+          default:
+            return turn.result("end_turn");
+        }
+      }
+      /** `get_session_stats.contextUsage` → 上下文占用与窗口（拿不到就算了）。 */
+      async reportContext(turn) {
+        if (this.exited) return;
+        try {
+          const stats = await Promise.race([
+            this.request({ type: "get_session_stats" }),
+            new Promise((resolve41) => setTimeout(() => resolve41({}), 5e3).unref())
+          ]);
+          const usage = (stats["data"] ?? {})["contextUsage"] ?? {};
+          const tokens = usage["tokens"];
+          const window2 = usage["contextWindow"];
+          if (typeof tokens === "number" || typeof window2 === "number")
+            turn.push({
+              type: "usage",
+              ...typeof tokens === "number" ? { contextTokens: tokens } : {},
+              ...typeof window2 === "number" ? { contextWindow: window2 } : {}
+            });
+        } catch {
+        }
+      }
+      exitPromise() {
+        return new Promise((_, reject2) => {
+          if (this.exited) reject2(this.exitError());
+          else this.exitWaiters.add(reject2);
+        });
+      }
+      exitError() {
+        const hint = stderrHint(this.transport);
+        return new AmaError(
+          "agent_exited",
+          `${this.agentId} process exited${hint !== "" ? `: ${hint}` : ""}`
+        );
+      }
+      request(command3) {
+        if (this.exited) return Promise.reject(this.exitError());
+        const id = `ama-${this.nextId++}`;
+        return new Promise((resolve41, reject2) => {
+          this.pending.set(id, { resolve: resolve41, reject: reject2 });
+          this.write({ id, ...command3 });
+        });
+      }
+      write(record3) {
+        if (this.exited) return;
+        this.transport.stdin.write(`${JSON.stringify(record3)}
+`);
+      }
+      onExit() {
+        this.exited = true;
+        const error2 = this.exitError();
+        for (const p of this.pending.values()) p.reject(error2);
+        this.pending.clear();
+        for (const reject2 of this.exitWaiters) reject2(error2);
+        this.exitWaiters.clear();
+        for (const c of this.permissions) c.abort();
+      }
+      onLine(line2) {
+        let record3;
+        try {
+          record3 = JSON.parse(line2);
+        } catch {
+          this.deps.log?.("debug", msg().drivers.agent.nonJson(this.agentId));
+          return;
+        }
+        switch (record3["type"]) {
+          case "response": {
+            const id = record3["id"];
+            const pending = typeof id === "string" ? this.pending.get(id) : void 0;
+            if (pending === void 0 || typeof id !== "string") return;
+            this.pending.delete(id);
+            pending.resolve(record3);
+            return;
+          }
+          case "agent_settled":
+            this.settle?.(record3["aborted"] === true);
+            return;
+          case "extension_ui_request":
+            void this.onDialog(record3);
+            return;
+          default:
+            this.onEvent(record3);
+        }
+      }
+      onEvent(record3) {
+        const turn = this.turn;
+        if (turn === void 0) return;
+        switch (record3["type"]) {
+          case "message_update": {
+            const event = record3["assistantMessageEvent"] ?? {};
+            const delta = event["delta"];
+            if (typeof delta !== "string") return;
+            if (event["type"] === "text_delta") turn.push({ type: "message_delta", text: delta });
+            else if (event["type"] === "thinking_delta")
+              turn.push({ type: "thought_delta", text: delta });
+            return;
+          }
+          case "message_end": {
+            const message = record3["message"] ?? {};
+            if (message["role"] !== "assistant") return;
+            this.lastAssistant = message;
+            const usage = message["usage"] ?? {};
+            const num10 = (key) => typeof usage[key] === "number" ? usage[key] : 0;
+            const cost2 = (usage["cost"] ?? {})["total"];
+            this.usage = {
+              input: this.usage.input + num10("input"),
+              output: this.usage.output + num10("output"),
+              cacheRead: this.usage.cacheRead + num10("cacheRead"),
+              costUsd: this.usage.costUsd + (typeof cost2 === "number" ? cost2 : 0),
+              seen: true
+            };
+            return;
+          }
+          case "tool_execution_start":
+          case "tool_execution_end": {
+            const tool = String(record3["toolName"] ?? "tool");
+            const known = turn.tool(String(record3["toolCallId"] ?? ""));
+            const input2 = record3["args"] ?? {};
+            const path = typeof input2["path"] === "string" ? input2["path"] : void 0;
+            const locations = path !== void 0 ? [(0, import_node_path61.resolve)(this.options.cwd, path)] : known?.locations;
+            turn.push({
+              type: "tool_call",
+              id: String(record3["toolCallId"] ?? ""),
+              title: known?.title ?? piToolTitle(tool, input2),
+              kind: piToolKind(tool),
+              status: record3["type"] === "tool_execution_start" ? "in_progress" : record3["isError"] === true ? "failed" : "completed",
+              ...locations !== void 0 && locations.length > 0 ? { locations } : {}
+            });
+            return;
+          }
+          case "auto_retry_start":
+            turn.push({
+              type: "notice",
+              level: "warn",
+              text: msg().drivers.agent.error(
+                this.agentId,
+                oneLine2(String(record3["errorMessage"] ?? "error"), 200),
+                true
+              )
+            });
+            return;
+          default:
+            return;
+        }
+      }
+      /** 扩展对话框：ama 的审批闸按模式决定或交给人；其它扩展的对话框取消（不代答）。 */
+      async onDialog(record3) {
+        const id = String(record3["id"] ?? "");
+        const method = String(record3["method"] ?? "");
+        if (!DIALOG_METHODS.has(method)) {
+          if (record3["method"] === "notify" && record3["notifyType"] !== "info")
+            this.turn?.push({
+              type: "notice",
+              level: "warn",
+              text: `${this.agentId}: ${oneLine2(String(record3["message"] ?? ""), 200)}`
+            });
+          return;
+        }
+        if (method !== "confirm" || record3["title"] !== PI_GATE_TITLE) {
+          this.turn?.push({
+            type: "notice",
+            level: "warn",
+            text: msg().drivers.agent.extensionDialog(
+              this.agentId,
+              oneLine2(String(record3["title"] ?? method), 80)
+            )
+          });
+          this.write({ type: "extension_ui_response", id, cancelled: true });
+          return;
+        }
+        const confirmed = await this.decide(record3);
+        this.write({ type: "extension_ui_response", id, confirmed });
+      }
+      async decide(record3) {
+        let call;
+        try {
+          call = JSON.parse(String(record3["message"] ?? "{}"));
+        } catch {
+          return false;
+        }
+        const tool = String(call["tool"] ?? "tool");
+        const input2 = call["input"] ?? {};
+        const mode = this.options.mode;
+        if (isReadOnlyMode(mode)) return false;
+        if (mode !== "default" && EDIT_TOOLS.has(tool)) return true;
+        const hooks = this.hooks;
+        if (hooks === void 0 || this.interrupted || this.closed) return false;
+        const known = this.turn?.tool(String(call["id"] ?? ""));
+        const path = typeof input2["path"] === "string" ? input2["path"] : void 0;
+        const controller = new AbortController();
+        this.permissions.add(controller);
+        try {
+          const outcome = await hooks.onPermission(
+            {
+              toolCall: {
+                title: known?.title ?? piToolTitle(tool, input2),
+                kind: piToolKind(tool),
+                ...path !== void 0 ? { locations: [(0, import_node_path61.resolve)(this.options.cwd, path)] } : {},
+                inputSummary: oneLine2(JSON.stringify(input2), 300)
+              },
+              options: [
+                { optionId: "allow", kind: "allow_once" },
+                { optionId: "reject", kind: "reject_once" }
+              ]
+            },
+            controller.signal
+          );
+          return !controller.signal.aborted && outcome.outcome === "selected" && outcome.optionId === "allow";
+        } finally {
+          this.permissions.delete(controller);
+        }
+      }
+    };
+  }
+});
+
 // src/drivers/pids.ts
 function pidsFile(dataDir) {
-  return (0, import_node_path60.join)(dataDir, "drivers", "pids.json");
+  return (0, import_node_path62.join)(dataDir, "drivers", "pids.json");
 }
 function read(file) {
   try {
-    const parsed = JSON.parse((0, import_node_fs41.readFileSync)(file, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs42.readFileSync)(file, "utf8"));
     return Array.isArray(parsed.entries) ? parsed.entries : [];
   } catch {
     return [];
@@ -35677,11 +36348,11 @@ function read(file) {
 }
 function write(file, entries) {
   try {
-    (0, import_node_fs41.mkdirSync)((0, import_node_path60.dirname)(file), { recursive: true });
+    (0, import_node_fs42.mkdirSync)((0, import_node_path62.dirname)(file), { recursive: true });
     const tmp = `${file}.${process.pid}.tmp`;
-    (0, import_node_fs41.writeFileSync)(tmp, `${JSON.stringify({ version: 1, entries }, null, 2)}
+    (0, import_node_fs42.writeFileSync)(tmp, `${JSON.stringify({ version: 1, entries }, null, 2)}
 `);
-    (0, import_node_fs41.renameSync)(tmp, file);
+    (0, import_node_fs42.renameSync)(tmp, file);
   } catch {
   }
 }
@@ -35697,13 +36368,13 @@ function psCommand(pid) {
   const out = (0, import_node_child_process11.spawnSync)("ps", ["-o", "command=", "-p", String(pid)], { encoding: "utf8" });
   return out.status === 0 ? out.stdout.trim() : void 0;
 }
-var import_node_child_process11, import_node_fs41, import_node_path60, PidRegistry;
+var import_node_child_process11, import_node_fs42, import_node_path62, PidRegistry;
 var init_pids = __esm({
   "src/drivers/pids.ts"() {
     "use strict";
     import_node_child_process11 = require("node:child_process");
-    import_node_fs41 = require("node:fs");
-    import_node_path60 = require("node:path");
+    import_node_fs42 = require("node:fs");
+    import_node_path62 = require("node:path");
     init_process_tree();
     PidRegistry = class {
       constructor(file) {
@@ -35739,7 +36410,7 @@ var init_pids = __esm({
           }
           if (platform === "win32" || !groupAlive(entry.pid)) continue;
           const command3 = commandOf(entry.pid);
-          if (command3 !== void 0 && command3.includes((0, import_node_path60.basename)(entry.program))) {
+          if (command3 !== void 0 && command3.includes((0, import_node_path62.basename)(entry.program))) {
             await kill(entry.pid);
             killed.push(entry.pid);
           }
@@ -35899,7 +36570,7 @@ async function askHuman(request, ctx) {
   if (ctx.signal.aborted) return CANCELLED;
   if (ctx.unattended) return pick(request, "reject_once") ?? CANCELLED;
   const approval = {
-    requestId: (0, import_node_crypto14.randomUUID)(),
+    requestId: (0, import_node_crypto15.randomUUID)(),
     toolName: externalToolName(ctx.agent),
     input: request.toolCall,
     reason: "mode",
@@ -35940,11 +36611,11 @@ function supportedMode(mode, supported) {
     if (rank(m) <= rank(mode) && (best === void 0 || rank(m) > rank(best))) best = m;
   return best;
 }
-var import_node_crypto14, CANCELLED;
+var import_node_crypto15, CANCELLED;
 var init_permissions2 = __esm({
   "src/drivers/permissions.ts"() {
     "use strict";
-    import_node_crypto14 = require("node:crypto");
+    import_node_crypto15 = require("node:crypto");
     init_types();
     CANCELLED = { outcome: "cancelled" };
   }
@@ -36091,7 +36762,8 @@ var init_runner2 = __esm({
       "acp",
       "acp-adapter",
       "claude-stream",
-      "codex-app-server"
+      "codex-app-server",
+      "pi-rpc"
     ]);
     ProcessHandle = class {
       constructor(runner, chosen, request, deps) {
@@ -36418,15 +37090,17 @@ function createDriver(agentId, candidate, deps) {
       return new ClaudeStreamDriver(agentId, candidate, deps);
     case "codex-app-server":
       return new CodexAppServerDriver(agentId, candidate, deps);
+    case "pi-rpc":
+      return new PiRpcDriver(agentId, candidate, deps);
     case "oneshot":
       return new OneshotDriver(agentId, candidate, deps);
   }
 }
-var import_node_path61, reaped, ExternalAgents;
+var import_node_path63, reaped, ExternalAgents;
 var init_agents2 = __esm({
   "src/drivers/agents.ts"() {
     "use strict";
-    import_node_path61 = require("node:path");
+    import_node_path63 = require("node:path");
     init_errors();
     init_driver();
     init_catalog4();
@@ -36434,6 +37108,7 @@ var init_agents2 = __esm({
     init_claude_stream();
     init_codex_app_server();
     init_oneshot();
+    init_pi_rpc();
     init_pids();
     init_pool();
     init_probe();
@@ -36459,7 +37134,7 @@ var init_agents2 = __esm({
           probe: new ProgramProbe({
             env: options.env,
             cwd: options.cwd,
-            ...options.dataDir !== void 0 ? { cacheFile: (0, import_node_path61.join)(options.dataDir, "drivers.json") } : {}
+            ...options.dataDir !== void 0 ? { cacheFile: (0, import_node_path63.join)(options.dataDir, "drivers.json") } : {}
           }),
           spawn: (spec2) => spawnTransport(spec2, {
             onSpawn: (pid) => registry3?.add(pid, spec2.program),
@@ -36706,11 +37381,11 @@ function mergeAgentInfos(base4, external) {
   }
   return out;
 }
-var import_node_crypto15, LISTED_EXTERNAL_AGENTS, NO_AGENT_PROBE_ENV, externalTesting, HOST_AMA_RUNNER, ExternalTaskHandle, infoCache, SessionExternalAgents;
+var import_node_crypto16, LISTED_EXTERNAL_AGENTS, NO_AGENT_PROBE_ENV, externalTesting, HOST_AMA_RUNNER, ExternalTaskHandle, infoCache, SessionExternalAgents;
 var init_external = __esm({
   "src/agents/external.ts"() {
     "use strict";
-    import_node_crypto15 = require("node:crypto");
+    import_node_crypto16 = require("node:crypto");
     init_session_tools();
     init_types_w5();
     init_agents2();
@@ -36885,7 +37560,7 @@ var init_external = __esm({
             agentEntry(this.wiring.config, spec2)?.maxMode
           );
           const approval = {
-            requestId: (0, import_node_crypto15.randomUUID)(),
+            requestId: (0, import_node_crypto16.randomUUID)(),
             toolName: "task",
             input: {
               agent: spec2,
@@ -37131,7 +37806,7 @@ function sourceText2(source, cache3, log) {
   if (cached !== void 0) return cached;
   let text = "";
   try {
-    text = (0, import_node_fs42.readFileSync)(source.path, "utf8");
+    text = (0, import_node_fs43.readFileSync)(source.path, "utf8");
   } catch (error2) {
     log(
       "warn",
@@ -37485,11 +38160,11 @@ async function disposeSessionAlongside(target, session, fallback) {
   await session.dispose();
   record3.live.delete(session);
 }
-var import_node_fs42, records, LOG_LEVELS;
+var import_node_fs43, records, LOG_LEVELS;
 var init_compose_session = __esm({
   "src/cli/compose-session.ts"() {
     "use strict";
-    import_node_fs42 = require("node:fs");
+    import_node_fs43 = require("node:fs");
     init_limits();
     init_session2();
     init_session_subagent();
@@ -37537,7 +38212,7 @@ function toolTitle(name, args, nested = false) {
 function toolLocations(args, cwd) {
   const path = argOf(args, "path", "file_path", "filePath");
   if (path === void 0) return void 0;
-  return [{ path: (0, import_node_path62.isAbsolute)(path) ? path : (0, import_node_path62.resolve)(cwd, path) }];
+  return [{ path: (0, import_node_path64.isAbsolute)(path) ? path : (0, import_node_path64.resolve)(cwd, path) }];
 }
 function resultText2(content) {
   const text = typeof content === "string" ? content : content.map((b) => b.type === "text" ? b.text : `[${b.type}]`).join("");
@@ -37564,11 +38239,11 @@ function resultContent(result) {
     ]
   };
 }
-var import_node_path62, TOOL_OUTPUT_LIMIT, KINDS3;
+var import_node_path64, TOOL_OUTPUT_LIMIT, KINDS3;
 var init_acp_tool_text = __esm({
   "src/modes/acp/acp-tool-text.ts"() {
     "use strict";
-    import_node_path62 = require("node:path");
+    import_node_path64 = require("node:path");
     init_turn();
     init_i18n();
     TOOL_OUTPUT_LIMIT = 4 * 1024;
@@ -38345,9 +39020,9 @@ var init_acp_sessions = __esm({
 // src/modes/acp/acp-server.ts
 function canonical(path) {
   try {
-    return import_node_fs43.realpathSync.native((0, import_node_path63.resolve)(path));
+    return import_node_fs44.realpathSync.native((0, import_node_path65.resolve)(path));
   } catch {
-    return (0, import_node_path63.resolve)(path);
+    return (0, import_node_path65.resolve)(path);
   }
 }
 function str(params, key) {
@@ -38376,12 +39051,12 @@ ${block.resource.text}
 function countOf(value) {
   return Array.isArray(value) ? value.length : 0;
 }
-var import_node_fs43, import_node_path63, ACP_AGENT_CAPABILITIES, SESSION_ID_SHAPE, AcpServer;
+var import_node_fs44, import_node_path65, ACP_AGENT_CAPABILITIES, SESSION_ID_SHAPE, AcpServer;
 var init_acp_server = __esm({
   "src/modes/acp/acp-server.ts"() {
     "use strict";
-    import_node_fs43 = require("node:fs");
-    import_node_path63 = require("node:path");
+    import_node_fs44 = require("node:fs");
+    import_node_path65 = require("node:path");
     init_shared();
     init_compose_session();
     init_compose_store();
@@ -38895,7 +39570,7 @@ function terminalAuthMethods(authFile) {
   ];
 }
 function gateAuthFile(args, cwd) {
-  if (args.authFile !== void 0) return (0, import_node_path64.resolve)(cwd, args.authFile);
+  if (args.authFile !== void 0) return (0, import_node_path66.resolve)(cwd, args.authFile);
   if (args.profile === void 0) return void 0;
   try {
     return loadProfile(args.profile, cwd).authFile;
@@ -39018,11 +39693,11 @@ async function runAcpAuthGate(args, deps, io, cause, options = {}) {
   await runtime?.dispose("exit").catch(() => void 0);
   return code;
 }
-var import_node_path64, AUTH_RETRY_INTERVAL_MS, SESSION_METHODS;
+var import_node_path66, AUTH_RETRY_INTERVAL_MS, SESSION_METHODS;
 var init_acp_auth_gate = __esm({
   "src/modes/acp/acp-auth-gate.ts"() {
     "use strict";
-    import_node_path64 = require("node:path");
+    import_node_path66 = require("node:path");
     init_args();
     init_bootstrap();
     init_exit_codes();
@@ -39104,7 +39779,7 @@ async function bootstrap(argsIn, deps, io) {
     () => deps.sessions.open(sessionRequest, { sessionDir: paths.sessionDir, cwd: paths.cwd })
   );
   let sessionCwd = sessionManager.cwd;
-  if (!(0, import_node_fs44.existsSync)(sessionCwd)) {
+  if (!(0, import_node_fs45.existsSync)(sessionCwd)) {
     const replacement = interactive ? await deps.ui?.askCwd?.(sessionCwd) : void 0;
     if (replacement === void 0) {
       throw new StartupError(
@@ -39113,7 +39788,7 @@ async function bootstrap(argsIn, deps, io) {
         ExitCode.Session
       );
     }
-    sessionCwd = (0, import_node_path65.resolve)(replacement);
+    sessionCwd = (0, import_node_path67.resolve)(replacement);
   }
   const runtimePaths = { ...paths, cwd: sessionCwd };
   const trust = await step(
@@ -39188,7 +39863,7 @@ async function bootstrap(argsIn, deps, io) {
     () => deps.providers.create({
       config,
       cwd: sessionCwd,
-      authFile: args.authFile !== void 0 ? (0, import_node_path65.resolve)(io.cwd, args.authFile) : defaultAuthFilePath(paths.configDir),
+      authFile: args.authFile !== void 0 ? (0, import_node_path67.resolve)(io.cwd, args.authFile) : defaultAuthFilePath(paths.configDir),
       authEnv: profile?.authEnv ?? true,
       dataDir: paths.dataDir,
       ...args.apiKey !== void 0 && args.model !== void 0 ? {
@@ -39498,12 +40173,12 @@ function reportError(error2, io, fallback = ExitCode.RuntimeError) {
   if (isAmaError(error2) && error2.exitCode !== void 0) return error2.exitCode;
   return fallback;
 }
-var import_node_fs44, import_node_path65;
+var import_node_fs45, import_node_path67;
 var init_bootstrap = __esm({
   "src/cli/bootstrap.ts"() {
     "use strict";
-    import_node_fs44 = require("node:fs");
-    import_node_path65 = require("node:path");
+    import_node_fs45 = require("node:fs");
+    import_node_path67 = require("node:path");
     init_auth_file();
     init_context_files();
     init_load();
@@ -39529,7 +40204,7 @@ var init_bootstrap = __esm({
 // src/auth/oauth/token-store.ts
 function readRaw(path) {
   try {
-    const value = JSON.parse(retryTransientFs(() => (0, import_node_fs45.readFileSync)(path, "utf8")));
+    const value = JSON.parse(retryTransientFs(() => (0, import_node_fs46.readFileSync)(path, "utf8")));
     return typeof value === "object" && value !== null && typeof value.providers === "object" ? value : void 0;
   } catch {
     return void 0;
@@ -39561,12 +40236,12 @@ function isStaleLock(path, now = Date.now()) {
   let age;
   let pid;
   try {
-    age = now - (0, import_node_fs45.statSync)(path).mtimeMs;
-    const value = JSON.parse((0, import_node_fs45.readFileSync)(path, "utf8"));
+    age = now - (0, import_node_fs46.statSync)(path).mtimeMs;
+    const value = JSON.parse((0, import_node_fs46.readFileSync)(path, "utf8"));
     pid = typeof value.pid === "number" ? value.pid : void 0;
   } catch {
     try {
-      age = now - (0, import_node_fs45.statSync)(path).mtimeMs;
+      age = now - (0, import_node_fs46.statSync)(path).mtimeMs;
     } catch {
       return false;
     }
@@ -39575,11 +40250,11 @@ function isStaleLock(path, now = Date.now()) {
 }
 function tryAcquire(path) {
   try {
-    const fd = (0, import_node_fs45.openSync)(path, "wx", 384);
+    const fd = (0, import_node_fs46.openSync)(path, "wx", 384);
     try {
-      (0, import_node_fs45.writeSync)(fd, JSON.stringify({ pid: process.pid, at: (/* @__PURE__ */ new Date()).toISOString() }));
+      (0, import_node_fs46.writeSync)(fd, JSON.stringify({ pid: process.pid, at: (/* @__PURE__ */ new Date()).toISOString() }));
     } finally {
-      (0, import_node_fs45.closeSync)(fd);
+      (0, import_node_fs46.closeSync)(fd);
     }
     return true;
   } catch (error2) {
@@ -39590,13 +40265,13 @@ function tryAcquire(path) {
 }
 async function withRefreshLock(authFile, fn, options = {}) {
   const path = lockPath(authFile);
-  (0, import_node_fs45.mkdirSync)((0, import_node_path66.dirname)(path), { recursive: true, mode: 448 });
+  (0, import_node_fs46.mkdirSync)((0, import_node_path68.dirname)(path), { recursive: true, mode: 448 });
   const deadline = Date.now() + (options.waitMs ?? LOCK_WAIT_MS);
   for (; ; ) {
     if (tryAcquire(path)) break;
     if (isStaleLock(path)) {
       try {
-        (0, import_node_fs45.unlinkSync)(path);
+        (0, import_node_fs46.unlinkSync)(path);
       } catch {
       }
       continue;
@@ -39611,17 +40286,17 @@ async function withRefreshLock(authFile, fn, options = {}) {
     return await fn();
   } finally {
     try {
-      (0, import_node_fs45.unlinkSync)(path);
+      (0, import_node_fs46.unlinkSync)(path);
     } catch {
     }
   }
 }
-var import_node_fs45, import_node_path66, LOCK_WAIT_MS, LOCK_STALE_MS, LOCK_POLL_MS;
+var import_node_fs46, import_node_path68, LOCK_WAIT_MS, LOCK_STALE_MS, LOCK_POLL_MS;
 var init_token_store = __esm({
   "src/auth/oauth/token-store.ts"() {
     "use strict";
-    import_node_fs45 = require("node:fs");
-    import_node_path66 = require("node:path");
+    import_node_fs46 = require("node:fs");
+    import_node_path68 = require("node:path");
     init_auth_file();
     init_fs_retry();
     init_types2();
@@ -39635,7 +40310,7 @@ var init_token_store = __esm({
 
 // src/ai/providers/discovered-cache.ts
 function discoveredCachePath(dataDir, provider) {
-  return (0, import_node_path67.join)(dataDir, "models", "discovered", `${provider}.json`);
+  return (0, import_node_path69.join)(dataDir, "models", "discovered", `${provider}.json`);
 }
 function toEntry(value) {
   if (typeof value !== "object" || value === null) return void 0;
@@ -39655,7 +40330,7 @@ function toEntry(value) {
 function readDiscoveredCache(dataDir, provider) {
   let parsed;
   try {
-    parsed = JSON.parse((0, import_node_fs46.readFileSync)(discoveredCachePath(dataDir, provider), "utf8"));
+    parsed = JSON.parse((0, import_node_fs47.readFileSync)(discoveredCachePath(dataDir, provider), "utf8"));
   } catch {
     return void 0;
   }
@@ -39679,17 +40354,17 @@ function writeDiscoveredCache(dataDir, provider, input2, now = Date.now()) {
     ...input2.flavor !== void 0 ? { flavor: input2.flavor } : {},
     models: input2.models.map(toEntry).filter((m) => m !== void 0)
   };
-  (0, import_node_fs46.mkdirSync)((0, import_node_path67.dirname)(path), { recursive: true, mode: 448 });
+  (0, import_node_fs47.mkdirSync)((0, import_node_path69.dirname)(path), { recursive: true, mode: 448 });
   const tmp = `${path}.${process.pid}.tmp`;
-  (0, import_node_fs46.writeFileSync)(tmp, `${JSON.stringify(file, null, 2)}
+  (0, import_node_fs47.writeFileSync)(tmp, `${JSON.stringify(file, null, 2)}
 `);
-  (0, import_node_fs46.renameSync)(tmp, path);
+  (0, import_node_fs47.renameSync)(tmp, path);
   return path;
 }
 function clearDiscoveredCache(dataDir, provider) {
   const path = discoveredCachePath(dataDir, provider);
-  if (!(0, import_node_fs46.existsSync)(path)) return false;
-  (0, import_node_fs46.rmSync)(path, { force: true });
+  if (!(0, import_node_fs47.existsSync)(path)) return false;
+  (0, import_node_fs47.rmSync)(path, { force: true });
   return true;
 }
 function thinkingMapOf(levels) {
@@ -39743,12 +40418,12 @@ function mergeDiscoveredModels(registry3, dataDir, modelsDev, loginFlavor = () =
   }
   return merged;
 }
-var import_node_fs46, import_node_path67, DISCOVERED_CACHE_VERSION, EFFORT_LEVELS, SUBSCRIPTION_FALLBACK_CONTEXT_WINDOW, SUBSCRIPTION_PROVIDERS;
+var import_node_fs47, import_node_path69, DISCOVERED_CACHE_VERSION, EFFORT_LEVELS, SUBSCRIPTION_FALLBACK_CONTEXT_WINDOW, SUBSCRIPTION_PROVIDERS;
 var init_discovered_cache = __esm({
   "src/ai/providers/discovered-cache.ts"() {
     "use strict";
-    import_node_fs46 = require("node:fs");
-    import_node_path67 = require("node:path");
+    import_node_fs47 = require("node:fs");
+    import_node_path69 = require("node:path");
     init_catalog2();
     init_enrich();
     DISCOVERED_CACHE_VERSION = 1;
@@ -41631,7 +42306,7 @@ function parseKeybindings(value) {
 function loadKeybindingsFile(path) {
   let text;
   try {
-    text = (0, import_node_fs48.readFileSync)(path, "utf8");
+    text = (0, import_node_fs49.readFileSync)(path, "utf8");
   } catch (error2) {
     if (error2.code === "ENOENT") return { overrides: {}, warnings: [] };
     return {
@@ -41648,12 +42323,12 @@ function loadKeybindingsFile(path) {
     };
   }
 }
-var import_node_fs48, DEFAULT_KEYBINDINGS, Keybindings, defaultKeybindings;
+var import_node_fs49, DEFAULT_KEYBINDINGS, Keybindings, defaultKeybindings;
 var init_keybindings = __esm({
   "src/tui/keybindings.ts"() {
     "use strict";
     init_i18n();
-    import_node_fs48 = require("node:fs");
+    import_node_fs49 = require("node:fs");
     init_keys();
     DEFAULT_KEYBINDINGS = {
       "tui.editor.submit": ["enter"],
@@ -42489,7 +43164,7 @@ var init_editor_buffer = __esm({
 function loadHistoryFile(path, limit = 500) {
   let text;
   try {
-    text = (0, import_node_fs49.readFileSync)(path, "utf8");
+    text = (0, import_node_fs50.readFileSync)(path, "utf8");
   } catch {
     return [];
   }
@@ -42506,11 +43181,11 @@ function loadHistoryFile(path, limit = 500) {
 }
 function appendHistoryFile(path, entry, limit) {
   try {
-    (0, import_node_fs49.mkdirSync)((0, import_node_path69.dirname)(path), { recursive: true });
-    (0, import_node_fs49.appendFileSync)(path, JSON.stringify(entry) + "\n", { mode: 384 });
+    (0, import_node_fs50.mkdirSync)((0, import_node_path71.dirname)(path), { recursive: true });
+    (0, import_node_fs50.appendFileSync)(path, JSON.stringify(entry) + "\n", { mode: 384 });
     const all = loadHistoryFile(path, Number.MAX_SAFE_INTEGER);
     if (all.length > limit * 2) {
-      (0, import_node_fs49.writeFileSync)(
+      (0, import_node_fs50.writeFileSync)(
         path,
         all.slice(-limit).map((e) => JSON.stringify(e) + "\n").join("")
       );
@@ -42518,12 +43193,12 @@ function appendHistoryFile(path, entry, limit) {
   } catch {
   }
 }
-var import_node_fs49, import_node_path69;
+var import_node_fs50, import_node_path71;
 var init_editor_history = __esm({
   "src/tui/components/editor-history.ts"() {
     "use strict";
-    import_node_fs49 = require("node:fs");
-    import_node_path69 = require("node:path");
+    import_node_fs50 = require("node:fs");
+    import_node_path71 = require("node:path");
   }
 });
 
@@ -44097,7 +44772,7 @@ var init_key_docs = __esm({
 
 // src/ai/providers/models-dev-cache.ts
 function modelsDevCachePath(dataDir) {
-  return (0, import_node_path71.join)(dataDir, MODELS_DEV_FILE);
+  return (0, import_node_path73.join)(dataDir, MODELS_DEV_FILE);
 }
 function modelsDevUrl(env = process.env) {
   const custom = env[MODELS_DEV_URL_ENV]?.trim();
@@ -44105,7 +44780,7 @@ function modelsDevUrl(env = process.env) {
 }
 function readModelsDevCache(dataDir) {
   try {
-    const value = JSON.parse((0, import_node_fs50.readFileSync)(modelsDevCachePath(dataDir), "utf8"));
+    const value = JSON.parse((0, import_node_fs51.readFileSync)(modelsDevCachePath(dataDir), "utf8"));
     if (typeof value !== "object" || value === null) return void 0;
     const file = value;
     if (file.version !== 2 || typeof file.fetchedAt !== "string") return void 0;
@@ -44118,10 +44793,10 @@ function readModelsDevCache(dataDir) {
 }
 function writeModelsDevCache(dataDir, file) {
   const path = modelsDevCachePath(dataDir);
-  (0, import_node_fs50.mkdirSync)((0, import_node_path71.dirname)(path), { recursive: true, mode: 448 });
+  (0, import_node_fs51.mkdirSync)((0, import_node_path73.dirname)(path), { recursive: true, mode: 448 });
   const tmp = `${path}.${process.pid}.tmp`;
-  (0, import_node_fs50.writeFileSync)(tmp, JSON.stringify(file));
-  (0, import_node_fs50.renameSync)(tmp, path);
+  (0, import_node_fs51.writeFileSync)(tmp, JSON.stringify(file));
+  (0, import_node_fs51.renameSync)(tmp, path);
   memo = void 0;
 }
 function overrideApplies(file) {
@@ -44131,7 +44806,7 @@ function loadModelsDevIndex(dataDir) {
   const path = modelsDevCachePath(dataDir);
   let key;
   try {
-    const stat16 = (0, import_node_fs50.statSync)(path);
+    const stat16 = (0, import_node_fs51.statSync)(path);
     key = `${path}\0${stat16.mtimeMs}\0${stat16.size}`;
   } catch {
     return builtinSnapshotIndex();
@@ -44216,12 +44891,12 @@ function describeRefresh(result, limit = 20) {
   }
   return lines2.join("\n");
 }
-var import_node_fs50, import_node_path71, MODELS_DEV_URL, MODELS_DEV_URL_ENV, MODELS_DEV_FILE, MODELS_DEV_TIMEOUT_MS, memo;
+var import_node_fs51, import_node_path73, MODELS_DEV_URL, MODELS_DEV_URL_ENV, MODELS_DEV_FILE, MODELS_DEV_TIMEOUT_MS, memo;
 var init_models_dev_cache = __esm({
   "src/ai/providers/models-dev-cache.ts"() {
     "use strict";
-    import_node_fs50 = require("node:fs");
-    import_node_path71 = require("node:path");
+    import_node_fs51 = require("node:fs");
+    import_node_path73 = require("node:path");
     init_models_dev();
     init_models_dev_snapshot();
     init_i18n();
@@ -44519,7 +45194,7 @@ var init_json_schema = __esm({
     init_schema_w5();
     init_types_w5();
     CONFIG_SCHEMA_FILE = "config.schema.json";
-    CONFIG_SCHEMA_ID = "https://github.com/Owlbay/armadra-agent/config.schema.json";
+    CONFIG_SCHEMA_ID = "https://github.com/AMA-Link/armadra-agent/config.schema.json";
     KNOWN_APIS = [
       "openai-completions",
       "openai-responses",
@@ -44566,40 +45241,40 @@ function minimalConfig() {
 }
 function writeAtomic2(path, text, mode) {
   const tmp = `${path}.${process.pid}.tmp`;
-  (0, import_node_fs51.writeFileSync)(tmp, text, { mode });
-  (0, import_node_fs51.renameSync)(tmp, path);
+  (0, import_node_fs52.writeFileSync)(tmp, text, { mode });
+  (0, import_node_fs52.renameSync)(tmp, path);
 }
 function initConfigDir(dir, options = {}) {
-  const dirCreated = !(0, import_node_fs51.existsSync)(dir);
-  (0, import_node_fs51.mkdirSync)(dir, { recursive: true, mode: 448 });
-  if (dirCreated && process.platform !== "win32") (0, import_node_fs51.chmodSync)(dir, 448);
+  const dirCreated = !(0, import_node_fs52.existsSync)(dir);
+  (0, import_node_fs52.mkdirSync)(dir, { recursive: true, mode: 448 });
+  if (dirCreated && process.platform !== "win32") (0, import_node_fs52.chmodSync)(dir, 448);
   const files = [];
-  const config = (0, import_node_path72.join)(dir, CONFIG_FILE);
+  const config = (0, import_node_path74.join)(dir, CONFIG_FILE);
   const text = `${JSON.stringify(minimalConfig(), null, 2)}
 `;
-  if (!(0, import_node_fs51.existsSync)(config)) {
+  if (!(0, import_node_fs52.existsSync)(config)) {
     writeAtomic2(config, text, 420);
     files.push({ path: config, status: "created" });
   } else if (options.force) {
-    (0, import_node_fs51.copyFileSync)(config, `${config}.bak`);
+    (0, import_node_fs52.copyFileSync)(config, `${config}.bak`);
     writeAtomic2(config, text, 420);
     files.push({ path: config, status: "overwritten" });
   } else files.push({ path: config, status: "exists" });
-  const schema = (0, import_node_path72.join)(dir, CONFIG_SCHEMA_FILE);
+  const schema = (0, import_node_path74.join)(dir, CONFIG_SCHEMA_FILE);
   const schemaText = configSchemaText();
-  if (!(0, import_node_fs51.existsSync)(schema)) {
+  if (!(0, import_node_fs52.existsSync)(schema)) {
     writeAtomic2(schema, schemaText, 420);
     files.push({ path: schema, status: "created" });
-  } else if ((0, import_node_fs51.readFileSync)(schema, "utf8") !== schemaText) {
+  } else if ((0, import_node_fs52.readFileSync)(schema, "utf8") !== schemaText) {
     writeAtomic2(schema, schemaText, 420);
     files.push({ path: schema, status: "updated" });
   } else files.push({ path: schema, status: "unchanged" });
-  const auth = (0, import_node_path72.join)(dir, AUTH_FILE);
-  if ((0, import_node_fs51.existsSync)(auth)) files.push({ path: auth, status: "exists" });
+  const auth = (0, import_node_path74.join)(dir, AUTH_FILE);
+  if ((0, import_node_fs52.existsSync)(auth)) files.push({ path: auth, status: "exists" });
   return { dir, dirCreated, files };
 }
 function autoInitConfigDir(dir, env) {
-  if (env[NO_INIT_ENV] === "1" || (0, import_node_fs51.existsSync)(dir)) return false;
+  if (env[NO_INIT_ENV] === "1" || (0, import_node_fs52.existsSync)(dir)) return false;
   try {
     initConfigDir(dir);
     return true;
@@ -44617,12 +45292,12 @@ function describeInit(result) {
   return `${lines2.join("\n")}
 `;
 }
-var import_node_fs51, import_node_path72, NO_INIT_ENV;
+var import_node_fs52, import_node_path74, NO_INIT_ENV;
 var init_init = __esm({
   "src/config/init.ts"() {
     "use strict";
-    import_node_fs51 = require("node:fs");
-    import_node_path72 = require("node:path");
+    import_node_fs52 = require("node:fs");
+    import_node_path74 = require("node:path");
     init_i18n();
     init_json_schema();
     init_paths();
@@ -45668,6 +46343,13 @@ function recoverChatGptError(error2, model, compat, options, apiKey, tried) {
       return { kind: "retry" };
     }
   }
+  if (backend === "codex" && error2.status === 400 && /not supported when using codex with a chatgpt account/i.test(error2.body))
+    return {
+      kind: "fail",
+      error: new Error(
+        `model_unavailable: ${msg().auth.request.modelUnavailable(`${provider}/${model.id}`)}`
+      )
+    };
   if (backend === "codex" && error2.status === 400 && /instructions are not valid/i.test(error2.body) && !tried.has("instructions")) {
     tried.add("instructions");
     developerMode.add(sessionKeyOf(model, options));
@@ -47498,14 +48180,14 @@ var init_api = __esm({
 // src/ai/providers/auth.ts
 function defaultConfigDir(env = process.env) {
   if (env["AMA_CONFIG_DIR"]) return env["AMA_CONFIG_DIR"];
-  if (process.platform === "win32" && env["APPDATA"]) return (0, import_node_path73.join)(env["APPDATA"], "ama");
-  if (env["XDG_CONFIG_HOME"]) return (0, import_node_path73.join)(env["XDG_CONFIG_HOME"], "ama");
-  return (0, import_node_path73.join)(env["HOME"] ?? (0, import_node_os11.homedir)(), ".config", "ama");
+  if (process.platform === "win32" && env["APPDATA"]) return (0, import_node_path75.join)(env["APPDATA"], "ama");
+  if (env["XDG_CONFIG_HOME"]) return (0, import_node_path75.join)(env["XDG_CONFIG_HOME"], "ama");
+  return (0, import_node_path75.join)(env["HOME"] ?? (0, import_node_os12.homedir)(), ".config", "ama");
 }
 function readAuthFile2(path, onWarning) {
   let raw;
   try {
-    raw = (0, import_node_fs52.readFileSync)(path, "utf8");
+    raw = (0, import_node_fs53.readFileSync)(path, "utf8");
   } catch (error2) {
     const code = error2.code;
     if (code !== "ENOENT") onWarning?.(`cannot read auth file ${path}`);
@@ -47513,7 +48195,7 @@ function readAuthFile2(path, onWarning) {
   }
   if (process.platform !== "win32") {
     try {
-      const mode = (0, import_node_fs52.statSync)(path).mode & 511;
+      const mode = (0, import_node_fs53.statSync)(path).mode & 511;
       if ((mode & 63) !== 0) {
         onWarning?.(
           `auth file ${path} has permissions ${mode.toString(8).padStart(4, "0")}; expected 0600`
@@ -47547,14 +48229,14 @@ function expandEnvRefs(value, env) {
   );
   return missing || out.length === 0 ? void 0 : out;
 }
-var import_node_child_process13, import_node_fs52, import_node_os11, import_node_path73, ApiKeyResolver;
+var import_node_child_process13, import_node_fs53, import_node_os12, import_node_path75, ApiKeyResolver;
 var init_auth2 = __esm({
   "src/ai/providers/auth.ts"() {
     "use strict";
     import_node_child_process13 = require("node:child_process");
-    import_node_fs52 = require("node:fs");
-    import_node_os11 = require("node:os");
-    import_node_path73 = require("node:path");
+    import_node_fs53 = require("node:fs");
+    import_node_os12 = require("node:os");
+    import_node_path75 = require("node:path");
     init_live();
     init_refresh();
     init_token_store();
@@ -47574,7 +48256,7 @@ var init_auth2 = __esm({
       authFiles() {
         const files = [];
         if (this.options.authFile) files.push(this.options.authFile);
-        const user = this.options.userAuthFile === void 0 ? (0, import_node_path73.join)(defaultConfigDir(this.env), "auth.json") : this.options.userAuthFile;
+        const user = this.options.userAuthFile === void 0 ? (0, import_node_path75.join)(defaultConfigDir(this.env), "auth.json") : this.options.userAuthFile;
         if (user && !files.includes(user)) files.push(user);
         return files;
       }
@@ -48340,26 +49022,26 @@ var init_settings_registry = __esm({
 
 // src/config/write.ts
 function writeConfigFile(path, config, options = {}) {
-  (0, import_node_fs53.mkdirSync)((0, import_node_path75.dirname)(path), { recursive: true });
+  (0, import_node_fs54.mkdirSync)((0, import_node_path77.dirname)(path), { recursive: true });
   let mode;
   try {
-    mode = (0, import_node_fs53.statSync)(path).mode & 511;
+    mode = (0, import_node_fs54.statSync)(path).mode & 511;
   } catch {
     mode = void 0;
   }
-  if (mode !== void 0 && options.backup !== false) (0, import_node_fs53.copyFileSync)(path, `${path}.bak`);
+  if (mode !== void 0 && options.backup !== false) (0, import_node_fs54.copyFileSync)(path, `${path}.bak`);
   const tmp = `${path}.${process.pid}.tmp`;
-  (0, import_node_fs53.writeFileSync)(tmp, `${JSON.stringify(config, null, 2)}
+  (0, import_node_fs54.writeFileSync)(tmp, `${JSON.stringify(config, null, 2)}
 `, { mode: mode ?? 420 });
-  if (mode !== void 0) (0, import_node_fs53.chmodSync)(tmp, mode);
-  (0, import_node_fs53.renameSync)(tmp, path);
+  if (mode !== void 0) (0, import_node_fs54.chmodSync)(tmp, mode);
+  (0, import_node_fs54.renameSync)(tmp, path);
 }
-var import_node_fs53, import_node_path75;
+var import_node_fs54, import_node_path77;
 var init_write2 = __esm({
   "src/config/write.ts"() {
     "use strict";
-    import_node_fs53 = require("node:fs");
-    import_node_path75 = require("node:path");
+    import_node_fs54 = require("node:fs");
+    import_node_path77 = require("node:path");
   }
 });
 
@@ -48557,7 +49239,7 @@ function parseEnum(key, text, options) {
 function readTarget(path, scope) {
   let text;
   try {
-    text = (0, import_node_fs54.readFileSync)(path, "utf8");
+    text = (0, import_node_fs55.readFileSync)(path, "utf8");
   } catch (error2) {
     if (error2.code === "ENOENT")
       return scope === "user" ? minimalConfig() : { version: CONFIG_FILE_VERSION };
@@ -48639,11 +49321,11 @@ function formatSettingValue(value) {
   if (typeof value === "string") return value;
   return JSON.stringify(value);
 }
-var import_node_fs54, ConfigEditError, same, ABOVE, TRUE, FALSE, UNSET;
+var import_node_fs55, ConfigEditError, same, ABOVE, TRUE, FALSE, UNSET;
 var init_edit2 = __esm({
   "src/config/edit.ts"() {
     "use strict";
-    import_node_fs54 = require("node:fs");
+    import_node_fs55 = require("node:fs");
     init_errors();
     init_i18n();
     init_init();
@@ -48719,11 +49401,11 @@ async function readClipboardImage(dataDir, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const env = deps.env ?? process.env;
   const run7 = deps.run ?? runCommand;
-  const dir = (0, import_node_path78.join)(dataDir, CLIPBOARD_DIR);
+  const dir = (0, import_node_path80.join)(dataDir, CLIPBOARD_DIR);
   await (0, import_promises22.mkdir)(dir, { recursive: true });
   const stamp = new Date((deps.now ?? Date.now)()).toISOString().replace(/[:.]/g, "-");
-  let file = (0, import_node_path78.join)(dir, `${stamp}.png`);
-  for (let n = 1; (0, import_node_fs60.existsSync)(file); n++) file = (0, import_node_path78.join)(dir, `${stamp}-${n}.png`);
+  let file = (0, import_node_path80.join)(dir, `${stamp}.png`);
+  for (let n = 1; (0, import_node_fs61.existsSync)(file); n++) file = (0, import_node_path80.join)(dir, `${stamp}-${n}.png`);
   let anyTool = false;
   for (const attempt of attempts(platform, file, env)) {
     const options = attempt.via === "file" && attempt.env !== void 0 ? { env: attempt.env } : {};
@@ -48742,7 +49424,7 @@ async function readClipboardImage(dataDir, deps = {}) {
   return { ok: false, reason: anyTool ? "no_image" : "no_tool" };
 }
 async function gcClipboardImages(dataDir, options = {}) {
-  const dir = (0, import_node_path78.join)(dataDir, CLIPBOARD_DIR);
+  const dir = (0, import_node_path80.join)(dataDir, CLIPBOARD_DIR);
   let names;
   try {
     names = await (0, import_promises22.readdir)(dir);
@@ -48752,7 +49434,7 @@ async function gcClipboardImages(dataDir, options = {}) {
   const cutoff = (options.now ?? Date.now()) - (options.maxAgeDays ?? CLIPBOARD_MAX_AGE_DAYS) * 864e5;
   const removed = [];
   for (const name of names) {
-    const file = (0, import_node_path78.join)(dir, name);
+    const file = (0, import_node_path80.join)(dir, name);
     try {
       const info2 = await (0, import_promises22.stat)(file);
       if (!info2.isFile() || info2.mtimeMs >= cutoff) continue;
@@ -48763,13 +49445,13 @@ async function gcClipboardImages(dataDir, options = {}) {
   }
   return removed;
 }
-var import_node_fs60, import_promises22, import_node_path78, CLIPBOARD_DIR, CLIPBOARD_MAX_AGE_DAYS, OSASCRIPT, POWERSHELL;
+var import_node_fs61, import_promises22, import_node_path80, CLIPBOARD_DIR, CLIPBOARD_MAX_AGE_DAYS, OSASCRIPT, POWERSHELL;
 var init_clipboard_image = __esm({
   "src/tools/clipboard-image.ts"() {
     "use strict";
-    import_node_fs60 = require("node:fs");
+    import_node_fs61 = require("node:fs");
     import_promises22 = require("node:fs/promises");
-    import_node_path78 = require("node:path");
+    import_node_path80 = require("node:path");
     init_image_file();
     init_image_resize();
     CLIPBOARD_DIR = "clipboard";
@@ -50156,7 +50838,7 @@ function statusCost(stats) {
 function layoutRow(parts, width2, theme, style = {}) {
   const sep5 = style.sep ?? " · ";
   const dim = (text) => text === "" ? "" : theme.fg("dim", text);
-  const join67 = (list5) => {
+  const join68 = (list5) => {
     let out = "";
     let size = 0;
     const add3 = (text, measured = visibleWidth(text)) => {
@@ -50188,7 +50870,7 @@ function layoutRow(parts, width2, theme, style = {}) {
     const left = zone("left");
     const right = zone("right");
     const between = left.length === 0 || right.length === 0 ? 0 : sep5.length;
-    return join67(left)[1] + between + join67(right)[1] <= width2;
+    return join68(left)[1] + between + join68(right)[1] <= width2;
   };
   while (!fits()) {
     const droppable = kept.filter((p) => p.priority !== void 0);
@@ -50196,8 +50878,8 @@ function layoutRow(parts, width2, theme, style = {}) {
     const drop = droppable.reduce((worst, p) => p.priority > worst.priority ? p : worst);
     kept = kept.filter((p) => p !== drop);
   }
-  const l = join67(zone("left"))[0];
-  const r = join67(zone("right"))[0];
+  const l = join68(zone("left"))[0];
+  const r = join68(zone("right"))[0];
   const gap = width2 - visibleWidth(l) - visibleWidth(r);
   const line2 = r === "" ? l : l === "" ? " ".repeat(Math.max(0, gap)) + r : gap >= MIN_GAP ? l + " ".repeat(gap) + r : l + dim(sep5) + r;
   return truncateToWidth(line2, width2);
@@ -50456,9 +51138,9 @@ function flat(text, max = 120) {
   return one.length > max ? `${one.slice(0, max - 1)}…` : one;
 }
 function displayPath2(path, cwd) {
-  if (cwd === void 0 || !(0, import_node_path83.isAbsolute)(path)) return path;
-  const rel = (0, import_node_path83.relative)(cwd, path);
-  return rel === "" ? "." : rel.startsWith("..") || (0, import_node_path83.isAbsolute)(rel) ? path : rel;
+  if (cwd === void 0 || !(0, import_node_path85.isAbsolute)(path)) return path;
+  const rel = (0, import_node_path85.relative)(cwd, path);
+  return rel === "" ? "." : rel.startsWith("..") || (0, import_node_path85.isAbsolute)(rel) ? path : rel;
 }
 function toolSummary(name, args, cwd) {
   if (typeof args !== "object" || args === null) return "";
@@ -50613,12 +51295,12 @@ function resultSummary(input2, theme) {
       return muted(count2 === 0 ? m.done : m.outputLines(count2));
   }
 }
-var import_node_path83;
+var import_node_path85;
 var init_tool_summary = __esm({
   "src/modes/interactive/tool-summary.ts"() {
     "use strict";
     init_i18n();
-    import_node_path83 = require("node:path");
+    import_node_path85 = require("node:path");
     init_tui2();
     init_status_bar();
   }
@@ -51435,7 +52117,7 @@ function childLoader(read2 = readTraceInput) {
   const load2 = ((file) => {
     let stamp = "";
     try {
-      const st = (0, import_node_fs63.statSync)(file);
+      const st = (0, import_node_fs64.statSync)(file);
       stamp = `${st.mtimeMs}:${st.size}`;
     } catch {
       stamp = "missing";
@@ -51479,11 +52161,11 @@ function traceText(session, taskId) {
     `${msg().trace.taskTitle(node.taskId, node.agent)}${summary2}`
   );
 }
-var import_node_fs63, LiveTracker, lineTraceCommand;
+var import_node_fs64, LiveTracker, lineTraceCommand;
 var init_session3 = __esm({
   "src/trace/session.ts"() {
     "use strict";
-    import_node_fs63 = require("node:fs");
+    import_node_fs64 = require("node:fs");
     init_session2();
     init_i18n();
     init_scan();
@@ -51557,10 +52239,10 @@ var init_session3 = __esm({
 
 // src/skills/builtin.ts
 function builtinSkillPath(dataDir, name) {
-  return (0, import_node_path86.join)(dataDir, BUILTIN_SKILLS_DIR, `${name}.md`);
+  return (0, import_node_path88.join)(dataDir, BUILTIN_SKILLS_DIR, `${name}.md`);
 }
 function isBuiltinSkill(skill) {
-  return BUILTIN_SKILLS.some((b) => b.name === skill.name) && skill.location.endsWith((0, import_node_path86.join)(BUILTIN_SKILLS_DIR, `${skill.name}.md`));
+  return BUILTIN_SKILLS.some((b) => b.name === skill.name) && skill.location.endsWith((0, import_node_path88.join)(BUILTIN_SKILLS_DIR, `${skill.name}.md`));
 }
 function builtinSkillText(skill) {
   return `---
@@ -51575,7 +52257,7 @@ async function ensureFile(path, text) {
     if (await (0, import_promises23.readFile)(path, "utf8") === text) return;
   } catch {
   }
-  await (0, import_promises23.mkdir)((0, import_node_path86.dirname)(path), { recursive: true });
+  await (0, import_promises23.mkdir)((0, import_node_path88.dirname)(path), { recursive: true });
   await (0, import_promises23.writeFile)(path, text, "utf8");
 }
 async function withBuiltinSkills(skills, dataDir, builtins = BUILTIN_SKILLS) {
@@ -51584,7 +52266,7 @@ async function withBuiltinSkills(skills, dataDir, builtins = BUILTIN_SKILLS) {
   const taken = new Set(skills.map((skill) => skill.name));
   for (const builtin2 of builtins) {
     if (taken.has(builtin2.name)) continue;
-    const baseDir = (0, import_node_path86.join)(dataDir, BUILTIN_SKILLS_DIR);
+    const baseDir = (0, import_node_path88.join)(dataDir, BUILTIN_SKILLS_DIR);
     const location = builtinSkillPath(dataDir, builtin2.name);
     try {
       await ensureFile(location, builtinSkillText(builtin2));
@@ -51605,16 +52287,16 @@ async function withBuiltinSkills(skills, dataDir, builtins = BUILTIN_SKILLS) {
   }
   return { skills: out, warnings };
 }
-var import_promises23, import_node_path86, BUILTIN_SKILLS_DIR, AMA_DOCS_BODY, BUILTIN_SKILLS;
+var import_promises23, import_node_path88, BUILTIN_SKILLS_DIR, AMA_DOCS_BODY, BUILTIN_SKILLS;
 var init_builtin3 = __esm({
   "src/skills/builtin.ts"() {
     "use strict";
     import_promises23 = require("node:fs/promises");
-    import_node_path86 = require("node:path");
+    import_node_path88 = require("node:path");
     BUILTIN_SKILLS_DIR = "builtin";
     AMA_DOCS_BODY = `# ama quick reference
 
-ama is the coding agent running this session. Docs: https://github.com/Owlbay/armadra-agent (README.md, docs/).
+ama is the coding agent running this session. Docs: https://github.com/AMA-Link/armadra-agent (README.md, docs/).
 
 ## Files
 - User config dir \`~/.config/ama/\` (\`AMA_CONFIG_DIR\`; Windows \`%APPDATA%\\ama\`): \`config.json\`, \`auth.json\` (keys, 0600), \`hooks.json\`, \`keybindings.json\`, \`trust.json\`, \`AGENTS.md\`, \`skills/\`, \`prompts/\`.
@@ -51663,33 +52345,33 @@ Skills: \`<dir>/<name>/SKILL.md\` with \`name\` and \`description\` frontmatter
 // src/skills/discover.ts
 function ancestorDirs(cwd) {
   const out = [];
-  let dir = (0, import_node_path87.resolve)(cwd);
+  let dir = (0, import_node_path89.resolve)(cwd);
   for (; ; ) {
     out.push(dir);
-    if ((0, import_node_fs65.existsSync)((0, import_node_path87.join)(dir, ".git"))) return out;
-    const parent = (0, import_node_path87.dirname)(dir);
+    if ((0, import_node_fs66.existsSync)((0, import_node_path89.join)(dir, ".git"))) return out;
+    const parent = (0, import_node_path89.dirname)(dir);
     if (parent === dir) return out;
     dir = parent;
   }
 }
 function skillSources(options) {
   const sources = [];
-  const add3 = (dir, scope, requiresTrust) => sources.push({ dir: (0, import_node_path87.resolve)(options.cwd, dir), scope, requiresTrust });
+  const add3 = (dir, scope, requiresTrust) => sources.push({ dir: (0, import_node_path89.resolve)(options.cwd, dir), scope, requiresTrust });
   for (const d of options.cliDirs ?? []) add3(d, "cli", false);
   for (const d of options.profileDirs ?? []) add3(d, "profile", false);
   for (const d of options.configDirs ?? []) add3(d, "config", false);
-  add3((0, import_node_path87.join)(options.configDir, "skills"), "user", false);
-  add3((0, import_node_path87.join)(options.cwd, ".ama", "skills"), "project", true);
-  for (const d of ancestorDirs(options.cwd)) add3((0, import_node_path87.join)(d, ".agents", "skills"), "ancestor", true);
+  add3((0, import_node_path89.join)(options.configDir, "skills"), "user", false);
+  add3((0, import_node_path89.join)(options.cwd, ".ama", "skills"), "project", true);
+  for (const d of ancestorDirs(options.cwd)) add3((0, import_node_path89.join)(d, ".agents", "skills"), "ancestor", true);
   return sources;
 }
 function parseSkill(text, location, scope) {
   const warnings = [];
   const fm = parseFrontmatter(text);
   for (const e of fm.errors) warnings.push(`${location}: ${e}`);
-  const baseDir = (0, import_node_path87.dirname)(location);
+  const baseDir = (0, import_node_path89.dirname)(location);
   const rawName = fm.data["name"];
-  const name = typeof rawName === "string" && rawName !== "" ? rawName : (0, import_node_path87.basename)(baseDir);
+  const name = typeof rawName === "string" && rawName !== "" ? rawName : (0, import_node_path89.basename)(baseDir);
   if (name.length > MAX_SKILL_NAME || !SKILL_NAME_RE.test(name)) {
     warnings.push(`${location}: invalid skill name "${name}" (lowercase letters, digits, -)`);
     return { warnings };
@@ -51727,8 +52409,8 @@ async function isDir3(path) {
 }
 async function findSkillFiles(dir, depth = 0) {
   if (depth > MAX_DEPTH3) return [];
-  const own = (0, import_node_path87.join)(dir, SKILL_FILE);
-  if ((0, import_node_fs65.existsSync)(own)) return [own];
+  const own = (0, import_node_path89.join)(dir, SKILL_FILE);
+  if ((0, import_node_fs66.existsSync)(own)) return [own];
   let names;
   try {
     names = await (0, import_promises24.readdir)(dir);
@@ -51739,7 +52421,7 @@ async function findSkillFiles(dir, depth = 0) {
   const out = [];
   for (const name of names) {
     if (SKIP_DIRS.has(name)) continue;
-    const child = (0, import_node_path87.join)(dir, name);
+    const child = (0, import_node_path89.join)(dir, name);
     if (await isDir3(child)) out.push(...await findSkillFiles(child, depth + 1));
   }
   return out;
@@ -51780,13 +52462,13 @@ async function discoverSkills(sources, options) {
   }
   return result;
 }
-var import_node_fs65, import_promises24, import_node_path87, SKILL_FILE, SKILL_NAME_RE, MAX_SKILL_NAME, MAX_SKILL_DESCRIPTION, MAX_DEPTH3, SKIP_DIRS;
+var import_node_fs66, import_promises24, import_node_path89, SKILL_FILE, SKILL_NAME_RE, MAX_SKILL_NAME, MAX_SKILL_DESCRIPTION, MAX_DEPTH3, SKIP_DIRS;
 var init_discover2 = __esm({
   "src/skills/discover.ts"() {
     "use strict";
-    import_node_fs65 = require("node:fs");
+    import_node_fs66 = require("node:fs");
     import_promises24 = require("node:fs/promises");
-    import_node_path87 = require("node:path");
+    import_node_path89 = require("node:path");
     init_frontmatter2();
     SKILL_FILE = "SKILL.md";
     SKILL_NAME_RE = /^[a-z0-9-]+$/;
@@ -51901,14 +52583,14 @@ var init_protocol2 = __esm({
 
 // src/codemode/host-side.ts
 function resolveSandboxEntry(moduleUrl = __ama_import_meta_url) {
-  const here = (0, import_node_path88.dirname)((0, import_node_url2.fileURLToPath)(moduleUrl));
+  const here = (0, import_node_path90.dirname)((0, import_node_url2.fileURLToPath)(moduleUrl));
   const candidates2 = [];
   if (true)
-    candidates2.push((0, import_node_path88.join)(here, "ama-sandbox.cjs"));
-  candidates2.push((0, import_node_path88.join)(here, "sandbox-entry.js"));
-  candidates2.push((0, import_node_path88.join)(here, "sandbox-entry.ts"));
+    candidates2.push((0, import_node_path90.join)(here, "ama-sandbox.cjs"));
+  candidates2.push((0, import_node_path90.join)(here, "sandbox-entry.js"));
+  candidates2.push((0, import_node_path90.join)(here, "sandbox-entry.ts"));
   for (const candidate of candidates2) {
-    if ((0, import_node_fs66.existsSync)(candidate)) return (0, import_node_fs66.realpathSync)(candidate);
+    if ((0, import_node_fs67.existsSync)(candidate)) return (0, import_node_fs67.realpathSync)(candidate);
   }
   return void 0;
 }
@@ -52140,13 +52822,13 @@ async function runSandbox(request) {
   child.stdin.end();
   return result;
 }
-var import_node_child_process16, import_node_fs66, import_node_path88, import_node_url2, MAX_COLLECTED_OUTPUT_CHARS, ABORT_GRACE_MS, DEFAULT_CODEMODE_HEAP_MB, CODEMODE_OS_POLICY;
+var import_node_child_process16, import_node_fs67, import_node_path90, import_node_url2, MAX_COLLECTED_OUTPUT_CHARS, ABORT_GRACE_MS, DEFAULT_CODEMODE_HEAP_MB, CODEMODE_OS_POLICY;
 var init_host_side = __esm({
   "src/codemode/host-side.ts"() {
     "use strict";
     import_node_child_process16 = require("node:child_process");
-    import_node_fs66 = require("node:fs");
-    import_node_path88 = require("node:path");
+    import_node_fs67 = require("node:fs");
+    import_node_path90 = require("node:path");
     import_node_url2 = require("node:url");
     init_detect();
     init_wrap();
@@ -52208,7 +52890,7 @@ var init_store5 = __esm({
 });
 
 // src/codemode/tool.ts
-function textOf4(content) {
+function textOf5(content) {
   if (typeof content === "string") return content;
   return content.map((block) => block.type === "text" ? block.text : "").join("");
 }
@@ -52227,8 +52909,8 @@ function toScriptValue(name, result) {
     if (s2.full_output_path !== void 0) value.fullOutputPath = s2.full_output_path;
     return value;
   }
-  if (result.isError === true) throw new Error(textOf4(result.content) || `Tool ${name} failed`);
-  return result.structured !== void 0 ? result.structured : textOf4(result.content);
+  if (result.isError === true) throw new Error(textOf5(result.content) || `Tool ${name} failed`);
+  return result.structured !== void 0 ? result.structured : textOf5(result.content);
 }
 function scriptErrorHint(error2, toolNames2) {
   if (/Cannot use import statement|dynamic import callback/.test(error2) || SCRIPT_ONLY_GLOBALS.test(error2)) {
@@ -52310,10 +52992,10 @@ ${output.slice(-half)}`;
 }
 function saveFullOutput(ctx, text) {
   try {
-    const dir = ctx.outputDir ?? (0, import_node_path89.join)((0, import_node_os13.tmpdir)(), "ama-codemode");
-    (0, import_node_fs67.mkdirSync)(dir, { recursive: true });
-    const file = (0, import_node_path89.join)(dir, `${ctx.toolCallId.replace(/[^A-Za-z0-9_-]/g, "_")}.txt`);
-    (0, import_node_fs67.writeFileSync)(file, text, "utf8");
+    const dir = ctx.outputDir ?? (0, import_node_path91.join)((0, import_node_os14.tmpdir)(), "ama-codemode");
+    (0, import_node_fs68.mkdirSync)(dir, { recursive: true });
+    const file = (0, import_node_path91.join)(dir, `${ctx.toolCallId.replace(/[^A-Za-z0-9_-]/g, "_")}.txt`);
+    (0, import_node_fs68.writeFileSync)(file, text, "utf8");
     return file;
   } catch {
     return void 0;
@@ -52419,7 +53101,7 @@ function createCodemodeTool(options) {
       return shown2;
     },
     renderResult(result, width2, expanded) {
-      const lines2 = textOf4(result.content).split("\n");
+      const lines2 = textOf5(result.content).split("\n");
       const clip4 = (line2) => line2.slice(0, Math.max(10, width2));
       if (expanded || lines2.length <= 8) return lines2.map(clip4);
       return [clip4(lines2[0] ?? ""), `… ${lines2.length - 6} lines`, ...lines2.slice(-5).map(clip4)];
@@ -52465,13 +53147,13 @@ function codemodeToolFactory(overrides = {}) {
     return createCodemodeTool(options);
   };
 }
-var import_node_fs67, import_node_os13, import_node_path89, CODEMODE_TOOL_NAME2, DEFAULT_MAX_TOOL_RESULT_CHARS2, CODEMODE_EXAMPLE, SCRIPT_ONLY_GLOBALS, TAIL_CHARS, CODEMODE_ONLY_GUIDELINE;
+var import_node_fs68, import_node_os14, import_node_path91, CODEMODE_TOOL_NAME2, DEFAULT_MAX_TOOL_RESULT_CHARS2, CODEMODE_EXAMPLE, SCRIPT_ONLY_GLOBALS, TAIL_CHARS, CODEMODE_ONLY_GUIDELINE;
 var init_tool = __esm({
   "src/codemode/tool.ts"() {
     "use strict";
-    import_node_fs67 = require("node:fs");
-    import_node_os13 = require("node:os");
-    import_node_path89 = require("node:path");
+    import_node_fs68 = require("node:fs");
+    import_node_os14 = require("node:os");
+    import_node_path91 = require("node:path");
     init_presets2();
     init_capability();
     init_declarations();
@@ -52583,7 +53265,7 @@ var init_tool2 = __esm({
 // src/cli/codemode-notice.ts
 function readNotices(path) {
   try {
-    const value = JSON.parse((0, import_node_fs68.readFileSync)(path, "utf8"));
+    const value = JSON.parse((0, import_node_fs69.readFileSync)(path, "utf8"));
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
       const shown2 = value[KEY];
       return {
@@ -52602,26 +53284,26 @@ function takeCodemodeNotice(input2) {
   const resolved = resolveCodemodeMode(input2.config, input2.capability.strict);
   if (resolved.source !== "preset" || resolved.preset !== "default" || input2.capability.strict)
     return void 0;
-  const path = (0, import_node_path90.join)(input2.dataDir, NOTICES_FILE);
+  const path = (0, import_node_path92.join)(input2.dataDir, NOTICES_FILE);
   const notices = readNotices(path);
   const shown2 = notices[KEY] ?? [];
   if (shown2.includes(input2.configDir)) return void 0;
   try {
-    (0, import_node_fs68.mkdirSync)(input2.dataDir, { recursive: true });
+    (0, import_node_fs69.mkdirSync)(input2.dataDir, { recursive: true });
     const tmp = `${path}.${process.pid}.tmp`;
-    (0, import_node_fs68.writeFileSync)(tmp, `${JSON.stringify({ ...notices, [KEY]: [...shown2, input2.configDir] })}
+    (0, import_node_fs69.writeFileSync)(tmp, `${JSON.stringify({ ...notices, [KEY]: [...shown2, input2.configDir] })}
 `);
-    (0, import_node_fs68.renameSync)(tmp, path);
+    (0, import_node_fs69.renameSync)(tmp, path);
   } catch {
   }
   return codemodeNoticeText(input2.capability);
 }
-var import_node_fs68, import_node_path90, NOTICES_FILE, KEY;
+var import_node_fs69, import_node_path92, NOTICES_FILE, KEY;
 var init_codemode_notice = __esm({
   "src/cli/codemode-notice.ts"() {
     "use strict";
-    import_node_fs68 = require("node:fs");
-    import_node_path90 = require("node:path");
+    import_node_fs69 = require("node:fs");
+    import_node_path92 = require("node:path");
     init_presets2();
     init_i18n();
     NOTICES_FILE = "notices.json";
@@ -52631,13 +53313,13 @@ var init_codemode_notice = __esm({
 
 // src/ai/providers/max-tokens-cache.ts
 function maxTokensCachePath(dataDir) {
-  return (0, import_node_path91.join)(dataDir, "models", "max-tokens-caps.json");
+  return (0, import_node_path93.join)(dataDir, "models", "max-tokens-caps.json");
 }
 function readEntries(dataDir, now) {
   const out = /* @__PURE__ */ new Map();
   let parsed;
   try {
-    parsed = JSON.parse((0, import_node_fs69.readFileSync)(maxTokensCachePath(dataDir), "utf8"));
+    parsed = JSON.parse((0, import_node_fs70.readFileSync)(maxTokensCachePath(dataDir), "utf8"));
   } catch {
     return out;
   }
@@ -52671,11 +53353,11 @@ function recordMaxTokensCap(dataDir, key, cap, now = Date.now) {
   const path = maxTokensCachePath(dataDir);
   const tmp = `${path}.${process.pid}.tmp`;
   try {
-    (0, import_node_fs69.mkdirSync)((0, import_node_path91.dirname)(path), { recursive: true, mode: 448 });
+    (0, import_node_fs70.mkdirSync)((0, import_node_path93.dirname)(path), { recursive: true, mode: 448 });
     const caps = Object.fromEntries([...entries].sort(([a], [b]) => a < b ? -1 : 1));
-    (0, import_node_fs69.writeFileSync)(tmp, `${JSON.stringify({ version: MAX_TOKENS_CACHE_VERSION, caps }, null, 2)}
+    (0, import_node_fs70.writeFileSync)(tmp, `${JSON.stringify({ version: MAX_TOKENS_CACHE_VERSION, caps }, null, 2)}
 `);
-    (0, import_node_fs69.renameSync)(tmp, path);
+    (0, import_node_fs70.renameSync)(tmp, path);
   } catch {
   }
 }
@@ -52691,12 +53373,12 @@ function attachMaxTokensCache(dataDir, now = Date.now) {
   attached2.set(dataDir, detach);
   return detach;
 }
-var import_node_fs69, import_node_path91, MAX_TOKENS_CACHE_VERSION, MAX_TOKENS_CACHE_TTL_MS, attached2;
+var import_node_fs70, import_node_path93, MAX_TOKENS_CACHE_VERSION, MAX_TOKENS_CACHE_TTL_MS, attached2;
 var init_max_tokens_cache = __esm({
   "src/ai/providers/max-tokens-cache.ts"() {
     "use strict";
-    import_node_fs69 = require("node:fs");
-    import_node_path91 = require("node:path");
+    import_node_fs70 = require("node:fs");
+    import_node_path93 = require("node:path");
     init_max_tokens();
     MAX_TOKENS_CACHE_VERSION = 1;
     MAX_TOKENS_CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
@@ -52836,8 +53518,8 @@ var init_compose_providers = __esm({
 
 // src/modes/image-input.ts
 function expand(path, cwd) {
-  const home = path === "~" || path.startsWith("~/") ? (0, import_node_os14.homedir)() + path.slice(1) : path;
-  return (0, import_node_path92.resolve)(cwd, home);
+  const home = path === "~" || path.startsWith("~/") ? (0, import_node_os15.homedir)() + path.slice(1) : path;
+  return (0, import_node_path94.resolve)(cwd, home);
 }
 function findImageRefs(text, cwd) {
   const out = [];
@@ -52849,7 +53531,7 @@ function findImageRefs(text, cwd) {
     token = token.replace(/\\ /g, " ").replace(/[,\uFF0C\u3002;\uFF1B)\uFF09]+$/, "");
     if (token === "" || imageMimeFromPath(token) === void 0) continue;
     const path = expand(token, cwd);
-    if (!explicit && !(0, import_node_fs70.existsSync)(path)) continue;
+    if (!explicit && !(0, import_node_fs71.existsSync)(path)) continue;
     if (seen.has(path)) continue;
     seen.add(path);
     out.push({ path, explicit });
@@ -52908,13 +53590,13 @@ async function loadLocalized(path, options) {
     throw error2;
   }
 }
-var import_node_fs70, import_node_os14, import_node_path92, TOKEN;
+var import_node_fs71, import_node_os15, import_node_path94, TOKEN;
 var init_image_input = __esm({
   "src/modes/image-input.ts"() {
     "use strict";
-    import_node_fs70 = require("node:fs");
-    import_node_os14 = require("node:os");
-    import_node_path92 = require("node:path");
+    import_node_fs71 = require("node:fs");
+    import_node_os15 = require("node:os");
+    import_node_path94 = require("node:path");
     init_channels();
     init_errors();
     init_image_limits();
@@ -52940,7 +53622,7 @@ function compactEvent(event) {
       if (event.toolResults.length === 0) return event;
       return {
         ...event,
-        // 线上形状（docs/rpc.md）不是完整的 ToolResultMessage：正文与 details 都不带
+        // 线上形状（docs/reference/rpc.md）不是完整的 ToolResultMessage：正文与 details 都不带
         toolResults: event.toolResults.map(
           ({ toolCallId: toolCallId2, toolName, isError, timestamp }) => ({
             toolCallId: toolCallId2,
@@ -53128,7 +53810,7 @@ async function runPrintMode(runtime, context) {
       denied.push({
         toolCallId: event.toolCallId,
         toolName: event.toolName,
-        reason: textOf5(event)
+        reason: textOf6(event)
       });
       const command3 = bashCommands.get(event.toolCallId);
       if (event.toolName === "bash" && command3 !== void 0) deniedBash.push(command3);
@@ -53264,7 +53946,7 @@ function describeLimit(event) {
   const m = msg().print.print;
   return event.kind === "turns" ? m.limitTurns(event.limit) : m.limitCost(formatUsd(event.limit), formatUsd(event.value));
 }
-function textOf5(event) {
+function textOf6(event) {
   const content = event.result.content;
   const text = typeof content === "string" ? content : content.map((b) => b.type === "text" ? b.text : "").join("");
   return text.split("\n")[0]?.trim().slice(0, 200) ?? "";
@@ -53711,7 +54393,7 @@ function trustChoices() {
 }
 function isDirectory2(path) {
   try {
-    return (0, import_node_fs71.statSync)(path).isDirectory();
+    return (0, import_node_fs72.statSync)(path).isDirectory();
   } catch {
     return false;
   }
@@ -53765,8 +54447,8 @@ function createStartupUi(options = {}) {
         placeholder: m.cwdPlaceholder,
         validate: (text) => {
           if (text === "") return m.cwdEmpty;
-          const abs = (0, import_node_path93.resolve)(text);
-          if (!(0, import_node_fs71.existsSync)(abs)) return m.cwdMissing(abs);
+          const abs = (0, import_node_path95.resolve)(text);
+          if (!(0, import_node_fs72.existsSync)(abs)) return m.cwdMissing(abs);
           if (!isDirectory2(abs)) return m.cwdNotDir(abs);
           return void 0;
         }
@@ -53774,13 +54456,13 @@ function createStartupUi(options = {}) {
     }
   };
 }
-var import_node_fs71, import_node_path93;
+var import_node_fs72, import_node_path95;
 var init_startup_ui = __esm({
   "src/modes/interactive/startup-ui.ts"() {
     "use strict";
     init_i18n();
-    import_node_fs71 = require("node:fs");
-    import_node_path93 = require("node:path");
+    import_node_fs72 = require("node:fs");
+    import_node_path95 = require("node:path");
     init_tui2();
     init_model_items();
     init_model_items();
@@ -54197,7 +54879,7 @@ function startupInfo(runtime, home) {
     permissionMode: runtime.session.state.permissionMode,
     preset: runtime.config.tools?.preset ?? "default",
     codemode: effectiveCodemodeMode(runtime.config),
-    contextFiles: resources.contextFiles.map((f) => (0, import_node_path94.basename)(f.path)),
+    contextFiles: resources.contextFiles.map((f) => (0, import_node_path96.basename)(f.path)),
     skills: resources.skills.filter((s2) => !isBuiltinSkill(s2)).length,
     prompts: resources.prompts.length,
     hooks: runtime.hooks.list().length,
@@ -54206,12 +54888,12 @@ function startupInfo(runtime, home) {
   if (runtime.host !== void 0) info2.host = runtime.host.adapter.id;
   return info2;
 }
-var import_node_path94;
+var import_node_path96;
 var init_startup_screen = __esm({
   "src/cli/startup-screen.ts"() {
     "use strict";
     init_builtin3();
-    import_node_path94 = require("node:path");
+    import_node_path96 = require("node:path");
     init_channels();
     init_presets2();
     init_i18n();
@@ -55126,7 +55808,7 @@ var init_commands = __esm({
       },
       get_commands: async (_p, ctx) => ({ commands: commands(ctx.runtime) }),
       get_skills: async (_p, ctx) => ({ skills: ctx.runtime.resources.skills }),
-      // [W5-F] 计划 / 任务命令（docs/wave5-plan.md §6.5、§7.5）
+      // [W5-F] 计划 / 任务命令（docs/history/wave5-plan.md §6.5、§7.5）
       plan_response: async (p, ctx) => {
         const result = await plans(ctx).respond(p);
         if (result.freshPrompt !== void 0) {
@@ -55141,7 +55823,7 @@ var init_commands = __esm({
       get_todos: async (_p, ctx) => ({ items: currentTodos(impl(ctx.session()).manager.branch()) }),
       get_tasks: async (_p, ctx) => ({ tasks: [...ctx.tasks?.()?.list() ?? []] }),
       get_agents: async (_p, ctx) => ({ agents: [...ctx.agents?.() ?? []] }),
-      // [W6-T2] 轨迹（docs/wave6-plan.md §2.6；分页 / 增量 / 脱敏见 trace/query.ts）
+      // [W6-T2] 轨迹（docs/history/wave6-plan.md §2.6；分页 / 增量 / 脱敏见 trace/query.ts）
       get_trace: async (p, ctx) => sessionTrace(ctx.session(), p ?? {}),
       // [W7-B2] 前台任务转后台：工具调用立即返回、任务继续，完成后照常通知
       background_task: async (p, ctx) => {
@@ -56954,29 +57636,29 @@ function runEditor(command3, file) {
   return result.status;
 }
 async function editExternally(text, name, deps) {
-  const dir = (0, import_node_fs72.mkdtempSync)((0, import_node_path95.join)((0, import_node_os15.tmpdir)(), "ama-edit-"));
-  const file = (0, import_node_path95.join)(dir, name);
-  (0, import_node_fs72.writeFileSync)(file, text);
+  const dir = (0, import_node_fs73.mkdtempSync)((0, import_node_path97.join)((0, import_node_os16.tmpdir)(), "ama-edit-"));
+  const file = (0, import_node_path97.join)(dir, name);
+  (0, import_node_fs73.writeFileSync)(file, text);
   deps.suspend();
   try {
     const code = (deps.run ?? runEditor)(editorCommand(deps.env, deps.platform), file);
     if (code !== 0) return void 0;
-    return (0, import_node_fs72.readFileSync)(file, "utf8");
+    return (0, import_node_fs73.readFileSync)(file, "utf8");
   } catch {
     return void 0;
   } finally {
     deps.resume();
-    (0, import_node_fs72.rmSync)(dir, { recursive: true, force: true });
+    (0, import_node_fs73.rmSync)(dir, { recursive: true, force: true });
   }
 }
-var import_node_child_process17, import_node_fs72, import_node_os15, import_node_path95;
+var import_node_child_process17, import_node_fs73, import_node_os16, import_node_path97;
 var init_external_editor = __esm({
   "src/modes/interactive/external-editor.ts"() {
     "use strict";
     import_node_child_process17 = require("node:child_process");
-    import_node_fs72 = require("node:fs");
-    import_node_os15 = require("node:os");
-    import_node_path95 = require("node:path");
+    import_node_fs73 = require("node:fs");
+    import_node_os16 = require("node:os");
+    import_node_path97 = require("node:path");
   }
 });
 
@@ -60996,9 +61678,9 @@ function parseLeftRight(text) {
 async function hasUpstream(cwd, branch) {
   const gitDir = await findGitDir(cwd);
   if (gitDir === void 0) return false;
-  const common = (await (0, import_promises25.readFile)((0, import_node_path96.join)(gitDir, "commondir"), "utf8").catch(() => void 0))?.trim();
-  const dir = common === void 0 ? gitDir : (0, import_node_path96.isAbsolute)(common) ? common : (0, import_node_path96.resolve)(gitDir, common);
-  const text = await (0, import_promises25.readFile)((0, import_node_path96.join)(dir, "config"), "utf8").catch(() => "");
+  const common = (await (0, import_promises25.readFile)((0, import_node_path98.join)(gitDir, "commondir"), "utf8").catch(() => void 0))?.trim();
+  const dir = common === void 0 ? gitDir : (0, import_node_path98.isAbsolute)(common) ? common : (0, import_node_path98.resolve)(gitDir, common);
+  const text = await (0, import_promises25.readFile)((0, import_node_path98.join)(dir, "config"), "utf8").catch(() => "");
   let inBranch = false;
   for (const raw of text.split("\n")) {
     const line2 = raw.trim();
@@ -61021,17 +61703,17 @@ async function readHead2(cwd) {
   }
   const gitDir = await findGitDir(cwd);
   if (gitDir === void 0) return void 0;
-  const text = await (0, import_promises25.readFile)((0, import_node_path96.join)(gitDir, "HEAD"), "utf8").catch(() => void 0);
+  const text = await (0, import_promises25.readFile)((0, import_node_path98.join)(gitDir, "HEAD"), "utf8").catch(() => void 0);
   const match = /^ref:\s*refs\/heads\/(\S+)\s*$/.exec(text ?? "");
   return match?.[1] !== void 0 ? { branch: match[1] } : void 0;
 }
-var import_node_child_process18, import_promises25, import_node_path96, GIT_NUMSTAT_INTERVAL_MS, GIT_NUMSTAT_TIMEOUT_MS, sameInfo, GitInfoWatcher;
+var import_node_child_process18, import_promises25, import_node_path98, GIT_NUMSTAT_INTERVAL_MS, GIT_NUMSTAT_TIMEOUT_MS, sameInfo, GitInfoWatcher;
 var init_info = __esm({
   "src/git/info.ts"() {
     "use strict";
     import_node_child_process18 = require("node:child_process");
     import_promises25 = require("node:fs/promises");
-    import_node_path96 = require("node:path");
+    import_node_path98 = require("node:path");
     init_git_head();
     GIT_NUMSTAT_INTERVAL_MS = 1e4;
     GIT_NUMSTAT_TIMEOUT_MS = 2e3;
@@ -61327,12 +62009,12 @@ function statusLineText(mode) {
   const m = msg().interactive.statusLine;
   return mode === "full" ? m.full : m.compact;
 }
-var import_node_path97, WRITE_TOOLS3, QUOTA_TICK_MS, HintLine, StatusArea;
+var import_node_path99, WRITE_TOOLS3, QUOTA_TICK_MS, HintLine, StatusArea;
 var init_status_area = __esm({
   "src/modes/interactive/status-area.ts"() {
     "use strict";
     init_i18n();
-    import_node_path97 = require("node:path");
+    import_node_path99 = require("node:path");
     init_capability();
     init_channels();
     init_info();
@@ -61522,7 +62204,7 @@ var init_status_area = __esm({
       gitView() {
         const cwd = this.gitCwd;
         if (cwd === void 0) return void 0;
-        return { dir: (0, import_node_path97.basename)(cwd), info: this.git?.current() };
+        return { dir: (0, import_node_path99.basename)(cwd), info: this.git?.current() };
       }
       watchGit() {
         const cwd = this.deps.session().state.cwd;
@@ -63849,15 +64531,15 @@ function processTerminal() {
   return new ProcessTerminal();
 }
 function loadKeys(runtime, warn2) {
-  const parsed = loadKeybindingsFile((0, import_node_path98.join)(runtime.paths.configDir, KEYBINDINGS_FILE));
+  const parsed = loadKeybindingsFile((0, import_node_path100.join)(runtime.paths.configDir, KEYBINDINGS_FILE));
   for (const w of parsed.warnings) warn2(msg().interactive.app.keybindingsWarning(w));
   return new Keybindings(parsed.overrides);
 }
-var import_node_path98;
+var import_node_path100;
 var init_terminal_setup = __esm({
   "src/modes/interactive/terminal-setup.ts"() {
     "use strict";
-    import_node_path98 = require("node:path");
+    import_node_path100 = require("node:path");
     init_paths();
     init_errors();
     init_i18n();
@@ -63923,7 +64605,7 @@ function runInteractiveMode(runtime, context, options = {}) {
     ...options.statusLine !== void 0 ? { layout: options.statusLine } : {}
   });
   const { hint, bar: status } = area;
-  const historyFile = options.historyFile === false ? void 0 : options.historyFile ?? (0, import_node_path99.join)(runtime.paths.dataDir, "history");
+  const historyFile = options.historyFile === false ? void 0 : options.historyFile ?? (0, import_node_path101.join)(runtime.paths.dataDir, "history");
   const completion = new InteractiveCompletion({
     commands: () => ALL_COMMANDS,
     prompts: () => runtime.resources.prompts,
@@ -64287,12 +64969,12 @@ function runInteractiveMode(runtime, context, options = {}) {
     }
   });
 }
-var import_node_path99, HINT_MS;
+var import_node_path101, HINT_MS;
 var init_interactive_mode = __esm({
   "src/modes/interactive/interactive-mode.ts"() {
     "use strict";
     init_image_input();
-    import_node_path99 = require("node:path");
+    import_node_path101 = require("node:path");
     init_session2();
     init_compose_session();
     init_startup_screen();
@@ -64368,7 +65050,7 @@ function choose(answer, values) {
 }
 function isDirectory3(path) {
   try {
-    return (0, import_node_fs73.statSync)(path).isDirectory();
+    return (0, import_node_fs74.statSync)(path).isDirectory();
   } catch {
     return false;
   }
@@ -64412,8 +65094,8 @@ function createTextStartupUi(io) {
       const m = msg().report.startup;
       const answer = (await ask([m.cwdMissing(missing)], m.cwdAnswer))?.trim();
       if (answer === void 0 || answer === "") return void 0;
-      const abs = (0, import_node_path100.resolve)(answer);
-      if (!(0, import_node_fs73.existsSync)(abs) || !isDirectory3(abs)) {
+      const abs = (0, import_node_path102.resolve)(answer);
+      if (!(0, import_node_fs74.existsSync)(abs) || !isDirectory3(abs)) {
         io.write(m.notDirectory(abs));
         return void 0;
       }
@@ -64421,12 +65103,12 @@ function createTextStartupUi(io) {
     }
   };
 }
-var import_node_fs73, import_node_path100;
+var import_node_fs74, import_node_path102;
 var init_startup_ui_text = __esm({
   "src/modes/startup-ui-text.ts"() {
     "use strict";
-    import_node_fs73 = require("node:fs");
-    import_node_path100 = require("node:path");
+    import_node_fs74 = require("node:fs");
+    import_node_path102 = require("node:path");
     init_i18n();
   }
 });
@@ -64451,7 +65133,7 @@ function createTools(input2, options, state) {
   const osStatus = configureOsSandbox(input2.config.sandbox?.enabled);
   const bashSandbox = options.bashSandbox ?? resolveBashSandbox(input2.config.sandbox, {
     status: osStatus,
-    ...input2.paths === void 0 ? {} : { hidden: [(0, import_node_path101.join)(input2.paths.configDir, AUTH_FILE)] }
+    ...input2.paths === void 0 ? {} : { hidden: [(0, import_node_path103.join)(input2.paths.configDir, AUTH_FILE)] }
   });
   state.bashSandbox = bashSandbox;
   const capability = options.sandboxCapability ?? sandboxCapabilityFor(input2.config);
@@ -64641,7 +65323,7 @@ function createRuntimeDeps(options = {}) {
   if (ui !== void 0) deps.ui = ui;
   return deps;
 }
-var import_node_path101, DEFAULT_TOOL_FACTORIES, DEFAULT_MODES;
+var import_node_path103, DEFAULT_TOOL_FACTORIES, DEFAULT_MODES;
 var init_compose2 = __esm({
   "src/cli/compose.ts"() {
     "use strict";
@@ -64656,7 +65338,7 @@ var init_compose2 = __esm({
     init_tool();
     init_detect();
     init_bash();
-    import_node_path101 = require("node:path");
+    import_node_path103 = require("node:path");
     init_paths();
     init_presets2();
     init_registry();
@@ -64871,8 +65553,8 @@ var init_memory3 = __esm({
 });
 
 // src/cli/main.ts
-var import_node_fs74 = require("node:fs");
-var import_node_path102 = require("node:path");
+var import_node_fs75 = require("node:fs");
+var import_node_path104 = require("node:path");
 var import_node_url3 = require("node:url");
 init_version();
 init_args();
@@ -64880,7 +65562,7 @@ init_bootstrap();
 init_exit_codes();
 
 // src/cli/subcommands/auth.ts
-var import_node_path70 = require("node:path");
+var import_node_path72 = require("node:path");
 init_builtin();
 
 // src/auth/chatgpt/cli.ts
@@ -65160,15 +65842,15 @@ async function startCallbackServer(options) {
 }
 
 // src/auth/oauth/pkce.ts
-var import_node_crypto16 = require("node:crypto");
+var import_node_crypto17 = require("node:crypto");
 function base64url(input2) {
   return Buffer.from(input2).toString("base64url");
 }
 function randomToken(bytes = 32) {
-  return base64url((0, import_node_crypto16.randomBytes)(bytes));
+  return base64url((0, import_node_crypto17.randomBytes)(bytes));
 }
 function s256(verifier) {
-  return base64url((0, import_node_crypto16.createHash)("sha256").update(verifier, "ascii").digest());
+  return base64url((0, import_node_crypto17.createHash)("sha256").update(verifier, "ascii").digest());
 }
 function generatePkce() {
   const verifier = randomToken(32);
@@ -65284,7 +65966,7 @@ async function loginDevice(preset, deps) {
 }
 
 // src/auth/oauth/jwt.ts
-var import_node_crypto17 = require("node:crypto");
+var import_node_crypto18 = require("node:crypto");
 init_errors();
 function invalid2(reason) {
   return new AmaError("oauth_invalid_token", `invalid id_token: ${reason}`, { detail: { reason } });
@@ -65335,11 +66017,11 @@ function verifyJwtSignature(decoded, keys) {
   if (candidates2.length === 0) throw invalid2("no matching key");
   for (const jwk of candidates2) {
     try {
-      const key = (0, import_node_crypto17.createPublicKey)({ key: jwk, format: "jwk" });
-      const ok = (0, import_node_crypto17.verify)(
+      const key = (0, import_node_crypto18.createPublicKey)({ key: jwk, format: "jwk" });
+      const ok = (0, import_node_crypto18.verify)(
         spec2.hash,
         Buffer.from(decoded.signingInput),
-        spec2.pss ? { key, padding: import_node_crypto17.constants.RSA_PKCS1_PSS_PADDING, saltLength: 32 } : spec2.ec ? { key, dsaEncoding: "ieee-p1363" } : key,
+        spec2.pss ? { key, padding: import_node_crypto18.constants.RSA_PKCS1_PSS_PADDING, saltLength: 32 } : spec2.ec ? { key, dsaEncoding: "ieee-p1363" } : key,
         decoded.signature
       );
       if (ok) return;
@@ -65407,24 +66089,24 @@ async function validateIdToken(fetchFn, idToken, expect) {
 init_token_client();
 
 // src/auth/chatgpt/host-id.ts
-var import_node_crypto18 = require("node:crypto");
-var import_node_fs47 = require("node:fs");
-var import_node_path68 = require("node:path");
+var import_node_crypto19 = require("node:crypto");
+var import_node_fs48 = require("node:fs");
+var import_node_path70 = require("node:path");
 var HOST_ID_FILE = "chatgpt-host.json";
 function hostIdPath(dataDir) {
-  return (0, import_node_path68.join)(dataDir, HOST_ID_FILE);
+  return (0, import_node_path70.join)(dataDir, HOST_ID_FILE);
 }
 function readOrCreateHostId(dataDir) {
   const path = hostIdPath(dataDir);
   try {
-    const value = JSON.parse((0, import_node_fs47.readFileSync)(path, "utf8"));
+    const value = JSON.parse((0, import_node_fs48.readFileSync)(path, "utf8"));
     if (typeof value.hostId === "string" && /^urn:uuid:[0-9a-f-]{36}$/i.test(value.hostId))
       return value.hostId;
   } catch {
   }
-  const hostId = `urn:uuid:${(0, import_node_crypto18.randomUUID)()}`;
-  (0, import_node_fs47.mkdirSync)((0, import_node_path68.dirname)(path), { recursive: true, mode: 448 });
-  (0, import_node_fs47.writeFileSync)(path, `${JSON.stringify({ version: 1, hostId }, null, 2)}
+  const hostId = `urn:uuid:${(0, import_node_crypto19.randomUUID)()}`;
+  (0, import_node_fs48.mkdirSync)((0, import_node_path70.dirname)(path), { recursive: true, mode: 448 });
+  (0, import_node_fs48.writeFileSync)(path, `${JSON.stringify({ version: 1, hostId }, null, 2)}
 `, { mode: 384 });
   return hostId;
 }
@@ -65861,7 +66543,7 @@ async function runAuth(argv, io, deps = {}) {
     return flags2.has("help") ? ExitCode.Ok : ExitCode.Usage;
   }
   const explicit = values.get("auth-file");
-  const path = explicit !== void 0 ? (0, import_node_path70.resolve)(io.cwd, explicit) : defaultAuthFilePath(resolveConfigDir({ env: io.env }));
+  const path = explicit !== void 0 ? (0, import_node_path72.resolve)(io.cwd, explicit) : defaultAuthFilePath(resolveConfigDir({ env: io.env }));
   const loginOnly = ["flavor", "port"].filter((name) => values.has(name));
   const loginFlags = ["paste", "device", "no-browser", "yes"].filter((name) => flags2.has(name));
   if (action !== "login" && [...loginOnly, ...loginFlags].length > 0)
@@ -65937,8 +66619,8 @@ init_merge();
 init_key_docs();
 init_paths();
 var import_node_child_process14 = require("node:child_process");
-var import_node_fs56 = require("node:fs");
-var import_node_path77 = require("node:path");
+var import_node_fs57 = require("node:fs");
+var import_node_path79 = require("node:path");
 init_models_dev_cache();
 init_init();
 init_json_schema();
@@ -65953,7 +66635,7 @@ init_default_model();
 init_exit_codes();
 
 // src/cli/subcommands/context.ts
-var import_node_path74 = require("node:path");
+var import_node_path76 = require("node:path");
 init_auth_file();
 init_load();
 init_merge();
@@ -65974,7 +66656,7 @@ function loadUserLevel(io, options = {}) {
     profile: profile?.config,
     hasProfile: profile !== void 0
   });
-  const authFile = options.authFile !== void 0 ? (0, import_node_path74.resolve)(io.cwd, options.authFile) : profile?.authFile ?? defaultAuthFilePath(configDir);
+  const authFile = options.authFile !== void 0 ? (0, import_node_path76.resolve)(io.cwd, options.authFile) : profile?.authFile ?? defaultAuthFilePath(configDir);
   const result = { configDir, dataDir, merged, userConfigPath, authFile, warnings };
   if (profile !== void 0) result.profile = profile;
   return result;
@@ -65999,8 +66681,8 @@ init_ansi();
 // src/cli/subcommands/config-set.ts
 init_i18n();
 init_edit2();
-var import_node_fs55 = require("node:fs");
-var import_node_path76 = require("node:path");
+var import_node_fs56 = require("node:fs");
+var import_node_path78 = require("node:path");
 init_init();
 init_paths();
 init_profile();
@@ -66129,7 +66811,7 @@ async function runConfigEdit(action, argv, io, deps = {}) {
   if (key === "permission.mode" && value === "full-auto" && scope === "user") {
     if (!await confirmBypass(io, flags2.has("yes"), deps)) return ExitCode.Config;
   }
-  if (scope === "user" && !(0, import_node_fs55.existsSync)((0, import_node_path76.join)(input2.configDir, CONFIG_FILE)))
+  if (scope === "user" && !(0, import_node_fs56.existsSync)((0, import_node_path78.join)(input2.configDir, CONFIG_FILE)))
     initConfigDir(input2.configDir);
   report(io, setConfigValue({ ...input2, scope, key, value }), value);
   return ExitCode.Ok;
@@ -66142,17 +66824,17 @@ function showPaths(io) {
   const configDir = resolveConfigDir({ env: io.env });
   const dataDir = resolveDataDir({ env: io.env });
   const m = msg().subcommands.configShow;
-  const mark = (path) => `${path}${(0, import_node_fs56.existsSync)(path) ? "" : m.missing}`;
+  const mark = (path) => `${path}${(0, import_node_fs57.existsSync)(path) ? "" : m.missing}`;
   const width2 = Math.max(...[m.configDir, m.dataDir, m.projectLevel].map(visibleWidth)) + 2;
   const label2 = (text) => padToWidth(text, width2);
   const lines2 = [
     `${label2(m.configDir)}${mark(configDir)}`,
-    `  config.json         ${mark((0, import_node_path77.join)(configDir, CONFIG_FILE))}`,
-    `  config.schema.json  ${mark((0, import_node_path77.join)(configDir, CONFIG_SCHEMA_FILE))}`,
-    `  auth.json           ${mark((0, import_node_path77.join)(configDir, AUTH_FILE))}`,
-    `  hooks.json          ${mark((0, import_node_path77.join)(configDir, HOOKS_FILE))}`,
+    `  config.json         ${mark((0, import_node_path79.join)(configDir, CONFIG_FILE))}`,
+    `  config.schema.json  ${mark((0, import_node_path79.join)(configDir, CONFIG_SCHEMA_FILE))}`,
+    `  auth.json           ${mark((0, import_node_path79.join)(configDir, AUTH_FILE))}`,
+    `  hooks.json          ${mark((0, import_node_path79.join)(configDir, HOOKS_FILE))}`,
     `${label2(m.dataDir)}${mark(dataDir)}`,
-    `  sessions/           ${mark((0, import_node_path77.join)(dataDir, "sessions"))}`,
+    `  sessions/           ${mark((0, import_node_path79.join)(dataDir, "sessions"))}`,
     `  models-dev.json     ${mark(modelsDevCachePath(dataDir))}`,
     `${label2(m.projectLevel)}${mark(projectFile(io.cwd, CONFIG_FILE))}`
   ];
@@ -66162,8 +66844,8 @@ function showPaths(io) {
 }
 function editConfig(io) {
   const configDir = resolveConfigDir({ env: io.env });
-  const path = (0, import_node_path77.join)(configDir, CONFIG_FILE);
-  if (!(0, import_node_fs56.existsSync)(path)) initConfigDir(configDir);
+  const path = (0, import_node_path79.join)(configDir, CONFIG_FILE);
+  if (!(0, import_node_fs57.existsSync)(path)) initConfigDir(configDir);
   const editor = (io.env["VISUAL"] ?? io.env["EDITOR"] ?? "").trim();
   if (editor === "") {
     io.stdout(msg().subcommands.configShow.noEditor(path));
@@ -66455,7 +67137,7 @@ async function runConfig(argv, io, deps) {
 }
 
 // src/cli/subcommands/doctor.ts
-var import_node_fs57 = require("node:fs");
+var import_node_fs58 = require("node:fs");
 init_blobs();
 init_shadow_git();
 init_gc();
@@ -66828,7 +67510,7 @@ async function runDoctor(argv, io, deps) {
   const m = msg().report.doctor;
   report2.section(m.dirsTitle);
   report2.item(m.configDir(level.configDir));
-  report2.item(m.dataDir(level.dataDir, (0, import_node_fs57.existsSync)(level.dataDir)));
+  report2.item(m.dataDir(level.dataDir, (0, import_node_fs58.existsSync)(level.dataDir)));
   await fileHistoryLine(report2, level.dataDir);
   report2.section(m.layersTitle);
   report2.item(m.builtinDefaults);
@@ -67056,7 +67738,7 @@ init_discovered_cache();
 init_catalog2();
 init_models_dev_cache();
 init_models_dev();
-var import_node_fs58 = require("node:fs");
+var import_node_fs59 = require("node:fs");
 init_load();
 init_write2();
 init_args();
@@ -67419,7 +68101,7 @@ function writeEntries(ctx, provider, entries, notes) {
     return 0;
   }
   models.push(...added);
-  const backup = (0, import_node_fs58.existsSync)(path);
+  const backup = (0, import_node_fs59.existsSync)(path);
   writeConfigFile(path, config, { backup: true });
   io.stdout(m.written(path, provider.id, added.length, kept, backup));
   if (notes.noTools.size > 0) io.stdout(m.skippedNoTools([...notes.noTools].join(", ")));
@@ -67844,7 +68526,7 @@ async function runModels(argv, io, deps) {
 }
 
 // src/cli/subcommands/providers.ts
-var import_node_fs59 = require("node:fs");
+var import_node_fs60 = require("node:fs");
 init_models_dev_cache();
 init_models_dev();
 init_auth_file();
@@ -68501,7 +69183,7 @@ ${renderTable2(result.plans)}`);
   const providers = config.providers ??= {};
   providers[id] = merged.config;
   if (defaultPick !== void 0) config.defaultModel = `${id}/${defaultPick.id}`;
-  const backup = (0, import_node_fs59.existsSync)(level.userConfigPath);
+  const backup = (0, import_node_fs60.existsSync)(level.userConfigPath);
   writeConfigFile(level.userConfigPath, config, { backup: true });
   if (key.store !== void 0) setAuthKey(level.authFile, id, key.store);
   io.stdout(m.written(level.userConfigPath, backup));
@@ -68617,7 +69299,7 @@ init_init();
 init_paths();
 
 // src/cli/subcommands/sessions.ts
-var import_node_path85 = require("node:path");
+var import_node_path87 = require("node:path");
 init_gc();
 init_paths();
 init_args();
@@ -68626,8 +69308,8 @@ init_reuse();
 init_clipboard_image();
 
 // src/cli/subcommands/sessions-export.ts
-var import_node_fs61 = require("node:fs");
-var import_node_path79 = require("node:path");
+var import_node_fs62 = require("node:fs");
+var import_node_path81 = require("node:path");
 init_paths();
 
 // src/session/export.ts
@@ -68849,7 +69531,7 @@ async function runSessionsExport(argv, io) {
     throw new UsageError(msg().subcommands.common.invalidChoice("--branch", BRANCHES, branch));
   }
   const dirFlag = values.get("session-dir");
-  const root = dirFlag !== void 0 ? (0, import_node_path79.resolve)(io.cwd, expandHome(dirFlag, { env: io.env })) : (0, import_node_path79.join)(resolveDataDir({ env: io.env }), "sessions");
+  const root = dirFlag !== void 0 ? (0, import_node_path81.resolve)(io.cwd, expandHome(dirFlag, { env: io.env })) : (0, import_node_path81.join)(resolveDataDir({ env: io.env }), "sessions");
   const session = readSessionReadOnly(findSessionFileReadOnly(root, id, io.cwd));
   const text = renderExport(session, format, branch);
   const output = values.get("output");
@@ -68857,14 +69539,14 @@ async function runSessionsExport(argv, io) {
     io.stdout(text);
     return ExitCode.Ok;
   }
-  const target = (0, import_node_path79.resolve)(io.cwd, expandHome(output, { env: io.env }));
-  (0, import_node_fs61.writeFileSync)(target, text, { mode: 384 });
+  const target = (0, import_node_path81.resolve)(io.cwd, expandHome(output, { env: io.env }));
+  (0, import_node_fs62.writeFileSync)(target, text, { mode: 384 });
   io.stderr(msg().subcommands.sessionsExport.exported(target));
   return ExitCode.Ok;
 }
 
 // src/cli/subcommands/sessions-search.ts
-var import_node_path82 = require("node:path");
+var import_node_path84 = require("node:path");
 init_paths();
 init_scan();
 
@@ -69042,7 +69724,7 @@ init_args();
 init_exit_codes();
 
 // src/cli/subcommands/stats.ts
-var import_node_path81 = require("node:path");
+var import_node_path83 = require("node:path");
 init_paths();
 init_scan();
 
@@ -69190,8 +69872,8 @@ function aggregateStats(summaries, options = {}) {
 }
 
 // src/session/stats-index.ts
-var import_node_fs62 = require("node:fs");
-var import_node_path80 = require("node:path");
+var import_node_fs63 = require("node:fs");
+var import_node_path82 = require("node:path");
 
 // src/session/stats-scan.ts
 init_scan();
@@ -69404,7 +70086,7 @@ function collectSummaries(files, options = {}) {
   let index2 = { version: INDEX_VERSION, zone, files: {} };
   if (options.indexFile !== void 0) {
     try {
-      const loaded = JSON.parse((0, import_node_fs62.readFileSync)(options.indexFile, "utf8"));
+      const loaded = JSON.parse((0, import_node_fs63.readFileSync)(options.indexFile, "utf8"));
       if (loaded.version === INDEX_VERSION && loaded.zone === zone && typeof loaded.files === "object")
         index2 = loaded;
     } catch {
@@ -69415,7 +70097,7 @@ function collectSummaries(files, options = {}) {
   for (const file of files) {
     let stat16;
     try {
-      stat16 = (0, import_node_fs62.statSync)(file);
+      stat16 = (0, import_node_fs63.statSync)(file);
     } catch {
       result.invalid++;
       continue;
@@ -69445,10 +70127,10 @@ function collectSummaries(files, options = {}) {
   }
   if (dirty && options.indexFile !== void 0) {
     try {
-      (0, import_node_fs62.mkdirSync)((0, import_node_path80.dirname)(options.indexFile), { recursive: true, mode: 448 });
+      (0, import_node_fs63.mkdirSync)((0, import_node_path82.dirname)(options.indexFile), { recursive: true, mode: 448 });
       const tmp = `${options.indexFile}.${process.pid}.tmp`;
-      (0, import_node_fs62.writeFileSync)(tmp, JSON.stringify(index2), { mode: 384 });
-      (0, import_node_fs62.renameSync)(tmp, options.indexFile);
+      (0, import_node_fs63.writeFileSync)(tmp, JSON.stringify(index2), { mode: 384 });
+      (0, import_node_fs63.renameSync)(tmp, options.indexFile);
     } catch {
     }
   }
@@ -69609,13 +70291,13 @@ async function runStats(argv, io) {
   }
   const dataDir = resolveDataDir({ env: io.env });
   const dirFlag = values.get("session-dir");
-  const root = dirFlag !== void 0 ? (0, import_node_path81.resolve)(io.cwd, expandHome(dirFlag, { env: io.env })) : (0, import_node_path81.join)(dataDir, "sessions");
+  const root = dirFlag !== void 0 ? (0, import_node_path83.resolve)(io.cwd, expandHome(dirFlag, { env: io.env })) : (0, import_node_path83.join)(dataDir, "sessions");
   const projectFlag = values.get("project");
-  const project = projectFlag !== void 0 ? (0, import_node_path81.resolve)(io.cwd, expandHome(projectFlag, { env: io.env })) : flags2.has("all") || by === "project" ? void 0 : io.cwd;
+  const project = projectFlag !== void 0 ? (0, import_node_path83.resolve)(io.cwd, expandHome(projectFlag, { env: io.env })) : flags2.has("all") || by === "project" ? void 0 : io.cwd;
   const files = sessionFilesInScope(root, project);
   const useCache = !flags2.has("no-cache");
   const collected = collectSummaries(files, {
-    ...useCache ? { indexFile: (0, import_node_path81.join)(dataDir, STATS_INDEX_FILE) } : {},
+    ...useCache ? { indexFile: (0, import_node_path83.join)(dataDir, STATS_INDEX_FILE) } : {},
     prune: project === void 0
   });
   const report2 = aggregateStats(collected.summaries, {
@@ -69710,7 +70392,7 @@ async function runSessionsSearch(argv, io) {
   const sinceRaw = values.get("since");
   const sinceIso = sinceRaw === void 0 ? void 0 : (/* @__PURE__ */ new Date(`${parseDaySpec("since", sinceRaw)}T00:00:00`)).toISOString();
   const dirFlag = values.get("session-dir");
-  const root = dirFlag !== void 0 ? (0, import_node_path82.resolve)(io.cwd, expandHome(dirFlag, { env: io.env })) : (0, import_node_path82.join)(resolveDataDir({ env: io.env }), "sessions");
+  const root = dirFlag !== void 0 ? (0, import_node_path84.resolve)(io.cwd, expandHome(dirFlag, { env: io.env })) : (0, import_node_path84.join)(resolveDataDir({ env: io.env }), "sessions");
   const files = sessionFilesInScope(root, flags2.has("all") ? void 0 : io.cwd);
   const { hits, truncated } = searchSessions(files, query, {
     limit,
@@ -69734,9 +70416,9 @@ async function runSessionsSearch(argv, io) {
 
 // src/cli/subcommands/sessions-trace.ts
 var import_node_child_process15 = require("node:child_process");
-var import_node_fs64 = require("node:fs");
-var import_node_os12 = require("node:os");
-var import_node_path84 = require("node:path");
+var import_node_fs65 = require("node:fs");
+var import_node_os13 = require("node:os");
+var import_node_path86 = require("node:path");
 init_paths();
 init_i18n();
 init_scan();
@@ -70172,9 +70854,9 @@ function splitHtmlFlag(argv) {
   return { rest, html, ...file !== void 0 ? { file } : {} };
 }
 function locate(io, target, dirFlag) {
-  const asPath = (0, import_node_path84.resolve)(io.cwd, expandHome(target, { env: io.env }));
-  if (/[\\/]|\.jsonl$/.test(target) && (0, import_node_fs64.existsSync)(asPath)) return asPath;
-  const root = dirFlag !== void 0 ? (0, import_node_path84.resolve)(io.cwd, expandHome(dirFlag, { env: io.env })) : (0, import_node_path84.join)(resolveDataDir({ env: io.env }), "sessions");
+  const asPath = (0, import_node_path86.resolve)(io.cwd, expandHome(target, { env: io.env }));
+  if (/[\\/]|\.jsonl$/.test(target) && (0, import_node_fs65.existsSync)(asPath)) return asPath;
+  const root = dirFlag !== void 0 ? (0, import_node_path86.resolve)(io.cwd, expandHome(dirFlag, { env: io.env })) : (0, import_node_path86.join)(resolveDataDir({ env: io.env }), "sessions");
   return findSessionFileReadOnly(root, target, io.cwd);
 }
 async function runSessionsTrace(argv, io, deps = {}) {
@@ -70239,14 +70921,14 @@ async function runSessionsTrace(argv, io, deps = {}) {
   }
   const outFlag = split.file ?? values.get("output");
   const open3 = flags2.has("open");
-  let outPath = outFlag === void 0 ? void 0 : (0, import_node_path84.resolve)(io.cwd, expandHome(outFlag, { env: io.env }));
+  let outPath = outFlag === void 0 ? void 0 : (0, import_node_path86.resolve)(io.cwd, expandHome(outFlag, { env: io.env }));
   if (outPath === void 0 && open3)
-    outPath = (0, import_node_path84.join)((0, import_node_os12.tmpdir)(), `ama-trace-${read2.header.id}.${wantsJson ? "json" : "html"}`);
+    outPath = (0, import_node_path86.join)((0, import_node_os13.tmpdir)(), `ama-trace-${read2.header.id}.${wantsJson ? "json" : "html"}`);
   if (outPath === void 0) {
     io.stdout(text);
     return ExitCode.Ok;
   }
-  (0, import_node_fs64.writeFileSync)(outPath, text, { mode: 384 });
+  (0, import_node_fs65.writeFileSync)(outPath, text, { mode: 384 });
   io.stderr(m.wrote(outPath));
   if (open3) {
     try {
@@ -70287,7 +70969,7 @@ async function runSessions(argv, io, deps) {
     return flags2.has("help") ? ExitCode.Ok : ExitCode.Usage;
   }
   const dirFlag = values.get("session-dir");
-  const sessionDir = dirFlag !== void 0 ? (0, import_node_path85.resolve)(io.cwd, expandHome(dirFlag, { env: io.env })) : (0, import_node_path85.resolve)(resolveDataDir({ env: io.env }), "sessions");
+  const sessionDir = dirFlag !== void 0 ? (0, import_node_path87.resolve)(io.cwd, expandHome(dirFlag, { env: io.env })) : (0, import_node_path87.resolve)(resolveDataDir({ env: io.env }), "sessions");
   const sessions = deps?.sessions;
   const scope = flags2.has("all") ? {} : { cwd: io.cwd };
   switch (action) {
@@ -70373,7 +71055,7 @@ async function pruneFileHistory(io, sessionDir, dryRun) {
   try {
     const result = await gcBlobs({
       dataDir,
-      sessionRoots: [sessionDir, (0, import_node_path85.join)(dataDir, "sessions")],
+      sessionRoots: [sessionDir, (0, import_node_path87.join)(dataDir, "sessions")],
       dryRun
     });
     if (result.removed.length === 0) return;
@@ -70447,7 +71129,7 @@ function readStdinDefault() {
 }
 function stdinKindDefault() {
   try {
-    const stat16 = (0, import_node_fs74.fstatSync)(0);
+    const stat16 = (0, import_node_fs75.fstatSync)(0);
     if (stat16.isFile()) return "file";
     if (stat16.isFIFO()) return "fifo";
     if (stat16.isSocket()) return "socket";
@@ -70507,7 +71189,7 @@ function defaultIo() {
 }
 function peekUserLanguage(env) {
   try {
-    const raw = (0, import_node_fs74.readFileSync)((0, import_node_path102.join)(resolveConfigDir({ env }), "config.json"), "utf8");
+    const raw = (0, import_node_fs75.readFileSync)((0, import_node_path104.join)(resolveConfigDir({ env }), "config.json"), "utf8");
     const value = JSON.parse(raw).ui?.language;
     return value === "auto" || value === "zh" || value === "en" ? value : void 0;
   } catch {
@@ -70595,7 +71277,7 @@ function isDirectRun() {
   const entry = process.argv[1];
   if (entry === void 0) return false;
   try {
-    return (0, import_node_fs74.realpathSync)(entry) === (0, import_node_fs74.realpathSync)((0, import_node_url3.fileURLToPath)(__ama_import_meta_url));
+    return (0, import_node_fs75.realpathSync)(entry) === (0, import_node_fs75.realpathSync)((0, import_node_url3.fileURLToPath)(__ama_import_meta_url));
   } catch {
     return false;
   }