@armadra/agent 0.5.1 → 0.6.1

package/dist/permissions/bypass.js

@@ -7,21 +7,30 @@
  * - 离开 Bypass、切到其它模式都不问。
  * - 只管「要不要问」与记住确认；怎么问（对话框 / 行式 y/N）由各界面提供 `ask`。
  */
+import { msg } from "../i18n/index.js";
 export const BYPASS_MODE = "full-auto";
-export const BYPASS_CONFIRM_TITLE = "进入 Bypass permissions？";
+/** 确认框标题（随界面语言）。 */
+export function bypassConfirmTitle() {
+    return msg().permissions.bypass.title;
+}
 /** 确认框正文：Bypass 意味着什么（一两条关键风险）。 */
-export const BYPASS_RISK_LINES = [
-    "所有工具调用都不再询问：写文件、执行命令、联网直接放行",
-    "只有危险命令仍会询问，deny 规则照常生效；只建议在一次性沙箱、容器里用",
-];
+export function bypassRiskLines() {
+    const m = msg().permissions.bypass;
+    return [m.riskAllowAll, m.riskDangerous];
+}
 /** 选项：缺省选中「取消」。 */
-export const BYPASS_CHOICES = [
-    { label: "进入 Bypass", keys: "y" },
-    { label: "取消", keys: "n Esc" },
-];
+export function bypassChoices() {
+    const m = msg().permissions.bypass;
+    return [
+        { label: m.choiceEnter, keys: "y" },
+        { label: m.choiceCancel, keys: "n Esc" },
+    ];
+}
 export const BYPASS_DEFAULT_CHOICE = 1;
 /** 行式界面的问句（单键 y/N，缺省 N）。 */
-export const BYPASS_LINE_QUESTION = "确认进入 Bypass？[y/N] ";
+export function bypassLineQuestion() {
+    return msg().permissions.bypass.lineQuestion;
+}
 /**
  * 返回「切到 `mode` 前要不要放行」的闸门：不是 Bypass 直接放行；Bypass 首次调用 `ask`，
  * 确认后本闸门内不再问。`confirmed` 为 true 表示启动时已在 Bypass（视为已确认）。

package/dist/permissions/memory-class.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 权限类 `memory`（docs/wave6-plan.md §3.3、D10）。[W6-C0] 管线判定；`memory` 工具本身由 W6-M 实现。
+ *
+ * 管线按命令把它折成已有的类再走通常的真值表：
+ * - `view` → `read`：所有模式放行；
+ * - 写命令（`create` / `str_replace` / `delete`，以及无法识别的命令）→ `execute`：default / auto-edit 询问
+ *   （审批可选「本会话允许」）、plan 拒绝、full-auto 放行、allowlist 只放行 allow 规则命中的
+ *   （`memory` 不带括号即全部放行）、auto 交给分类器。
+ * 写入前的脱敏拒写、子会话写命令拒绝在工具执行层（W6-M），不在这里。
+ */
+import type { ToolPermission } from "../tools/types.js";
+export declare const MEMORY_COMMANDS: readonly ["view", "create", "str_replace", "delete"];
+export type MemoryCommand = (typeof MEMORY_COMMANDS)[number];
+/** 调用的 `command`（不是字符串返回 undefined）。 */
+export declare function memoryCommand(input: unknown): string | undefined;
+/** `memory` 类在真值表里按哪一类判定。 */
+export declare function memoryEffectivePermission(input: unknown): Exclude<ToolPermission, "memory">;
+/**
+ * [W6-M] `memory(pattern)` 规则：pattern 是命令名（`view` / `create` / `str_replace` / `delete`）时比对命令；
+ * 否则按 glob 比对逻辑路径（`/memories/user/**`，`*` 不跨 `/`，`**` 跨）；单独的 `*` / `**` 命中全部。
+ * 记忆路径是逻辑路径，不按文件系统解析（`rules.ts` 对 memory 不走 bash 命令与真实路径的匹配）。
+ */
+export declare function memoryRuleMatches(pattern: string, input: unknown): boolean;

package/dist/permissions/memory-class.js

@@ -0,0 +1,54 @@
+/**
+ * 权限类 `memory`（docs/wave6-plan.md §3.3、D10）。[W6-C0] 管线判定；`memory` 工具本身由 W6-M 实现。
+ *
+ * 管线按命令把它折成已有的类再走通常的真值表：
+ * - `view` → `read`：所有模式放行；
+ * - 写命令（`create` / `str_replace` / `delete`，以及无法识别的命令）→ `execute`：default / auto-edit 询问
+ *   （审批可选「本会话允许」）、plan 拒绝、full-auto 放行、allowlist 只放行 allow 规则命中的
+ *   （`memory` 不带括号即全部放行）、auto 交给分类器。
+ * 写入前的脱敏拒写、子会话写命令拒绝在工具执行层（W6-M），不在这里。
+ */
+export const MEMORY_COMMANDS = ["view", "create", "str_replace", "delete"];
+/** 调用的 `command`（不是字符串返回 undefined）。 */
+export function memoryCommand(input) {
+    const raw = typeof input === "object" && input !== null
+        ? input["command"]
+        : undefined;
+    return typeof raw === "string" ? raw : undefined;
+}
+/** `memory` 类在真值表里按哪一类判定。 */
+export function memoryEffectivePermission(input) {
+    return memoryCommand(input) === "view" ? "read" : "execute";
+}
+/**
+ * [W6-M] `memory(pattern)` 规则：pattern 是命令名（`view` / `create` / `str_replace` / `delete`）时比对命令；
+ * 否则按 glob 比对逻辑路径（`/memories/user/**`，`*` 不跨 `/`，`**` 跨）；单独的 `*` / `**` 命中全部。
+ * 记忆路径是逻辑路径，不按文件系统解析（`rules.ts` 对 memory 不走 bash 命令与真实路径的匹配）。
+ */
+export function memoryRuleMatches(pattern, input) {
+    const p = pattern.trim();
+    if (p === "*" || p === "**")
+        return true;
+    if (MEMORY_COMMANDS.includes(p))
+        return memoryCommand(input) === p;
+    const raw = typeof input === "object" && input !== null
+        ? input["path"]
+        : undefined;
+    if (typeof raw !== "string")
+        return false;
+    let body = "";
+    for (let i = 0; i < p.length; i++) {
+        const ch = p[i];
+        if (ch === "*" && p[i + 1] === "*") {
+            body += ".*";
+            i++;
+        }
+        else if (ch === "*")
+            body += "[^/]*";
+        else if (ch === "?")
+            body += "[^/]";
+        else
+            body += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+    return new RegExp(`^${body}$`).test(raw.replace(/\/+$/, ""));
+}

package/dist/permissions/modes.d.ts

@@ -1,7 +1,7 @@
 /**
  * 六种权限模式的显示名、一行说明、界面顺序与 Shift+Tab 循环（§7.4）。
  *
- * 显示名用英文（与常见编码 Agent 的叫法一致），说明用界面语言（中文）。界面顺序就是选择器里
+ * 显示名用英文（与常见编码 Agent 的叫法一致），说明随界面语言（`msg().permissions`）。界面顺序就是选择器里
  * 数字快捷键 1–6 的顺序；`allowlist` 不在 Shift+Tab 循环里，只能显式选。
  */
 import { type PermissionMode } from "./types.js";
@@ -22,8 +22,8 @@ export declare function isPermissionMode(value: unknown): value is PermissionMod
 export declare function nextCycleMode(mode: PermissionMode): PermissionMode;
 /** line 模式 `/permission` 与 `/permissions` 用的纯文本列表（与选择器同一顺序与标注）。 */
 export declare function permissionModeLines(current: PermissionMode, configDefault: PermissionMode): string[];
-/** 审批对话框与提示里 auto 判定层的中文名。 */
-export declare const AUTO_LAYER_TEXT: Readonly<Record<"rule" | "static" | "classifier", string>>;
+/** 审批对话框与提示里 auto 判定层的名字（随界面语言）。 */
+export declare function autoLayerText(layer: "rule" | "static" | "classifier"): string;
 /**
  * 命令参数里的模式：接受值（`auto-edit`）或显示名（`Accept edits`、`accept-edits`，大小写不敏感）。
  */

package/dist/permissions/modes.js

@@ -1,20 +1,27 @@
 /**
  * 六种权限模式的显示名、一行说明、界面顺序与 Shift+Tab 循环（§7.4）。
  *
- * 显示名用英文（与常见编码 Agent 的叫法一致），说明用界面语言（中文）。界面顺序就是选择器里
+ * 显示名用英文（与常见编码 Agent 的叫法一致），说明随界面语言（`msg().permissions`）。界面顺序就是选择器里
  * 数字快捷键 1–6 的顺序；`allowlist` 不在 Shift+Tab 循环里，只能显式选。
  */
+import { msg } from "../i18n/index.js";
 import { PERMISSION_MODES_STRICT_FIRST } from "./types.js";
+/** 说明随界面语言（取用时求值，不在 import 时定死）。 */
+function info(label, key) {
+    return {
+        label,
+        get description() {
+            return msg().permissions.modeDescription[key];
+        },
+    };
+}
 export const PERMISSION_MODE_INFO = {
-    default: { label: "Manual", description: "写文件、执行命令前询问" },
-    "auto-edit": { label: "Accept edits", description: "自动接受文件编辑，执行命令仍询问" },
-    plan: { label: "Plan", description: "只读调研，只跑只读命令，出计划后审批执行" },
-    auto: { label: "Auto", description: "由 ama 判断每一步：安全的自动放行，有风险的才问" },
-    "full-auto": { label: "Bypass permissions", description: "全部放行（危险命令仍询问）" },
-    allowlist: {
-        label: "Allowlist only",
-        description: "只放行 allow 规则命中的，其余拒绝，从不询问",
-    },
+    default: info("Manual", "default"),
+    "auto-edit": info("Accept edits", "autoEdit"),
+    plan: info("Plan", "plan"),
+    auto: info("Auto", "auto"),
+    "full-auto": info("Bypass permissions", "fullAuto"),
+    allowlist: info("Allowlist only", "allowlist"),
 };
 /** 选择器顺序（数字快捷键 1–6）。 */
 export const PERMISSION_MODE_ORDER = [
@@ -60,12 +67,10 @@ export function permissionModeLines(current, configDefault) {
         return `${mark} ${i + 1}. ${info.label} (${mode}) — ${info.description}${tail}`;
     });
 }
-/** 审批对话框与提示里 auto 判定层的中文名。 */
-export const AUTO_LAYER_TEXT = {
-    rule: "规则层",
-    static: "静态判定",
-    classifier: "分类器",
-};
+/** 审批对话框与提示里 auto 判定层的名字（随界面语言）。 */
+export function autoLayerText(layer) {
+    return msg().permissions.autoLayer[layer];
+}
 /**
  * 命令参数里的模式：接受值（`auto-edit`）或显示名（`Accept edits`、`accept-edits`，大小写不敏感）。
  */

package/dist/permissions/pipeline.d.ts

@@ -57,7 +57,7 @@ export declare function planDecision(input: Pick<PermissionCheckInput, "toolName
     message?: string;
 };
 export declare const UNATTENDED_MESSAGE = "This tool call requires approval, but no one is available to approve it (unattended mode).";
-export declare const ALLOWLIST_MESSAGE = "Not in the allowlist (\u4E0D\u5728\u5141\u8BB8\u540D\u5355): permission mode \"allowlist\" only runs read-only tools and calls matched by an allow rule, and never asks.";
+export declare const ALLOWLIST_MESSAGE = "Not in the allowlist: permission mode \"allowlist\" only runs read-only tools and calls matched by an allow rule, and never asks.";
 interface SessionGrant {
     toolName: string;
     kind: "command" | "dir" | "any";

package/dist/permissions/pipeline.js

@@ -35,6 +35,7 @@
  */
 import { dirname, sep } from "node:path";
 import { isBackgroundJobQuery } from "../tools/background-jobs.js";
+import { memoryEffectivePermission } from "./memory-class.js";
 import { findAllowRule, findDenyRule, inputCommand, inputPath, normalizeCommand, splitShellSegments, } from "./rules.js";
 import { collectNestedCommands, matchDangerous } from "./dangerous.js";
 import { analyzeBashForAuto, secretReferenceReason } from "./auto-safe.js";
@@ -103,7 +104,7 @@ export function planDecision(input, planBash, cwd, projectRoot = cwd) {
     return { decision: "deny", message: PLAN_MODE_MESSAGE };
 }
 export const UNATTENDED_MESSAGE = "This tool call requires approval, but no one is available to approve it (unattended mode).";
-export const ALLOWLIST_MESSAGE = 'Not in the allowlist (不在允许名单): permission mode "allowlist" only runs read-only tools and calls matched by an allow rule, and never asks.';
+export const ALLOWLIST_MESSAGE = 'Not in the allowlist: permission mode "allowlist" only runs read-only tools and calls matched by an allow rule, and never asks.';
 /** 审计摘要：bash 取命令，带 path 的取路径，其它取工具名；单行、截断。 */
 function auditSummary(toolName, input) {
     const command = inputCommand(input);
@@ -115,6 +116,8 @@ function auditSummary(toolName, input) {
     return text.length > 80 ? `${text.slice(0, 79)}…` : text;
 }
 export function sessionGrantFor(toolName, input, cwd) {
+    if (toolName === "memory")
+        return { toolName, kind: "any", prefix: "" }; // [W6-M] 本会话允许全部写命令
     const command = inputCommand(input);
     if (command !== undefined) {
         const words = normalizeCommand(command).split(" ").slice(0, 2);
@@ -213,7 +216,11 @@ export class PermissionPipeline {
         }
         return verdict;
     }
-    evaluate(input) {
+    evaluate(raw) {
+        // [W6-C0] 权限类 memory 按命令折成 read / execute（memory-class.ts）
+        const input = raw.permission === "memory"
+            ? { ...raw, permission: memoryEffectivePermission(raw.input) }
+            : raw;
         const { toolName, permission } = input;
         // ① deny
         const layers = layeredInputs(toolName, input.input);

package/dist/permissions/preview.js

@@ -21,6 +21,7 @@ import { normalizeToLF, splitBom } from "../tools/edit-fuzzy.js";
 import { displayPath, resolvePath } from "../tools/paths.js";
 import { collectNestedCommands, commandWords, matchDangerous, shellWords } from "./dangerous.js";
 import { splitShellSegments } from "./rules.js";
+import { msg } from "../i18n/index.js";
 export const PREVIEW_MAX_ENTRIES = 2000;
 export const PREVIEW_BUDGET_MS = 200;
 /** 超过它的文件不读内容，只报大小。 */
@@ -91,9 +92,9 @@ class Collector {
     }
     finish(kind) {
         if (this.hidden > 0)
-            this.lines.push(`… 另 ${this.hidden} 处未列出`);
+            this.lines.push(msg().permissions.preview.moreHidden(this.hidden));
         if (this.timedOut) {
-            this.lines.push(`统计超时（> ${this.options.budgetMs ?? PREVIEW_BUDGET_MS} ms），实际范围可能更大`);
+            this.lines.push(msg().permissions.preview.timedOut(this.options.budgetMs ?? PREVIEW_BUDGET_MS));
             this.raise("warn");
         }
         const preview = { kind, lines: this.lines, severity: this.severity };
@@ -142,37 +143,38 @@ function tally(root, c) {
 }
 /** 统计一个路径：返回目标与「：」之后的说明。 */
 function inspect(abs, c) {
+    const m = msg().permissions.preview;
     const shown = displayPath(abs, c.root);
     const info = tryStat(abs);
     if (info === undefined)
-        return { target: { path: shown, exists: false }, text: "不存在" };
+        return { target: { path: shown, exists: false }, text: m.missing };
     if (info.isSymbolicLink())
-        return { target: { path: shown, exists: true }, text: "符号链接" };
+        return { target: { path: shown, exists: true }, text: m.symlink };
     if (!info.isDirectory()) {
         return {
             target: { path: shown, exists: true, bytes: info.size },
-            text: `文件，${formatBytes(info.size)}`,
+            text: m.file(formatBytes(info.size)),
         };
     }
     const t = tally(abs, c);
     const target = { path: `${shown}/`, exists: true, files: t.files };
     if (t.capped)
-        return { target, text: `目录，> ${c.maxEntries} 项` };
+        return { target, text: m.dirCapped(c.maxEntries) };
     target.bytes = t.bytes;
-    const partial = c.timedOut ? "（统计未完成）" : "";
-    return { target, text: `目录，${t.files} 个文件，${formatBytes(t.bytes)}${partial}` };
+    return { target, text: m.dir(t.files, formatBytes(t.bytes), c.timedOut) };
 }
 /** 一个路径参数一行；含通配 / 变量的原样显示不展开。 */
-function pathLine(verb, word, c, note = "") {
+function pathLine(verb, word, c, note) {
+    const m = msg().permissions.preview;
     if (UNEXPANDED.test(word)) {
-        c.target(`${verb} ${word}：含通配符或变量，未展开，实际范围可能更大`);
+        c.target(m.pathUnexpanded(verb, word));
         c.raise("warn");
         return;
     }
     const { target, text } = inspect(resolvePath(word, c.cwd), c);
     if (target.exists)
         c.raise("warn");
-    c.target(`${verb} ${target.path}：${text}${note}`, target);
+    c.target(m.pathTarget(verb, target.path, text, note), target);
 }
 /** 段里的 `>` / `>>` 重定向：返回目标与去掉重定向后的文本。 */
 export function splitRedirects(segment) {
@@ -250,7 +252,7 @@ function previewSegment(segment, c) {
     for (const { word, append } of targets) {
         if (NULL_DEVICES.has(word.toLowerCase()))
             continue;
-        pathLine(append ? "追加写入" : "覆盖写入", word, c);
+        pathLine(append ? "append" : "overwrite", word, c);
     }
     const argv = commandWords(rest);
     const name = basename(argv[0] ?? "");
@@ -261,20 +263,20 @@ function previewSegment(segment, c) {
     if (name === "rm" || name === "rmdir" || name === "unlink") {
         const paths = operands(argv);
         if (paths.length === 0)
-            c.target(`${name}：路径来自管道或展开，范围未知`);
+            c.target(msg().permissions.preview.rmUnknown(name));
         for (const p of paths)
-            pathLine("删除", p, c);
+            pathLine("delete", p, c);
     }
     else if (name === "mv") {
         const paths = operands(argv, ["-t", "-S", "--target-directory", "--suffix"]);
         const t = argv.indexOf("-t");
         const dest = t > 0 ? argv[t + 1] : paths.pop();
         for (const p of paths)
-            pathLine("移动", p, c);
+            pathLine("move", p, c);
         if (dest !== undefined && paths.length > 0) {
             const info = UNEXPANDED.test(dest) ? undefined : tryStat(resolvePath(dest, c.cwd));
-            const note = info?.isDirectory() ? "（已存在的目录，移入其中）" : "（已存在，将被覆盖）";
-            pathLine("移到", dest, c, info === undefined ? "" : note);
+            const note = info?.isDirectory() ? "intoDir" : "overwritten";
+            pathLine("moveTo", dest, c, info === undefined ? undefined : note);
         }
     }
     else if (name === "git") {
@@ -299,7 +301,7 @@ function previewGit(argv, c) {
             !args.some((a) => a === "-n" || a === "--dry-run" || /^-[a-z]*n/.test(a))) {
             const paths = operands(args, ["-e", "--exclude"]);
             for (const p of paths.length > 0 ? paths : ["."]) {
-                pathLine("git clean 范围", p, c, "（计数含已跟踪文件，实际只删未跟踪的）");
+                pathLine("gitClean", p, c, "gitCleanTracked");
             }
             // 与危险规则无关地标红：`git -C 目录 clean -f` 之类危险表认不出的写法也算
             if (args.some((a) => a === "--force" || /^-[A-Za-z]*f/.test(a)))
@@ -307,10 +309,10 @@ function previewGit(argv, c) {
         }
         else if (sub === "checkout" && args.includes("--")) {
             for (const p of args.slice(args.indexOf("--") + 1))
-                pathLine("丢弃改动", p, c);
+                pathLine("discard", p, c);
         }
         else if (sub === "reset" && args.includes("--hard")) {
-            c.lines.push("git reset --hard：丢弃工作区与暂存区的全部未提交改动");
+            c.lines.push(msg().permissions.preview.gitResetHard);
             c.raise("danger");
         }
     }
@@ -321,7 +323,7 @@ function previewGit(argv, c) {
 function previewBash(command, c, dangerous) {
     const hit = matchDangerous(command);
     if (hit !== undefined)
-        c.lines.push(`危险：${hit.description}`);
+        c.lines.push(msg().permissions.preview.dangerous(hit.description));
     if (hit !== undefined || dangerous)
         c.raise("danger");
     const nested = collectNestedCommands(command);
@@ -336,7 +338,7 @@ function previewBash(command, c, dangerous) {
     }
     c.cwd = start;
     if (nested.tooDeep) {
-        c.lines.push("嵌套过深，内层命令未展开");
+        c.lines.push(msg().permissions.preview.tooDeep);
         c.raise("warn");
     }
 }
@@ -347,55 +349,58 @@ function unread(abs, request, c, tool) {
     const readFiles = request.context?.readFiles;
     if (readFiles === undefined || readFiles.has(abs))
         return;
-    c.lines.push(`本会话未 read 过此文件，${tool} 会被拒绝（先 read）`);
+    c.lines.push(msg().permissions.preview.unread(tool));
     c.raise("warn");
 }
 function previewWrite(input, request, c) {
     const abs = resolvePath(String(input["path"] ?? ""), c.cwd);
     const content = typeof input["content"] === "string" ? input["content"] : "";
-    const next = `${countLines(content)} 行，${formatBytes(Buffer.byteLength(content, "utf8"))}`;
+    const m = msg().permissions.preview;
+    const next = m.size(countLines(content), formatBytes(Buffer.byteLength(content, "utf8")));
     const shown = displayPath(abs, c.root);
     const info = tryStat(abs, true);
     if (info === undefined) {
-        c.target(`新建 ${shown}：${next}`, { path: shown, exists: false });
+        c.target(m.writeNew(shown, next), { path: shown, exists: false });
         return;
     }
     if (info.isDirectory()) {
-        c.target(`${shown} 是目录，write 会失败`, { path: `${shown}/`, exists: true });
+        c.target(m.writeIsDir(shown), { path: `${shown}/`, exists: true });
         c.raise("warn");
         return;
     }
     const old = readSmall(abs, info);
-    const before = old === undefined ? formatBytes(info.size) : `${countLines(old)} 行，${formatBytes(info.size)}`;
-    c.target(`覆盖 ${shown}：${before} → ${next}`, { path: shown, exists: true, bytes: info.size });
+    const before = old === undefined ? formatBytes(info.size) : m.size(countLines(old), formatBytes(info.size));
+    c.target(m.writeOverwrite(shown, before, next), { path: shown, exists: true, bytes: info.size });
     unread(abs, request, c, "write");
 }
 function editFailure(message) {
+    const m = msg().permissions.preview;
     const many = /^(\S+) matches (\d+) times/.exec(message);
     if (many)
-        return `${many[1]} 匹配不唯一（${many[2]} 处）`;
+        return m.editNotUnique(many[1], many[2]);
     const missing = /^Could not find (\S+)/.exec(message);
     if (missing)
-        return `未找到 ${missing[1]}`;
+        return m.editNotFound(missing[1]);
     if (message.includes("overlap"))
-        return "多处修改的区间重叠";
+        return m.editOverlap;
     if (message.includes("no change"))
-        return "修改前后内容相同";
+        return m.editNoChange;
     return message;
 }
 function previewEdit(input, request, c) {
+    const m = msg().permissions.preview;
     const abs = resolvePath(String(input["path"] ?? ""), c.cwd);
     const shown = displayPath(abs, c.root);
     const info = tryStat(abs, true);
     if (info === undefined || !info.isFile()) {
-        c.target(`${shown} 不存在或不是文件，edit 会失败`, { path: shown, exists: info !== undefined });
+        c.target(m.editMissing(shown), { path: shown, exists: info !== undefined });
         c.raise("warn");
         return;
     }
     const target = { path: shown, exists: true, bytes: info.size };
     const raw = readSmall(abs, info);
     if (raw === undefined) {
-        c.target(`修改 ${shown}：${formatBytes(info.size)}，文件过大，未干跑`, target);
+        c.target(m.editTooLarge(shown, formatBytes(info.size)), target);
         unread(abs, request, c, "edit");
         return;
     }
@@ -403,19 +408,18 @@ function previewEdit(input, request, c) {
     const edits = Array.isArray(input["edits"]) ? input["edits"] : [];
     try {
         const plan = planEdits(content, edits, input["replaceAll"] === true);
-        const fuzzy = plan.fuzzy ? "（空白 / 引号归一后匹配）" : "";
-        c.target(`修改 ${shown}：${plan.replacements} 处替换${fuzzy}`, target);
+        c.target(m.editPlan(shown, plan.replacements, plan.fuzzy === true), target);
         edits.slice(0, 5).forEach((e, i) => {
-            c.lines.push(`  #${i + 1} −${countLines(e.oldText)}/+${countLines(e.newText)} 行`);
+            c.lines.push(m.editOp(i + 1, countLines(e.oldText), countLines(e.newText)));
         });
         if (edits.length > 5)
-            c.lines.push(`  … 另 ${edits.length - 5} 处`);
-        c.lines.push(`  共 ${countLines(content)} → ${countLines(plan.result)} 行`);
+            c.lines.push(m.editMore(edits.length - 5));
+        c.lines.push(m.editTotal(countLines(content), countLines(plan.result)));
     }
     catch (err) {
         if (!(err instanceof EditError))
             throw err;
-        c.target(`修改 ${shown}：干跑失败——${editFailure(err.message)}`, target);
+        c.target(m.editDryRunFailed(shown, editFailure(err.message)), target);
         c.raise("warn");
     }
     unread(abs, request, c, "edit");
@@ -449,7 +453,7 @@ export function previewAction(request, options) {
         }
     }
     catch (err) {
-        c.lines.push(`预览失败：${err instanceof Error ? err.message : String(err)}`);
+        c.lines.push(msg().permissions.preview.failed(err instanceof Error ? err.message : String(err)));
     }
     return c.finish(kind);
 }
@@ -459,5 +463,8 @@ export function previewDisplayLines(preview, max = 10) {
         return [];
     if (preview.lines.length <= max)
         return preview.lines;
-    return [...preview.lines.slice(0, max - 1), `… 另 ${preview.lines.length - max + 1} 行`];
+    return [
+        ...preview.lines.slice(0, max - 1),
+        msg().permissions.preview.moreLines(preview.lines.length - max + 1),
+    ];
 }

package/dist/permissions/rules.js

@@ -18,6 +18,7 @@ import { AmaError } from "../errors.js";
 import { PERMISSION_MODES_STRICT_FIRST } from "./types.js";
 import { globBody } from "../tools/glob.js";
 import { expandHome, resolvePath, toPosix } from "../tools/paths.js";
+import { memoryRuleMatches } from "./memory-class.js";
 /** 内置缺省 deny 表（用户可经 `builtinDeny` 选项移除）。 */
 export const BUILTIN_DENY_RULES = [
     "write(**/.git/**)",
@@ -147,6 +148,8 @@ function matchesSubject(rule, toolName, input, cwd, command) {
         return false;
     if (rule.pattern === undefined)
         return true;
+    if (toolName === "memory")
+        return memoryRuleMatches(rule.pattern, input); // [W6-M] 逻辑路径 / 命令名
     if (command !== undefined)
         return wildcardToRegExp(rule.pattern).test(command);
     const abs = inputPath(toolName, input, cwd);
@@ -154,7 +157,7 @@ function matchesSubject(rule, toolName, input, cwd, command) {
 }
 /** 第一条命中的 deny 规则。 */
 export function findDenyRule(rules, toolName, input, cwd) {
-    const command = inputCommand(input);
+    const command = toolName === "memory" ? undefined : inputCommand(input);
     for (const rule of rules) {
         if (rule.effect !== "deny")
             continue;
@@ -172,7 +175,7 @@ export function findDenyRule(rules, toolName, input, cwd) {
 /** 覆盖本次调用的 allow 规则（复合命令返回第一段的覆盖者）；不覆盖返回 undefined。 */
 export function findAllowRule(rules, toolName, input, cwd) {
     const allows = rules.filter((r) => r.effect === "allow");
-    const command = inputCommand(input);
+    const command = toolName === "memory" ? undefined : inputCommand(input);
     if (command === undefined)
         return allows.find((r) => matchesSubject(r, toolName, input, cwd));
     const unconditional = allows.find((r) => r.pattern === undefined && toolNameMatches(r.tool, toolName));

package/dist/permissions/types.d.ts

@@ -79,6 +79,8 @@ export interface ApprovalRequestContext {
      * 无人值守拒绝），auto 分类器与模型都不参与；RPC `permission_request` 原样带出。
      */
     origin?: ExternalPermissionOrigin;
+    /** [W6-C0] 触发审批的工具调用 id（`gateToolCall` 填；轨迹据此算 `approvalMs`）。 */
+    toolCallId?: string;
 }
 /** [W5-C0] 外部 Agent 权限选项的种类（ACP 词汇）。 */
 export type ExternalPermissionOptionKind = "allow_once" | "allow_always" | "reject_once" | "reject_always";
@@ -109,6 +111,8 @@ export interface PermissionRequestContext {
     taskId?: string;
     /** 外部 Agent 的权限请求（对话框标 `[claude · 会话 abc1]`）。 */
     origin?: ExternalPermissionOrigin;
+    /** [W6-C0] 触发审批的工具调用 id（本会话的 toolCallId；外部 Agent 的请求不带）。 */
+    toolCallId?: string;
 }
 /** [W3-C0] 预览涉及的路径（bash 的 rm / mv / 重定向目标，write / edit 的目标文件）。 */
 export interface ActionPreviewTarget {

package/dist/plan/store.js

@@ -9,6 +9,7 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, relative, resolve } from "node:path";
 import { TODO_CUSTOM_TYPE, parseTodoState } from "../tools/todo.js";
+import { msg } from "../i18n/index.js";
 export const PLAN_CUSTOM_TYPE = "ama.plan";
 export const PLAN_STATE_CUSTOM_TYPE = "ama.plan_state";
 function customData(entry, customType) {
@@ -76,7 +77,7 @@ export function resolvePlanDirectory(configured, projectRoot, dataDir) {
     if (rel.startsWith("..") || isAbsolute(rel)) {
         return {
             dir: fallback,
-            warning: `plan.directory ${configured} 不在项目根 ${projectRoot} 之内，计划文件改写到 ${fallback}`,
+            warning: msg().session.plan.directoryOutside(configured, projectRoot, fallback),
         };
     }
     return { dir };

package/dist/rpc.d.ts

@@ -16,6 +16,9 @@
  *   get_tasks / get_agents`（返回形状见 `RpcW5Results`），客户端能力 `plans`（声明后计划审批交客户端）；
  *   新事件由 `SessionEvent` 派生自动包含。命令实现归 W5-F（C0 时返回 `not_implemented`），
  *   `RPC_PROTOCOL_VERSION` 不变。
+ * - [W6-C0] 第六波（docs/wave6-plan.md §2.6、§4.4）：命令 `get_trace`（参数 `RpcGetTraceParams`、返回
+ *   `RpcW6Results`，W6-T2 实现，之前回 `not_implemented`）；事件 `quota_update`；`permission_request.context`
+ *   可带 `toolCallId`；`keySource` 可为 `oauth`。`RPC_PROTOCOL_VERSION` 不变。
  */
 import type { AssistantEvent, ImageBlock, ModelThinkingLevel, Usage } from "./ai/types.js";
 import type { PlanData, PlanDecisionKind, QueueMode, SessionEvent, TodoItemView } from "./agent/types.js";
@@ -23,6 +26,8 @@ import type { AgentInfo } from "./agents/types.js";
 import type { TaskInfo } from "./tools/types.js";
 import type { RewindRequest } from "./checkpoints/types.js";
 import type { ApprovalDecision, PermissionMode } from "./permissions/types.js";
+import type { TracePreview } from "./trace/preview.js";
+import type { Trace, TraceSubagentNode } from "./trace/types.js";
 export type { SessionEvent } from "./agent/types.js";
 export declare const RPC_PROTOCOL_VERSION: 1;
 /** `plans`（W5-C0）：客户端声明后计划审批交给客户端（`plan_proposed` → `plan_response`）。 */
@@ -133,6 +138,38 @@ export interface RpcCommandMap {
     get_todos: NoParams;
     get_tasks: NoParams;
     get_agents: NoParams;
+    get_trace: RpcGetTraceParams;
+}
+/** [W6-C0] `get_trace` 的参数。 */
+export interface RpcGetTraceParams {
+    /** 缺省 leaf。 */
+    branch?: "leaf" | "all";
+    /** 尾部优先的回合数，缺省 50，上限 500。 */
+    turnLimit?: number;
+    /** 回合游标（turn id），向前翻页。 */
+    before?: string;
+    /** 条目游标（同 `get_entries.since`）：只返回从包含该条目的回合起的回合。 */
+    since?: string;
+    /** 该任务的子轨迹（ama 子会话或外部骨架）。 */
+    taskId?: string;
+    /** 缺省 none（只有结构与数字）。 */
+    content?: "none" | "preview";
+}
+/** [W6-C0] 第六波命令成功时的 `data` 形状；错误 `task_not_found` / `invalid_arguments`。 */
+export interface RpcW6Results {
+    get_trace: {
+        trace: Trace;
+        hasMoreBefore: boolean;
+        cursor: {
+            before?: string;
+            since: string;
+        };
+        leafId: string | null;
+        /** [W6-T2] `taskId` 时：子 Agent 节点本身（不含 `child`；外部 Agent 的骨架在 `external`）。 */
+        task?: TraceSubagentNode;
+        /** [W6-T2] `content:"preview"` 时：`<kind>:<id>` → 已脱敏、已截断的正文预览（只含窗口内节点）。 */
+        previews?: Record<string, TracePreview>;
+    };
 }
 /** [W5-C0] 计划审批的回答（与 `permission_response` 同构）。 */
 export interface RpcPlanResponse {
@@ -179,7 +216,8 @@ export interface RpcModelInfo {
     name: string;
     /** 只报有无，不回密钥。 */
     hasKey: boolean;
-    keySource: "cli" | "auth-file" | "config" | "env" | "none";
+    /** [W6-C0] 加 `oauth`（ChatGPT 登录，W6-O）。 */
+    keySource: "cli" | "auth-file" | "config" | "env" | "oauth" | "none";
     contextWindow?: number;
     maxTokens: number;
     reasoning: boolean;