@armadra/agent 0.5.1 → 0.6.0

package/dist/modes/session-report.js

@@ -12,6 +12,8 @@
 import { AgentSessionImpl } from "../agent/session.js";
 import { MISS_NOTICE_TOKENS, MISS_NOTICE_USD } from "../ai/cache/miss.js";
 import { KeyValue } from "../tui/components/key-value.js";
+import { quotaParts } from "../auth/chatgpt/quota-text.js";
+import { msg } from "../i18n/index.js";
 const REPORT_WIDTH = 240;
 /** `950`、`38.2k`、`150k`、`1.05M`（比状态栏多一位精度，面板与提示用）。 */
 export function formatTokenCount(count) {
@@ -44,33 +46,28 @@ export function formatDuration(ms) {
     return rest === 0 ? `${minutes}m` : `${minutes}m ${rest}s`;
 }
 export function reportingLabel(reporting) {
-    return reporting === "reported" ? "reported" : reporting === "silent" ? "未报告" : "未知";
+    const m = msg().report.cache;
+    return reporting === "reported" ? "reported" : reporting === "silent" ? m.unreported : m.unknown;
 }
-const REASON_LABELS = {
-    prefix_changed: "前缀变化",
-    model_changed: "切换模型",
-    idle: "空闲超时",
-    subtask: "子任务",
-    evicted: "服务端淘汰",
-};
 /** 未命中原因的短语（提示行括号里那段）。 */
 export function missReasonText(miss) {
     const minutes = Math.max(1, Math.round(miss.idleMs / 60_000));
+    const m = msg().report.cache;
     switch (miss.reason) {
         case "idle":
-            return `空闲 ${minutes} 分钟后`;
+            return m.missIdle(minutes);
         case "subtask":
-            return `子任务运行 ${minutes} 分钟后`;
+            return m.missSubtask(minutes);
         case "model_changed":
-            return "切换模型后";
+            return m.missModel;
         case "prefix_changed":
             return miss.detail === "tools"
-                ? "工具表变化"
+                ? m.missTools
                 : miss.detail === "system"
-                    ? "系统提示变化"
-                    : "前缀变化";
+                    ? m.missSystem
+                    : m.missPrefix;
         case "evicted":
-            return "服务端已淘汰";
+            return m.missEvicted;
     }
 }
 export function shouldNotifyMiss(miss) {
@@ -79,17 +76,17 @@ export function shouldNotifyMiss(miss) {
 }
 /** `缓存未命中（空闲 7 分钟后）：重计费 38.2k token（约 $0.11）`。 */
 export function cacheMissNotice(miss) {
-    const cost = miss.missedCost === undefined ? "" : `（约 ${formatUsd(miss.missedCost)}）`;
-    return `缓存未命中（${missReasonText(miss)}）：重计费 ${formatTokenCount(miss.missedTokens)} token${cost}`;
+    return msg().report.cache.missNotice(missReasonText(miss), formatTokenCount(miss.missedTokens), miss.missedCost === undefined ? undefined : formatUsd(miss.missedCost));
 }
 /** `上下文已用 72%，约剩 9 回合（按最近 5 回合均值）`；估不出回合时给余量 token。 */
 export function contextPressureNotice(event) {
-    const head = `上下文已用 ${Math.round(event.percent)}%`;
+    const m = msg().report.cache;
+    const percent = Math.round(event.percent);
     if (event.estimatedTurnsLeft !== undefined)
-        return `${head}，约剩 ${event.estimatedTurnsLeft} 回合（按最近 5 回合均值）`;
+        return m.pressureTurns(percent, event.estimatedTurnsLeft);
     if (event.remainingTokens !== undefined)
-        return `${head}，余量 ${formatTokenCount(event.remainingTokens)} token`;
-    return head;
+        return m.pressureTokens(percent, formatTokenCount(event.remainingTokens));
+    return m.pressure(percent);
 }
 /**
  * 缓存事件 → 消息区 / stderr 的一行提示；不提示时 undefined。`enabled` = `cache.missNotices`。
@@ -111,67 +108,50 @@ export function cacheEventNotice(event, enabled) {
 export function warmSentNotice(event) {
     if (event.phase !== "sent")
         return undefined;
-    const read = event.usage === undefined ? "" : `读 ${formatTokenCount(event.usage.cacheRead)} token`;
-    const cost = event.cost === undefined ? "" : `${read !== "" ? "，" : ""}${formatUsd(event.cost)}`;
-    return `缓存保温已刷新${read + cost !== "" ? `（${read}${cost}）` : ""}`;
+    return msg().report.cache.warmSent(event.usage === undefined ? undefined : formatTokenCount(event.usage.cacheRead), event.cost === undefined ? undefined : formatUsd(event.cost));
 }
 /** 消息区 / stderr 是否提示未命中与上下文余量（`cache.missNotices`，缺省 true）。 */
 export function cacheNoticesEnabled(session) {
     return session instanceof AgentSessionImpl ? session.cache.cacheSettings.missNotices : true;
 }
-const STOP_REASONS = {
-    retention_none: "缓存保留为 none",
-    payload_replaced: "请求体被 onPayload 替换",
-    thinking_budget: "思考预算随 max_tokens，不可重放",
-    reporting_unknown: "端点还没报过缓存",
-    reporting_silent: "端点不报缓存",
-    no_ttl: "模型目录没有缓存 TTL",
-    ttl_too_short: "缓存 TTL 太短",
-    max_duration: "已达保温时长上限",
-    late: "计时器迟到",
-    off: "已关闭",
-    stale: "上下文已变",
-    declined: "宿主否决",
-    error: "保温请求失败",
-    no_cache_hits: "连续保温零命中",
-    no_price: "缺价格，经济性不可算",
-    below_min_savings: "期望节省低于门槛",
-};
 export function warmStopText(reason) {
+    const m = msg().report.cache;
     if (reason === undefined)
-        return "已停止";
-    return `已停止：${STOP_REASONS[reason] ?? reason}`;
+        return m.stopped;
+    return m.stoppedWith(m.stopReason(reason));
 }
 /** `streaming · 下次 2m 10s · 期望节省 $0.18 ≥ $0.05 · 已发 2 次 $0.01`。 */
 export function warmingText(status, now, minSavingsUsd) {
     if (status.mode === "off")
         return "off";
+    const m = msg().report.cache;
     const parts = [status.mode];
     if (status.state === "scheduled") {
         if (status.nextWarmAt !== undefined)
-            parts.push(`下次 ${formatDuration(status.nextWarmAt - now)}`);
+            parts.push(m.next(formatDuration(status.nextWarmAt - now)));
         if (status.expectedSavingsUsd !== undefined) {
-            const floor = minSavingsUsd === undefined ? "" : ` ≥ ${formatUsd(minSavingsUsd)}`;
-            parts.push(`期望节省 ${formatUsd(status.expectedSavingsUsd)}${floor}`);
+            const floor = minSavingsUsd === undefined ? undefined : formatUsd(minSavingsUsd);
+            parts.push(m.savings(formatUsd(status.expectedSavingsUsd), floor));
         }
     }
     else if (status.state === "stopped")
         parts.push(warmStopText(status.reason));
     else
-        parts.push("待下一次请求");
+        parts.push(m.pending);
     if (status.sent !== undefined && status.sent > 0)
-        parts.push(`已发 ${status.sent} 次 ${formatUsd(status.costUsd)}`);
+        parts.push(m.sent(status.sent, formatUsd(status.costUsd)));
     return parts.join(" · ");
 }
 function missesText(cache) {
+    const m = msg().report.cache;
     if (cache.misses.count === 0)
-        return "0 次";
+        return m.missesNone;
     const by = Object.entries(cache.misses.byReason)
         .filter(([, n]) => n !== undefined && n > 0)
-        .map(([reason, n]) => `${REASON_LABELS[reason] ?? reason} ${n}`)
+        .map(([reason, n]) => `${m.reason(reason) ?? reason} ${n}`)
         .join(" · ");
     const cost = cache.reBilledUsd === undefined ? "$?" : formatUsd(cache.reBilledUsd);
-    return `${cache.misses.count} 次，重计费 ${formatTokenCount(cache.reBilledTokens)} token ≈ ${cost}${by !== "" ? `（${by}）` : ""}`;
+    return m.misses(cache.misses.count, formatTokenCount(cache.reBilledTokens), cost, by);
 }
 /** 缓存段的键值行（`/session` 与 `/cache` 共用）。 */
 export function cacheRows(session, now = Date.now()) {
@@ -179,57 +159,57 @@ export function cacheRows(session, now = Date.now()) {
     const t = stats.tokens;
     const prompt = t.input + t.cacheRead + t.cacheWrite;
     const uncached = t.input + t.cacheWrite;
-    const readShare = prompt > 0 ? `（${formatPercent(t.cacheRead / prompt)}）` : " ";
-    const write = t.cacheWrite > 0 ? `（其中写入 ${formatTokenCount(t.cacheWrite)}）` : "";
+    const m = msg().report.cache;
     const rows = [
         {
-            key: "输入",
-            value: `${formatTokenCount(prompt)} = 缓存读 ${formatTokenCount(t.cacheRead)}${readShare}+ 未缓存 ${formatTokenCount(uncached)}${write}`,
+            key: m.keyInput,
+            value: m.input(formatTokenCount(prompt), formatTokenCount(t.cacheRead), prompt > 0 ? formatPercent(t.cacheRead / prompt) : undefined, formatTokenCount(uncached), t.cacheWrite > 0 ? formatTokenCount(t.cacheWrite) : undefined),
         },
     ];
     const cache = stats.cache;
     if (cache === undefined) {
-        rows.push({ key: "命中率", value: `会话 ${formatPercent(stats.cacheHitRate)}` });
+        rows.push({ key: m.keyHitRate, value: m.sessionRate(formatPercent(stats.cacheHitRate)) });
         return rows;
     }
-    rows.push({ key: "报告状态", value: reportingLabel(cache.reporting) });
+    rows.push({ key: m.keyReporting, value: reportingLabel(cache.reporting) });
     if (cache.reporting === "reported") {
         rows.push({
-            key: "命中率",
-            value: `最近 ${formatPercent(cache.lastHitRate)} · 会话 ${formatPercent(cache.hitRate)}`,
+            key: m.keyHitRate,
+            value: m.rates(formatPercent(cache.lastHitRate), formatPercent(cache.hitRate)),
         });
     }
-    rows.push({ key: "未命中", value: missesText(cache) });
+    rows.push({ key: m.keyMisses, value: missesText(cache) });
     const minSavings = session instanceof AgentSessionImpl ? session.cache.cacheSettings.minSavingsUsd : undefined;
-    rows.push({ key: "保温", value: warmingText(cache.warming, now, minSavings) });
+    rows.push({ key: m.keyWarming, value: warmingText(cache.warming, now, minSavings) });
     if (stats.contextPercent !== undefined) {
-        const remaining = cache.contextRemainingTokens === undefined
-            ? ""
-            : `，余量 ≈ ${formatTokenCount(cache.contextRemainingTokens)} token`;
-        const turns = cache.estimatedTurnsLeft === undefined ? "" : ` ≈ ${cache.estimatedTurnsLeft} 回合`;
-        rows.push({ key: "上下文", value: `${Math.round(stats.contextPercent)}%${remaining}${turns}` });
+        rows.push({
+            key: m.keyContext,
+            value: m.context(Math.round(stats.contextPercent), cache.contextRemainingTokens === undefined
+                ? undefined
+                : formatTokenCount(cache.contextRemainingTokens), cache.estimatedTurnsLeft),
+        });
     }
     if (cache.subagents !== undefined) {
         const sub = cache.subagents;
-        const rebill = sub.reBilledTokens > 0 ? `，重计费 ${formatTokenCount(sub.reBilledTokens)} token` : "";
         rows.push({
-            key: "子任务",
-            value: `${sub.count} 个会话，命中率 ${formatPercent(sub.hitRate)}${rebill}`,
+            key: m.keySubtasks,
+            value: m.subtasks(sub.count, formatPercent(sub.hitRate), sub.reBilledTokens > 0 ? formatTokenCount(sub.reBilledTokens) : undefined),
         });
     }
     return rows;
 }
 /** [W5-U] 外部 Agent 用量一项：美元 / token / 请求数按各自单位，不换算。 */
 export function externalUsageText(usage) {
+    const m = msg().report.session;
     const amount = usage.unit === "usd"
         ? formatUsd(usage.amount)
         : usage.unit === "tokens"
-            ? `${formatTokenCount(usage.amount)} token`
-            : `${usage.amount} 次请求`;
+            ? m.externalTokens(formatTokenCount(usage.amount))
+            : m.externalRequests(usage.amount);
     const tokens = usage.unit !== "tokens" && usage.tokens !== undefined && usage.tokens > 0
-        ? ` · ${formatTokenCount(usage.tokens)} token`
-        : "";
-    return `${usage.runs} 次运行 · ${amount}${tokens}`;
+        ? formatTokenCount(usage.tokens)
+        : undefined;
+    return m.external(usage.runs, amount, tokens);
 }
 /** [W5-U] 「外部 Agent」段（`getStats().external.byAgent`）；没有外部运行时为空。 */
 export function externalRows(session) {
@@ -243,20 +223,34 @@ export function taskStatsText(session) {
     const tasks = session.getStats().tasks;
     if (tasks === undefined || tasks.total === 0)
         return undefined;
-    const parts = [`${tasks.total} 个任务`];
+    const m = msg().report.session;
+    const parts = [m.tasks(tasks.total)];
     if (tasks.running > 0)
-        parts.push(`运行中 ${tasks.running}`);
-    const labels = {
-        completed: "完成",
-        failed: "失败",
-        aborted: "已停止",
-        max_turns: "轮数耗尽",
-        interrupted: "已中断",
-    };
+        parts.push(m.running(tasks.running));
     for (const [status, count] of Object.entries(tasks.byStatus))
         if (count !== undefined && count > 0)
-            parts.push(`${labels[status] ?? status} ${count}`);
-    return `${parts.join(" · ")}（/tasks）`;
+            parts.push(m.status(status, count));
+    return m.tasksLine(parts);
+}
+/** [W6-O] 「订阅用量」段（`getStats().subscription`）：按供应商列请求与 token、缓存只给命中率；附最近配额。 */
+export function subscriptionRows(session, now = Date.now()) {
+    const sub = session.getStats().subscription;
+    if (sub === undefined)
+        return [];
+    const m = msg().auth.report;
+    const rows = Object.entries(sub.byProvider)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([provider, u]) => {
+        const prompt = u.input + u.cacheRead;
+        return {
+            key: provider,
+            value: m.row(u.requests, formatTokenCount(u.input), formatTokenCount(u.output), formatTokenCount(u.cacheRead), formatPercent(prompt > 0 ? u.cacheRead / prompt : undefined)),
+        };
+    });
+    const quota = sub.quota === undefined ? undefined : quotaParts(sub.quota, now);
+    if (quota !== undefined)
+        rows.push({ key: m.quotaKey, value: quota });
+    return rows;
 }
 /** 键值行 → 纯文本（键列对齐、去行尾空白）。 */
 export function renderRows(rows, indent = "") {
@@ -265,7 +259,7 @@ export function renderRows(rows, indent = "") {
         .map((line) => (line === "" ? "" : `${indent}${line}`.replace(/\s+$/, "")));
 }
 export function describeCache(session, now = Date.now()) {
-    return ["缓存", ...renderRows(cacheRows(session, now), "  ")].join("\n");
+    return [msg().report.cache.title, ...renderRows(cacheRows(session, now), "  ")].join("\n");
 }
 export function describeSession(session, now = Date.now()) {
     const state = session.state;
@@ -273,49 +267,51 @@ export function describeSession(session, now = Date.now()) {
     const model = state.model === undefined ? "?" : `${state.model.provider}/${state.model.id}`;
     const t = stats.tokens;
     const percent = stats.contextPercent === undefined ? "?" : `${Math.round(stats.contextPercent)}`;
+    const m = msg().report.session;
     const rows = [
+        { key: m.keySession, value: m.session(state.sessionId, state.sessionFile) },
         {
-            key: "会话",
-            value: `${state.sessionId}${state.sessionFile !== undefined ? `（${state.sessionFile}）` : "（未落盘）"}`,
-        },
-        {
-            key: "模型",
-            value: `${model} · 思考 ${state.thinkingLevel} · 权限 ${state.permissionMode}`,
+            key: m.keyModel,
+            value: m.model(model, state.thinkingLevel, state.permissionMode),
         },
         {
-            key: "消息",
-            value: `用户 ${stats.userMessages} · 助手 ${stats.assistantMessages} · 工具调用 ${stats.toolCalls}`,
+            key: m.keyMessages,
+            value: m.messages(stats.userMessages, stats.assistantMessages, stats.toolCalls),
         },
         {
-            key: "用量",
-            value: `输入 ${t.input} · 输出 ${t.output} · 缓存读 ${t.cacheRead} · 缓存写 ${t.cacheWrite}` +
-                (stats.cost !== undefined ? ` · $${stats.cost.toFixed(4)}` : " · $?"),
+            key: m.keyUsage,
+            value: m.usage(t.input, t.output, t.cacheRead, t.cacheWrite, stats.cost !== undefined ? `$${stats.cost.toFixed(4)}` : "$?"),
         },
         {
-            key: "上下文",
-            value: `${stats.contextTokens ?? "?"} / ${stats.contextWindow ?? "?"}（${percent}%）`,
+            key: m.keyContext,
+            value: m.context(String(stats.contextTokens ?? "?"), String(stats.contextWindow ?? "?"), percent),
         },
     ];
     const tasks = taskStatsText(session);
     if (tasks !== undefined)
-        rows.push({ key: "子 Agent", value: tasks });
+        rows.push({ key: m.keyAgents, value: tasks });
     const external = externalRows(session);
+    const subscription = subscriptionRows(session, now);
     return [
         ...renderRows(rows),
         describeCache(session, now),
-        ...(external.length > 0 ? ["外部 Agent", ...renderRows(external, "  ")] : []),
+        ...(subscription.length > 0
+            ? [msg().auth.report.section, ...renderRows(subscription, "  ")]
+            : []),
+        ...(external.length > 0 ? [m.externalTitle, ...renderRows(external, "  ")] : []),
     ].join("\n");
 }
 /** `/cache fingerprint`：最近一次真实请求的前缀指纹（system / tools 哈希与模型）。 */
 export function describeFingerprint(session) {
+    const m = msg().report.session;
     if (!(session instanceof AgentSessionImpl))
-        return "当前会话不提供前缀指纹";
+        return m.noFingerprint;
     const record = session.cache.lastTurn;
     if (record === undefined)
-        return "还没有真实请求（指纹在第一次请求后记录）";
+        return m.noRequestYet;
     const f = record.fingerprint;
     return [
-        "前缀指纹（最近一次请求）",
+        m.fingerprintTitle,
         ...renderRows([
             { key: "system", value: f.system },
             { key: "tools", value: f.tools },

package/dist/modes/startup-ui-text.js

@@ -6,6 +6,7 @@
  */
 import { existsSync, statSync } from "node:fs";
 import { resolve } from "node:path";
+import { msg } from "../i18n/index.js";
 /** 读一行（不含行尾）；EOF 且无内容返回 undefined。 */
 export function readOneLine(stdin) {
     if (stdin.readableEnded === true)
@@ -61,10 +62,11 @@ export function createTextStartupUi(io) {
     const list = (values, labels) => values.map((_, i) => `  ${i + 1}. ${labels[i]}`);
     return {
         async promptTrust(cwd, resources) {
+            const m = msg().report.startup;
             const shown = resources.slice(0, 6).map((p) => `  ${p}`);
             if (resources.length > shown.length)
-                shown.push(`  …另有 ${resources.length - shown.length} 项`);
-            const answer = await ask([`信任这个目录的项目资源？${cwd}`, ...shown], "[y 仅本次 / a 信任并记住 / N 不信任] ");
+                shown.push(m.more(resources.length - shown.length));
+            const answer = await ask([m.trustQuestion(cwd), ...shown], m.trustChoices);
             const key = answer?.trim().toLowerCase();
             if (key === "a")
                 return { trusted: true, remember: true };
@@ -76,7 +78,8 @@ export function createTextStartupUi(io) {
             const sorted = [...items].sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt));
             const ids = sorted.map((item) => item.id);
             const labels = sorted.map((item) => `${item.id.slice(0, 8)}  ${(item.name ?? item.firstPrompt ?? "").replace(/\s+/g, " ").slice(0, 60)}`);
-            return choose(await ask(["恢复哪个会话？", ...list(ids, labels)], "编号或 id："), ids);
+            const m = msg().report.startup;
+            return choose(await ask([m.resumeQuestion, ...list(ids, labels)], m.resumeAnswer), ids);
         },
         async pickModel(providers, reason) {
             const refs = [];
@@ -85,16 +88,18 @@ export function createTextStartupUi(io) {
                     refs.push(`${provider.id}/${model.id}`);
             if (refs.length === 0)
                 return undefined;
-            const answer = await ask([reason, "选择模型：", ...list(refs, refs)], "编号或 provider/id：");
+            const m = msg().report.startup;
+            const answer = await ask([reason, m.pickModel, ...list(refs, refs)], m.pickModelAnswer);
             return choose(answer, refs);
         },
         async askCwd(missing) {
-            const answer = (await ask([`会话的工作目录不存在：${missing}`], "替代目录（空行取消）："))?.trim();
+            const m = msg().report.startup;
+            const answer = (await ask([m.cwdMissing(missing)], m.cwdAnswer))?.trim();
             if (answer === undefined || answer === "")
                 return undefined;
             const abs = resolve(answer);
             if (!existsSync(abs) || !isDirectory(abs)) {
-                io.write(`不是目录：${abs}\n`);
+                io.write(m.notDirectory(abs));
                 return undefined;
             }
             return abs;

package/dist/permissions/bypass.d.ts

@@ -9,20 +9,18 @@
  */
 import type { PermissionMode } from "./types.js";
 export declare const BYPASS_MODE: PermissionMode;
-export declare const BYPASS_CONFIRM_TITLE = "\u8FDB\u5165 Bypass permissions\uFF1F";
+/** 确认框标题（随界面语言）。 */
+export declare function bypassConfirmTitle(): string;
 /** 确认框正文：Bypass 意味着什么（一两条关键风险）。 */
-export declare const BYPASS_RISK_LINES: readonly string[];
+export declare function bypassRiskLines(): string[];
 /** 选项：缺省选中「取消」。 */
-export declare const BYPASS_CHOICES: readonly [{
-    readonly label: "进入 Bypass";
-    readonly keys: "y";
-}, {
-    readonly label: "取消";
-    readonly keys: "n Esc";
-}];
+export declare function bypassChoices(): {
+    label: string;
+    keys: string;
+}[];
 export declare const BYPASS_DEFAULT_CHOICE = 1;
 /** 行式界面的问句（单键 y/N，缺省 N）。 */
-export declare const BYPASS_LINE_QUESTION = "\u786E\u8BA4\u8FDB\u5165 Bypass\uFF1F[y/N] ";
+export declare function bypassLineQuestion(): string;
 /** 不用问时同步返回 true（切换立即生效）；要问时返回等用户回答的 Promise。 */
 export type BypassGate = (mode: PermissionMode) => boolean | Promise<boolean>;
 /**

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`，大小写不敏感）。
  */