@armadra/agent 0.5.1 → 0.6.0

package/dist/memory/tool.js

@@ -0,0 +1,94 @@
+/**
+ * `memory` 工具（docs/wave6-plan.md §3.3、D10）。[W6-M] 模型侧模块：不得 import src/i18n。
+ *
+ * 自定义工具（不声明供应商原生的 memory 工具类型），四个命令：`view / create / str_replace / delete`，路径限定
+ * 在 `/memories/<scope>/`。权限类 `memory`：view 按读放行，写命令按 execute 判定（permissions/memory-class.ts）。
+ * 执行层额外拒绝：
+ * - 子会话（depth > 0）：`memory.subagents: "read"` 拒绝写命令，`"off"` 连 view 也拒绝——工具定义与父会话
+ *   一致，保住子会话首请求命中父前缀；
+ * - `/memory off`：本会话禁止写；
+ * - 凭据、大小、条数上限、路径越界（store.ts）。
+ * 写入只落盘：结果提示「下次会话起出现在索引」，本会话的 `memory` 节不变（前缀稳定）。
+ */
+import { MemoryLockError } from "./lock.js";
+import { MemoryError } from "./store.js";
+export const MEMORY_TOOL = "memory";
+export const MEMORY_GUIDELINES = [
+    "memory: save only when the user asks you to remember something or states a durable preference or correction; never store secrets or facts that can be read from the repository or git history.",
+    "memory: entries can be stale; verify names, paths and commands against the current project before relying on them.",
+    "memory: one topic per file; update an existing entry instead of adding a duplicate.",
+];
+function fail(input, code, message) {
+    const details = { command: String(input.command ?? ""), code };
+    if (typeof input.path === "string")
+        details.path = input.path;
+    return { content: message, isError: true, details };
+}
+export function createMemoryTool(runtime) {
+    return {
+        name: MEMORY_TOOL,
+        label: "Memory",
+        description: "Notes that persist across sessions, stored as Markdown files under /memories/<scope>/ (scopes and entries are listed in the memory index). " +
+            "Commands: view a directory or file, create (or overwrite) a file, str_replace a unique string, delete a file.",
+        parameters: {
+            type: "object",
+            properties: {
+                command: { type: "string", enum: ["view", "create", "str_replace", "delete"] },
+                path: { type: "string", description: "e.g. /memories/user/prefers-pnpm.md" },
+                view_range: { type: "array", items: { type: "integer" } },
+                file_text: { type: "string", description: "create: full Markdown content" },
+                old_str: { type: "string" },
+                new_str: { type: "string" },
+            },
+            required: ["command", "path"],
+            additionalProperties: false,
+        },
+        permission: "memory",
+        executionMode: "sequential",
+        promptSnippet: "memory: read and save notes that persist across sessions",
+        promptGuidelines: MEMORY_GUIDELINES,
+        async execute(input, ctx) {
+            const command = input?.command;
+            const write = command !== "view";
+            if (ctx.depth > 0) {
+                if (runtime.subagents === "off")
+                    return fail(input, "subagent", "subagents cannot access memory");
+                if (write)
+                    return fail(input, "subagent", "subagents cannot modify memory");
+            }
+            if (write && !runtime.writesEnabled)
+                return fail(input, "disabled", "memory writes are turned off for this session");
+            const store = runtime.store;
+            try {
+                switch (command) {
+                    case "view":
+                        return {
+                            content: store.view(input.path, input.view_range),
+                            details: { command, path: input.path },
+                        };
+                    case "create":
+                    case "str_replace":
+                    case "delete": {
+                        const result = command === "create"
+                            ? await store.create(input.path, input.file_text)
+                            : command === "str_replace"
+                                ? await store.strReplace(input.path, input.old_str, input.new_str)
+                                : await store.delete(input.path);
+                        const verb = command === "delete" ? "Deleted" : result.created ? "Saved new entry" : "Updated";
+                        return {
+                            content: `${verb} ${result.path}. The memory index will show it from the next session.`,
+                            details: { command, path: result.path },
+                        };
+                    }
+                    default:
+                        return fail(input, "invalid_command", 'command must be "view", "create", "str_replace" or "delete"');
+                }
+            }
+            catch (error) {
+                if (error instanceof MemoryError || error instanceof MemoryLockError)
+                    return fail(input, error.code, error.message);
+                throw error;
+            }
+        },
+    };
+}

package/dist/modes/acp/acp-events.js

@@ -17,6 +17,7 @@
 import { isAbsolute, resolve } from "node:path";
 import { PERMISSION_MODES_STRICT_FIRST } from "../../permissions/types.js";
 import { oneLine } from "../../drivers/turn.js";
+import { msg } from "../../i18n/index.js";
 export const TOOL_OUTPUT_LIMIT = 4 * 1024;
 const KINDS = {
     read: "read",
@@ -61,7 +62,7 @@ function resultText(result) {
         ? result.content
         : result.content.map((b) => (b.type === "text" ? b.text : `[${b.type}]`)).join("");
     return text.length > TOOL_OUTPUT_LIMIT
-        ? `${text.slice(0, TOOL_OUTPUT_LIMIT)}\n…（已截断，共 ${text.length} 字符）`
+        ? `${text.slice(0, TOOL_OUTPUT_LIMIT)}\n${msg().print.acp.truncated(text.length)}`
         : text;
 }
 export function permissionModes(currentModeId) {

package/dist/modes/acp/acp-server.js

@@ -24,6 +24,7 @@ import { isPermissionMode } from "../../permissions/modes.js";
 import { AMA_VERSION } from "../../version.js";
 import { errorText } from "../shared.js";
 import { AcpEventMapper, permissionModes, toolKind, toolLocations, toolTitle, } from "./acp-events.js";
+import { msg } from "../../i18n/index.js";
 export const ACP_AGENT_CAPABILITIES = {
     loadSession: true,
     promptCapabilities: { image: true, audio: false, embeddedContext: true },
@@ -42,13 +43,13 @@ function canonical(path) {
 function str(params, key) {
     const value = params[key];
     if (typeof value !== "string" || value === "")
-        throw new RpcError(RPC_ERRORS.invalidParams, `缺少 ${key}`);
+        throw new RpcError(RPC_ERRORS.invalidParams, msg().print.acp.missingParam(key));
     return value;
 }
 /** ACP 提示 → ama 的文本与图片。 */
 export function promptOf(blocks) {
     if (!Array.isArray(blocks))
-        throw new RpcError(RPC_ERRORS.invalidParams, "prompt 应为内容块数组");
+        throw new RpcError(RPC_ERRORS.invalidParams, msg().print.acp.promptNotArray);
     const parts = [];
     const images = [];
     for (const block of blocks) {
@@ -87,7 +88,7 @@ export class AcpServer {
                 if (method === ACP_METHODS.sessionCancel)
                     void this.cancel((params ?? {}));
             },
-            onProtocolError: (_line, reason) => this.log(`ACP：无法解析的输入（${reason}）`),
+            onProtocolError: (_line, reason) => this.log(msg().print.acp.unparsable(reason)),
         });
         this.subscribe();
     }
@@ -138,7 +139,7 @@ export class AcpServer {
     }
     initialize(params) {
         if (typeof params["protocolVersion"] !== "number")
-            throw new RpcError(RPC_ERRORS.invalidParams, "缺少 protocolVersion");
+            throw new RpcError(RPC_ERRORS.invalidParams, msg().print.acp.missingProtocolVersion);
         return {
             protocolVersion: ACP_PROTOCOL_VERSION,
             agentCapabilities: ACP_AGENT_CAPABILITIES,
@@ -151,7 +152,7 @@ export class AcpServer {
         if (cwd === undefined)
             return;
         if (typeof cwd !== "string" || canonical(cwd) !== this.cwd)
-            throw new RpcError(RPC_ERRORS.invalidParams, `ama --mode acp 的会话目录固定为启动目录 ${this.cwd}（收到 ${String(cwd)}）`);
+            throw new RpcError(RPC_ERRORS.invalidParams, msg().print.acp.fixedCwd(this.cwd, String(cwd)));
     }
     modes() {
         return permissionModes(this.session().state.permissionMode);
@@ -185,7 +186,7 @@ export class AcpServer {
                 await this.switchTo(switchSession(this.runtime, { kind: "resume", id }), "resume");
             }
             catch (error) {
-                throw new RpcError(RPC_ERRORS.resourceNotFound, `找不到会话 ${id}：${errorText(error)}`);
+                throw new RpcError(RPC_ERRORS.resourceNotFound, msg().print.acp.sessionNotFound(id, errorText(error)));
             }
         }
         this.freshUnclaimed = false;
@@ -222,7 +223,7 @@ export class AcpServer {
     }
     ensureIdle() {
         if (this.session().state.isStreaming)
-            throw new RpcError(RPC_ERRORS.invalidRequest, "当前会话正在运行，先 session/cancel");
+            throw new RpcError(RPC_ERRORS.invalidRequest, msg().print.acp.busy);
     }
     async prompt(params) {
         const id = str(params, "sessionId");
@@ -253,7 +254,7 @@ export class AcpServer {
             return { stopReason: "cancelled", usage };
         if (reason === "error") {
             const message = last !== undefined && "errorMessage" in last ? last.errorMessage : undefined;
-            throw new RpcError(RPC_ERRORS.internalError, message ?? "模型请求失败");
+            throw new RpcError(RPC_ERRORS.internalError, message ?? msg().print.acp.modelFailed);
         }
         return { stopReason: reason === "length" ? "max_tokens" : "end_turn", usage };
     }
@@ -269,7 +270,7 @@ export class AcpServer {
         str(params, "sessionId");
         const mode = params["modeId"];
         if (!isPermissionMode(mode))
-            throw new RpcError(RPC_ERRORS.invalidParams, `未知模式：${String(mode)}`);
+            throw new RpcError(RPC_ERRORS.invalidParams, msg().print.acp.unknownMode(String(mode)));
         this.session().setPermissionMode(mode);
         return {};
     }
@@ -292,9 +293,9 @@ export class AcpServer {
                     ...(locations !== undefined ? { locations } : {}),
                 },
                 options: [
-                    { optionId: "allow_once", name: "允许", kind: "allow_once" },
-                    { optionId: "allow_always", name: "本会话允许", kind: "allow_always" },
-                    { optionId: "reject_once", name: "拒绝", kind: "reject_once" },
+                    { optionId: "allow_once", name: msg().print.acp.allowOnce, kind: "allow_once" },
+                    { optionId: "allow_always", name: msg().print.acp.allowAlways, kind: "allow_always" },
+                    { optionId: "reject_once", name: msg().print.acp.rejectOnce, kind: "reject_once" },
                 ],
             }, signal);
         }

package/dist/modes/commands-core.d.ts

@@ -10,6 +10,8 @@
  * 会话切换（/new /resume /fork）经 `ctx.switchSession`，调用方据返回的新会话重新订阅事件。
  * `/rewind`（RW-C）：无参数列出回滚点，带参数执行（interactive/rewind-command.ts）；对话变了时
  * `handled` 带 `draft`（原消息）与 `reload`，界面据此回填输入框、重画消息区。
+ * [W6-C0] `/config`、`/trace`、`/memory` 登记在表里，由各功能批次经 `CommandContext.extra`（line 模式）或
+ * `CommandUi` 的面板钩子（交互模式，interactive/commands.ts）实现；没有实现时回「尚未提供」。
  */
 import type { AgentSession, RewindDraftText } from "../agent/types.js";
 import type { SwitchRequest } from "../cli/compose-session.js";
@@ -42,7 +44,16 @@ export interface CommandContext {
      * 保持原模式。没有时直接切换（管道、RPC 等无人值守入口）。
      */
     confirmPermissionMode?(mode: PermissionMode): boolean | Promise<boolean>;
+    /**
+     * [W6-C0] 第六波命令的处理器（命令名 → 处理器）：line 模式 `/config`（W6-S）、`/trace`（W6-T1）、
+     * `/memory`（W6-M）等在这里挂；命中时先于内置分派。交互模式走 `CommandUi` 的面板钩子。
+     */
+    extra?: Readonly<Record<string, CommandHandler>>;
 }
+/** [W6-C0] `CommandContext.extra` 的处理器。 */
+export type CommandHandler = (args: string, ctx: CommandContext) => Promise<CommandResult>;
+/** [W6-C0] 各功能批次实现的第六波命令（没有处理器时回「尚未提供」）。 */
+export declare const W6_COMMANDS: readonly ["config", "trace", "memory"];
 export interface CommandInfo {
     name: string;
     args?: string;

package/dist/modes/commands-core.js

@@ -10,6 +10,8 @@
  * 会话切换（/new /resume /fork）经 `ctx.switchSession`，调用方据返回的新会话重新订阅事件。
  * `/rewind`（RW-C）：无参数列出回滚点，带参数执行（interactive/rewind-command.ts）；对话变了时
  * `handled` 带 `draft`（原消息）与 `reload`，界面据此回填输入框、重画消息区。
+ * [W6-C0] `/config`、`/trace`、`/memory` 登记在表里，由各功能批次经 `CommandContext.extra`（line 模式）或
+ * `CommandUi` 的面板钩子（交互模式，interactive/commands.ts）实现；没有实现时回「尚未提供」。
  */
 import { AgentSessionImpl } from "../agent/session.js";
 import { WARMING_MODES } from "../ai/cache/types.js";
@@ -21,47 +23,54 @@ import { planCommand } from "./interactive/plan-command.js";
 import { rewindCommand } from "./interactive/rewind-command.js";
 import { describeAgents, describeTaskOutput, describeTasks, stopTask, } from "./interactive/tasks-report.js";
 import { describeCache, describeFingerprint, describeSession } from "./session-report.js";
+import { msg } from "../i18n/index.js";
 export { describeSession } from "./session-report.js";
+/** [W6-C0] 各功能批次实现的第六波命令（没有处理器时回「尚未提供」）。 */
+export const W6_COMMANDS = ["config", "trace", "memory"];
+/**
+ * 说明与需要翻译的参数占位按界面语言取（getter，不在 import 时定死，docs/i18n.md）；
+ * `args` 是字符串时原样（不含要翻译的词），是 `{ key }` 时取目录里的占位。
+ */
+function command(name, key, args) {
+    const info = {
+        name,
+        get description() {
+            return msg().report.commands[key];
+        },
+    };
+    if (typeof args === "string")
+        info.args = args;
+    else if (args !== undefined)
+        Object.defineProperty(info, "args", {
+            enumerable: true,
+            get: () => msg().report.commands[args.key],
+        });
+    return info;
+}
 export const BUILTIN_COMMANDS = [
-    { name: "help", description: "列出命令" },
-    { name: "new", description: "新建会话" },
-    { name: "resume", args: "[id]", description: "恢复会话（无 id 时选择）" },
-    { name: "fork", args: "[条目 id]", description: "从某条目分叉出新会话" },
-    { name: "compact", args: "[说明]", description: "压缩上下文" },
-    {
-        name: "rewind",
-        args: "[n] [both|conversation|code|summarize-from|summarize-up-to]",
-        description: "回滚对话与代码到某条消息之前",
-    },
-    { name: "model", args: "[provider/id]", description: "切换模型" },
-    {
-        name: "thinking",
-        args: "[级别]",
-        description: "思考级别 off | minimal | low | medium | high | xhigh",
-    },
-    {
-        name: "permission",
-        args: "[模式]",
-        description: "权限模式 plan | default | auto-edit | full-auto",
-    },
-    { name: "tools", args: "[名字…]", description: "列出 / 设置活动工具" },
-    { name: "hooks", description: "列出已加载的 Hook" },
-    { name: "session", description: "会话信息、用量与缓存" },
-    {
-        name: "cache",
-        args: "[warm off|streaming|idle | fingerprint]",
-        description: "缓存统计；切换本会话保温；打印前缀指纹",
-    },
-    { name: "statusline", args: "[full|compact]", description: "底部信息行两行 / 一行（Ctrl+G）" },
-    {
-        name: "plan",
-        args: "[目标] | approve [模式|fresh] | reject",
-        description: "查看计划与状态；带目标进入 Plan 模式；批准 / 放弃待审批的计划",
-    },
-    { name: "tasks", args: "[id] | stop <id>", description: "子 Agent 任务：状态、输出、停止" },
-    { name: "agents", description: "子 Agent 类型与外部 Agent（安装状态、版本）" },
-    { name: "paste", description: "粘贴剪贴板里的图片（Ctrl+V）" },
-    { name: "exit", description: "退出" },
+    command("help", "help"),
+    command("new", "new"),
+    command("resume", "resume", "[id]"),
+    command("fork", "fork", { key: "forkArgs" }),
+    command("compact", "compact", { key: "compactArgs" }),
+    command("rewind", "rewind", "[n] [both|conversation|code|summarize-from|summarize-up-to]"),
+    command("model", "model", "[provider/id]"),
+    command("thinking", "thinking", { key: "thinkingArgs" }),
+    command("permission", "permission", { key: "permissionArgs" }),
+    command("tools", "tools", { key: "toolsArgs" }),
+    command("hooks", "hooks"),
+    command("session", "session"),
+    command("cache", "cache", "[warm off|streaming|idle | fingerprint]"),
+    command("statusline", "statusline", "[full|compact]"),
+    command("plan", "plan", { key: "planArgs" }),
+    command("tasks", "tasks", "[id] | stop <id>"),
+    command("agents", "agents"),
+    command("paste", "paste"),
+    command("exit", "exit"),
+    // [W6-C0] 第六波（W6-S / W6-T1 / W6-M 实现）
+    command("config", "config", "[key=value]"),
+    command("trace", "trace", { key: "traceArgs" }),
+    command("memory", "memory", { key: "memoryArgs" }),
 ];
 const ALIASES = { quit: "exit", q: "exit", "?": "help" };
 export function parseSlash(line) {
@@ -73,7 +82,8 @@ export function parseSlash(line) {
 }
 function helpText() {
     const lines = BUILTIN_COMMANDS.map((c) => `/${c.name}${c.args !== undefined ? ` ${c.args}` : ""}  ${c.description}`);
-    return [...lines, "/skill:<名字> [参数]  使用 Skill", "/<模板名> [参数]  展开提示模板"].join("\n");
+    const m = msg().report.commands;
+    return [...lines, m.skillLine, m.templateLine].join("\n");
 }
 function toolNames(args) {
     return args
@@ -90,15 +100,15 @@ function cacheCommand(session, args) {
         return describeFingerprint(session);
     if (sub === "warm" && extra === undefined) {
         if (!(session instanceof AgentSessionImpl))
-            throw new AmaError("invalid_arguments", "当前会话不支持切换保温");
+            throw new AmaError("invalid_arguments", msg().report.command.warmingUnsupported);
         if (value === undefined)
-            return `保温：${session.cache.mode()}`;
+            return msg().report.command.warming(session.cache.mode());
         if (!WARMING_MODES.includes(value))
-            throw new AmaError("invalid_arguments", `保温模式应为 ${WARMING_MODES.join(" | ")}`);
+            throw new AmaError("invalid_arguments", msg().report.command.warmingInvalid(WARMING_MODES));
         session.cache.setWarming(value);
-        return `保温：${session.cache.mode()}（本会话）`;
+        return msg().report.command.warmingSet(session.cache.mode());
     }
-    throw new AmaError("invalid_arguments", "用法：/cache [warm off|streaming|idle | fingerprint]");
+    throw new AmaError("invalid_arguments", msg().report.command.cacheUsage);
 }
 /** `/tasks`、`/tasks <id>`、`/tasks stop <id>`。 */
 async function tasksCommand(sessionId, args) {
@@ -108,17 +118,20 @@ async function tasksCommand(sessionId, args) {
         return describeTasks(sessionId, now);
     if (first === "stop" && second !== undefined && extra === undefined) {
         await stopTask(sessionId, second);
-        return `已停止 ${second}`;
+        return msg().report.command.taskStopped(second);
     }
     if (second === undefined)
         return describeTaskOutput(sessionId, first, now);
-    throw new AmaError("invalid_arguments", "用法：/tasks [id] | /tasks stop <id>");
+    throw new AmaError("invalid_arguments", msg().report.command.tasksUsage);
 }
 export async function runSlashCommand(line, ctx) {
     const parsed = parseSlash(line);
     if (parsed === undefined)
         return undefined;
     const { name, args } = parsed;
+    const handler = ctx.extra?.[name];
+    if (handler !== undefined)
+        return handler(args, ctx);
     const session = ctx.session();
     switch (name) {
         case "help":
@@ -127,7 +140,10 @@ export async function runSlashCommand(line, ctx) {
             return { kind: "exit" };
         case "new": {
             const next = await ctx.switchSession({ kind: "new" });
-            return { kind: "handled", message: `已新建会话 ${next.state.sessionId.slice(0, 8)}` };
+            return {
+                kind: "handled",
+                message: msg().report.command.newSession(next.state.sessionId.slice(0, 8)),
+            };
         }
         case "resume": {
             if (args === "")
@@ -135,53 +151,64 @@ export async function runSlashCommand(line, ctx) {
             const next = await ctx.switchSession({ kind: "resume", id: args });
             return {
                 kind: "handled",
-                message: `已恢复会话 ${next.state.sessionId.slice(0, 8)}（${next.messages.length} 条消息）`,
+                message: msg().report.command.resumed(next.state.sessionId.slice(0, 8), next.messages.length),
             };
         }
         case "fork": {
             if (args === "")
                 return { kind: "pick", what: "tree" };
             const next = await ctx.switchSession({ kind: "fork", entryId: args });
-            return { kind: "handled", message: `已分叉到新会话 ${next.state.sessionId.slice(0, 8)}` };
+            return {
+                kind: "handled",
+                message: msg().report.command.forked(next.state.sessionId.slice(0, 8)),
+            };
         }
         case "compact": {
             const result = await session.compact(args === "" ? undefined : args);
-            const after = result.tokensAfter !== undefined ? ` → ${result.tokensAfter}` : "";
-            return { kind: "handled", message: `已压缩：${result.tokensBefore}${after} token` };
+            return {
+                kind: "handled",
+                message: msg().report.command.compacted(result.tokensBefore, result.tokensAfter),
+            };
         }
         case "model": {
             if (args === "")
                 return { kind: "pick", what: "model" };
             await session.setModel(args);
             const model = session.state.model;
-            return { kind: "handled", message: `模型：${model?.provider}/${model?.id}` };
+            return {
+                kind: "handled",
+                message: msg().report.command.model(`${model?.provider}/${model?.id}`),
+            };
         }
         case "thinking": {
             if (args === "")
                 return { kind: "pick", what: "thinking" };
             if (!THINKING_LEVELS.includes(args))
-                throw new AmaError("invalid_arguments", `思考级别应为 ${THINKING_LEVELS.join(" | ")}`);
+                throw new AmaError("invalid_arguments", msg().report.command.thinkingInvalid(THINKING_LEVELS));
             session.setThinkingLevel(args);
-            return { kind: "handled", message: `思考级别：${args}` };
+            return { kind: "handled", message: msg().report.command.thinking(args) };
         }
         case "permission": {
             if (args === "")
                 return { kind: "pick", what: "permission" };
             const mode = parsePermissionMode(args);
             if (mode === undefined) {
-                throw new AmaError("invalid_arguments", `权限模式应为 ${PERMISSION_MODE_ORDER.join(" | ")}（也可写显示名，如 "Accept edits"）`);
+                throw new AmaError("invalid_arguments", msg().report.command.permissionInvalid(PERMISSION_MODE_ORDER));
             }
             const current = session.state.permissionMode;
             if (mode !== current && ctx.confirmPermissionMode !== undefined) {
                 if (!(await ctx.confirmPermissionMode(mode))) {
                     return {
                         kind: "handled",
-                        message: `已取消，权限模式仍为 ${permissionModeLabel(current)}`,
+                        message: msg().report.command.permissionCancelled(permissionModeLabel(current)),
                     };
                 }
             }
             session.setPermissionMode(mode);
-            return { kind: "handled", message: `权限模式：${permissionModeLabel(mode)}` };
+            return {
+                kind: "handled",
+                message: msg().report.command.permission(permissionModeLabel(mode)),
+            };
         }
         case "tools": {
             if (args !== "")
@@ -191,13 +218,13 @@ export async function runSlashCommand(line, ctx) {
             const inactive = all.filter((n) => !active.includes(n));
             return {
                 kind: "handled",
-                message: `活动：${active.join(", ") || "（无）"}${inactive.length > 0 ? `\n可用：${inactive.join(", ")}` : ""}`,
+                message: msg().report.command.tools(active, inactive),
             };
         }
         case "hooks": {
             const hooks = ctx.runtime.hooks.list();
             if (hooks.length === 0)
-                return { kind: "handled", message: "没有已加载的 Hook" };
+                return { kind: "handled", message: msg().report.command.noHooks };
             return {
                 kind: "handled",
                 message: hooks
@@ -222,14 +249,18 @@ export async function runSlashCommand(line, ctx) {
             return pasted.ok
                 ? {
                     kind: "handled",
-                    message: `已粘贴图片：${pasted.path}`,
+                    message: msg().report.command.pasted(pasted.path),
                     draft: { text: `${pasted.ref} ` },
                 }
                 : { kind: "handled", message: pasted.message };
         }
         case "statusline":
             // [W5-A] 交互界面在 commands-core 之前自己处理；line 模式没有底部信息行
-            return { kind: "handled", message: "/statusline 只在交互界面可用" };
+            return { kind: "handled", message: msg().report.command.statuslineOnly };
+        case "config":
+        case "trace":
+        case "memory":
+            return { kind: "handled", message: msg().interactive.commands.unavailable(name) };
         default:
             return undefined;
     }

package/dist/modes/image-input.js

@@ -15,7 +15,8 @@ import { resolve } from "node:path";
 import { formatModelRef } from "../ai/providers/channels.js";
 import { AmaError } from "../errors.js";
 import { imageLimits } from "../ai/image-limits.js";
-import { imageMimeFromPath, loadImageFile } from "../tools/image-file.js";
+import { imageMimeFromPath, isImageFileErrorDetail, loadImageFile, } from "../tools/image-file.js";
+import { msg } from "../i18n/index.js";
 const TOKEN = /@?"([^"]+)"|@?'([^']+)'|((?:\\ |\S)+)/g;
 function expand(path, cwd) {
     const home = path === "~" || path.startsWith("~/") ? homedir() + path.slice(1) : path;
@@ -30,7 +31,8 @@ export function findImageRefs(text, cwd) {
         const explicit = m[0].startsWith("@");
         if (m[3] !== undefined && explicit)
             token = token.slice(1);
-        token = token.replace(/\\ /g, " ").replace(/[,，。;；)）]+$/, "");
+        // 结尾标点（含全角，写成转义：输入识别与界面语言无关）
+        token = token.replace(/\\ /g, " ").replace(/[,\uFF0C\u3002;\uFF1B)\uFF09]+$/, "");
         if (token === "" || imageMimeFromPath(token) === undefined)
             continue;
         const path = expand(token, cwd);
@@ -60,9 +62,7 @@ export async function loadPromptImages(refs, model, options = {}) {
     if (wanted.length === 0)
         return [];
     if (!accepts) {
-        const name = model === undefined ? "当前模型" : `${model.provider}/${model.id}`;
-        throw new AmaError("invalid_arguments", `${name} 不接受图片输入（模型 input 没有 image）；换一个支持图像的模型再试` +
-            `（ama models list 里标「图片」的，或在配置里给该模型写 "input": ["text", "image"]）`);
+        throw new AmaError("invalid_arguments", msg().errors.imageUnsupported(model === undefined ? undefined : `${model.provider}/${model.id}`));
     }
     const fit = {
         ...(model !== undefined ? { maxBase64Bytes: imageLimits(model).perImageBase64 } : {}),
@@ -70,7 +70,7 @@ export async function loadPromptImages(refs, model, options = {}) {
     };
     const blocks = [];
     for (const ref of wanted)
-        blocks.push((await loadImageFile(ref.path, fit)).block);
+        blocks.push((await loadLocalized(ref.path, fit)).block);
     return blocks;
 }
 /** 提示 + 额外的显式图片路径（`--image`）→ 附件。 */
@@ -93,3 +93,17 @@ export function imageFitOptionsFor(providers, ref, images) {
     const found = providers.findModel(formatModelRef(ref));
     return found.ok ? { maxBase64Bytes: imageLimits(found.model).perImageBase64, ...resize } : resize;
 }
+/** [W6-C0] `loadImageFile` 的错误固定英文（模型侧模块）；给人看时按 `detail.reason` 换成界面语言。 */
+async function loadLocalized(path, options) {
+    try {
+        return await loadImageFile(path, options);
+    }
+    catch (error) {
+        if (error instanceof AmaError && isImageFileErrorDetail(error.detail))
+            throw new AmaError(error.code, msg().errors.imageFile(error.detail), {
+                detail: error.detail,
+                ...(error.exitCode !== undefined ? { exitCode: error.exitCode } : {}),
+            });
+        throw error;
+    }
+}