@armadra/agent 0.5.1 → 0.6.0

package/dist/modes/interactive/config-ui.d.ts

@@ -0,0 +1,96 @@
+/**
+ * `/config` controller (docs/wave6-plan.md §6.3, D24-D26). [W6-S]
+ *
+ * - `open("")` shows the panel (config-panel.ts); `open("key=value")` / `open("key value")` sets one key
+ *   in the user config without the panel (same path as `ama config set`).
+ * - Every change is written at once (config/edit.ts) and then applied: keys of the "now" tier go to the
+ *   running session / view (`applySetting`), and `runtime.replaceConfig()` hands the re-merged config to
+ *   `/new`. `defaultModel`, `thinkingLevel` and `permission.mode` also switch the current session.
+ * - `permission.mode: full-auto` in the user config always asks the Bypass confirmation first.
+ * - The first change of a cache-prefix key in a conversation that already has replies shows a notice once
+ *   per panel; closing the panel posts one summary (`from → to (scope)`, plus restart / new-session lists).
+ * - `configCommand()` is the line mode `/config` (`CommandContext.extra.config`).
+ */
+import type { AgentSession } from "../../agent/types.js";
+import type { ModeContext } from "../../cli/deps.js";
+import type { Runtime } from "../../cli/runtime.js";
+import { type ConfigLayerInput } from "../../config/edit.js";
+import type { StatusLineMode } from "../../config/types.js";
+import type { CommandContext, CommandResult } from "../commands-core.js";
+import type { NoticeLevel, ThinkingDisplay } from "./message-view.js";
+import { type PickerHost } from "./pickers.js";
+/** Where "now" settings land in the running UI (every target optional). */
+export interface ConfigApplyTargets {
+    session(): AgentSession;
+    view?: {
+        setOptions(options: {
+            showThinking?: ThinkingDisplay;
+            markdown?: boolean;
+            compact?: boolean;
+        }): void;
+    };
+    loader?: {
+        setAnimation(on: boolean): void;
+    };
+    area?: {
+        setLayout(mode: StatusLineMode): void;
+    };
+    redraw?(): void;
+}
+/** Apply one "now" key to the running session / view; returns false when nothing applies. */
+export declare function applySetting(key: string, value: unknown, targets: ConfigApplyTargets): Promise<boolean>;
+/** Layer inputs of this process: user / project files, the profile and the command line flags. */
+export declare function layerInputFor(runtime: Runtime, context: ModeContext): ConfigLayerInput;
+/** `key=value` / `key value` → [key, raw]. */
+export declare function splitAssignment(args: string): [string, string] | undefined;
+export interface ConfigUiDeps extends PickerHost, ConfigApplyTargets {
+    runtime: Runtime;
+    context: ModeContext;
+    rows(): number;
+    notice(level: NoticeLevel, text: string): void;
+    render(): void;
+    /** Home directory for ~ in paths. */
+    home?: string;
+}
+export declare class ConfigUi {
+    private readonly deps;
+    private panel;
+    private handle;
+    private changes;
+    private prefixNoticeShown;
+    constructor(deps: ConfigUiDeps);
+    private input;
+    /** `/config [key=value]`. */
+    open(args: string): Promise<void>;
+    private close;
+    /** Closing summary (undefined when nothing changed). */
+    summary(): string | undefined;
+    private activate;
+    private pick;
+    private commitText;
+    /**
+     * Write one key and apply it. Errors become panel notices (or are rethrown with `rethrow`, for the
+     * inline editor). Returns the edit result, undefined when refused / cancelled.
+     */
+    private write;
+    private afterWrite;
+    /** `/config key=value`: user scope, no panel. */
+    private direct;
+}
+/** Line mode `/config`: no args lists the settings, `key=value` sets one (user scope). */
+export declare function configCommand(runtime: Runtime, context: ModeContext): (args: string, ctx: CommandContext) => Promise<CommandResult>;
+/** Wiring for interactive-mode.ts (one line there): the session follows `/new` `/resume` `/fork`. */
+export declare function configUiFor(host: PickerHost & {
+    rows(): number;
+}, parts: {
+    runtime: Runtime;
+    context: ModeContext;
+    view: NonNullable<ConfigApplyTargets["view"]>;
+    loader: NonNullable<ConfigApplyTargets["loader"]>;
+    area: NonNullable<ConfigApplyTargets["area"]>;
+    tui: {
+        forceFullRedraw(): void;
+        requestRender(): void;
+    };
+    notice(level: NoticeLevel, text: string): void;
+}): ConfigUi;

package/dist/modes/interactive/config-ui.js

@@ -0,0 +1,397 @@
+/**
+ * `/config` controller (docs/wave6-plan.md §6.3, D24-D26). [W6-S]
+ *
+ * - `open("")` shows the panel (config-panel.ts); `open("key=value")` / `open("key value")` sets one key
+ *   in the user config without the panel (same path as `ama config set`).
+ * - Every change is written at once (config/edit.ts) and then applied: keys of the "now" tier go to the
+ *   running session / view (`applySetting`), and `runtime.replaceConfig()` hands the re-merged config to
+ *   `/new`. `defaultModel`, `thinkingLevel` and `permission.mode` also switch the current session.
+ * - `permission.mode: full-auto` in the user config always asks the Bypass confirmation first.
+ * - The first change of a cache-prefix key in a conversation that already has replies shows a notice once
+ *   per panel; closing the panel posts one summary (`from → to (scope)`, plus restart / new-session lists).
+ * - `configCommand()` is the line mode `/config` (`CommandContext.extra.config`).
+ */
+import { AgentSessionImpl } from "../../agent/session.js";
+import { currentSession } from "../../cli/compose-session.js";
+import { hideFakeProvider } from "../../cli/fake-visibility.js";
+import { tildePath } from "../../cli/startup-screen.js";
+import { ConfigEditError, formatSettingValue, getConfigValue, parseValue, readSnapshot, setConfigValue, } from "../../config/edit.js";
+import { loadProfile } from "../../config/profile.js";
+import { settingSpec, settingsRegistry } from "../../config/settings-registry.js";
+import { msg } from "../../i18n/index.js";
+import { ConfigPanel, blockedReason } from "./config-panel.js";
+import { bypassChoiceSpec, openChoice } from "./confirm-dialog.js";
+import { modelItems, openPicker, permissionItems, thinkingItems, } from "./pickers.js";
+/** Apply one "now" key to the running session / view; returns false when nothing applies. */
+export async function applySetting(key, value, targets) {
+    const session = targets.session();
+    const impl = session instanceof AgentSessionImpl ? session : undefined;
+    switch (key) {
+        case "ui.markdown":
+            targets.view?.setOptions({ markdown: value !== false });
+            break;
+        case "ui.showThinking":
+            targets.view?.setOptions({ showThinking: (value ?? "collapsed") });
+            break;
+        case "ui.compact":
+            targets.view?.setOptions({ compact: value === true });
+            break;
+        case "ui.animation":
+            targets.loader?.setAnimation(value !== false);
+            break;
+        case "ui.statusLine":
+            targets.area?.setLayout((value ?? "full"));
+            break;
+        case "thinkingLevel":
+            session.setThinkingLevel((value ?? "medium"));
+            return true;
+        case "permission.mode":
+            session.setPermissionMode((value ?? "default"));
+            return true;
+        case "defaultModel":
+            if (typeof value !== "string")
+                return false;
+            await session.setModel(value);
+            return true;
+        case "compaction.enabled":
+            impl?.setAutoCompaction(value !== false);
+            return impl !== undefined;
+        case "retry.enabled":
+            impl?.setAutoRetry(value !== false);
+            return impl !== undefined;
+        case "cache.warming":
+            if (typeof value === "string")
+                impl?.cache.setWarming(value);
+            return impl !== undefined;
+        default:
+            return false;
+    }
+    targets.redraw?.();
+    return true;
+}
+/** Layer inputs of this process: user / project files, the profile and the command line flags. */
+export function layerInputFor(runtime, context) {
+    const { args, io } = context;
+    const cli = {};
+    if (args.thinking !== undefined)
+        cli.thinkingLevel = args.thinking;
+    if (args.permissionMode !== undefined)
+        cli.permissionMode = args.permissionMode;
+    if (args.allow.length > 0)
+        cli.allow = args.allow;
+    if (args.deny.length > 0)
+        cli.deny = args.deny;
+    if (args.quietStartup !== undefined)
+        cli.quietStartup = args.quietStartup;
+    if (args.tuiMode !== undefined)
+        cli.tuiMode = args.tuiMode;
+    if (args.toolsPreset !== undefined)
+        cli.toolsPreset = args.toolsPreset;
+    if (args.codemode !== undefined)
+        cli.codemode = args.codemode;
+    if (args.memory !== undefined)
+        cli.memory = args.memory;
+    const input = {
+        configDir: runtime.paths.configDir,
+        cwd: runtime.paths.cwd,
+        env: io.env,
+        cli,
+    };
+    if (args.profile !== undefined) {
+        input.profile = { config: loadProfile(args.profile, io.cwd).config };
+        input.hasProfile = true;
+    }
+    return input;
+}
+/** `key=value` / `key value` → [key, raw]. */
+export function splitAssignment(args) {
+    const text = args.trim();
+    const eq = text.indexOf("=");
+    const space = text.search(/\s/);
+    const at = eq !== -1 && (space === -1 || eq < space) ? eq : space;
+    if (at <= 0)
+        return undefined;
+    return [text.slice(0, at).trim(), text.slice(at + 1).trim()];
+}
+const PROJECT_FILE = ".ama/config.json";
+const labelOf = (key) => msg().settings.labels[key] ?? key;
+const hasReplies = (session) => session.messages.some((m) => m.role === "assistant");
+export class ConfigUi {
+    deps;
+    panel;
+    handle;
+    changes = new Map();
+    prefixNoticeShown = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    input() {
+        return layerInputFor(this.deps.runtime, this.deps.context);
+    }
+    /** `/config [key=value]`. */
+    async open(args) {
+        if (args.trim() !== "")
+            return this.direct(args);
+        if (this.panel !== undefined)
+            return;
+        const snapshot = readSnapshot(this.input());
+        const home = this.deps.home;
+        this.changes = new Map();
+        this.prefixNoticeShown = false;
+        const panel = new ConfigPanel(snapshot, {
+            theme: this.deps.theme,
+            ...(this.deps.keybindings !== undefined ? { keybindings: this.deps.keybindings } : {}),
+            rows: () => this.deps.rows(),
+            // project file is always <cwd>/.ama/config.json; forward slashes on every platform
+            paths: {
+                user: tildePath(snapshot.userPath, home).replace(/\\/g, "/"),
+                project: PROJECT_FILE,
+            },
+            embedded: this.input().hasProfile === true,
+            activate: (key, scope) => this.activate(key, scope),
+            unset: (key, scope) => this.write(key, undefined, scope).then(() => undefined),
+            commit: (key, text, scope) => this.commitText(key, text, scope),
+            close: () => this.close(),
+            requestRender: () => this.deps.render(),
+        });
+        this.panel = panel;
+        this.handle = this.deps.showOverlay(panel, { anchor: "bottom" });
+        this.deps.render();
+    }
+    close() {
+        this.handle?.hide();
+        this.handle = undefined;
+        this.panel = undefined;
+        const summary = this.summary();
+        if (summary !== undefined)
+            this.deps.notice("info", summary);
+        this.deps.render();
+    }
+    /** Closing summary (undefined when nothing changed). */
+    summary() {
+        const s = msg().settings;
+        const changed = [...this.changes.values()].filter((c) => c.from !== c.to);
+        if (changed.length === 0)
+            return undefined;
+        const lines = [s.summaryTitle];
+        for (const c of changed)
+            lines.push(`  ${s.summaryLine(labelOf(c.key), c.from, c.to, s.scope[c.scope])}`);
+        const tier = (apply) => changed
+            .filter((c) => c.spec?.apply === apply)
+            .map((c) => labelOf(c.key))
+            .join(", ");
+        if (tier("restart") !== "")
+            lines.push(s.summaryRestart(tier("restart")));
+        if (tier("nextSession") !== "")
+            lines.push(s.summaryNextSession(tier("nextSession")));
+        return lines.join("\n");
+    }
+    async activate(key, scope) {
+        const panel = this.panel;
+        const spec = settingSpec(key);
+        if (panel === undefined || spec === undefined)
+            return;
+        const current = getConfigValue(readSnapshot(this.input()), key);
+        const blocked = blockedReason(spec, current, scope);
+        if (blocked !== undefined)
+            return panel.setNotice(blocked, "warning");
+        const value = current.value;
+        switch (spec.kind) {
+            case "bool":
+                await this.write(key, value !== true, scope);
+                return;
+            case "enum": {
+                const options = spec.options ?? [];
+                if (options.length <= 4) {
+                    const next = options[(options.indexOf(String(value)) + 1) % options.length];
+                    await this.write(key, next, scope);
+                    return;
+                }
+                const picked = await this.pick(spec, value);
+                if (picked !== undefined)
+                    await this.write(key, picked === "" ? undefined : picked, scope);
+                return;
+            }
+            case "model": {
+                const picked = await this.pick(spec, value);
+                if (picked !== undefined)
+                    await this.write(key, picked === "" ? undefined : picked, scope);
+                return;
+            }
+            default:
+                panel.startEdit(key, value === undefined ? "" : formatSettingValue(value));
+        }
+    }
+    async pick(spec, value) {
+        const s = msg().settings;
+        const current = typeof value === "string" ? value : undefined;
+        let items;
+        if (spec.key === "permission.mode")
+            items = permissionItems((current ?? "default"));
+        else if (spec.key.endsWith("thinkingLevel"))
+            items = thinkingItems(true);
+        else if (spec.kind === "model")
+            items = [
+                ...(await modelItems(hideFakeProvider(this.deps.runtime.providers, this.deps.context.io.env))),
+                { value: "", label: s.defaultChoice },
+            ];
+        else
+            items = (spec.options ?? []).map((o) => ({ value: o, label: o }));
+        const picked = await openPicker(this.deps, {
+            title: s.pickTitle(labelOf(spec.key)),
+            items,
+            filterable: spec.kind === "model",
+            ...(current !== undefined ? { selected: current, currentValue: current } : {}),
+            ...(spec.key === "permission.mode" ? { stacked: true } : {}),
+        });
+        return picked?.value;
+    }
+    async commitText(key, text, scope) {
+        try {
+            await this.write(key, parseValue(key, text), scope, true);
+            return undefined;
+        }
+        catch (error) {
+            return error instanceof Error ? error.message : String(error);
+        }
+    }
+    /**
+     * Write one key and apply it. Errors become panel notices (or are rethrown with `rethrow`, for the
+     * inline editor). Returns the edit result, undefined when refused / cancelled.
+     */
+    async write(key, value, scope, rethrow = false) {
+        const s = msg().settings;
+        if (key === "permission.mode" && value === "full-auto" && scope === "user") {
+            const spec = bypassChoiceSpec(this.deps.theme);
+            const body = [...spec.body, this.deps.theme.fg("warning", s.bypassPersist)];
+            if ((await openChoice(this.deps, { ...spec, body })) !== 0)
+                return undefined;
+        }
+        let result;
+        try {
+            result = setConfigValue({ ...this.input(), scope, key, value });
+        }
+        catch (error) {
+            if (rethrow)
+                throw error;
+            const text = error instanceof Error ? error.message : String(error);
+            if (this.panel !== undefined)
+                this.panel.setNotice(text, "error");
+            else
+                this.deps.notice("error", text);
+            return undefined;
+        }
+        await this.afterWrite(result);
+        return result;
+    }
+    async afterWrite(result) {
+        const s = msg().settings;
+        const spec = settingSpec(result.key);
+        const from = formatSettingValue(result.before.value);
+        const to = formatSettingValue(result.after.value);
+        const previous = this.changes.get(result.key);
+        this.changes.set(result.key, {
+            key: result.key,
+            from: previous?.from ?? from,
+            to,
+            scope: result.scope,
+            spec,
+        });
+        this.deps.runtime.replaceConfig?.(result.snapshot.config);
+        let warning;
+        if (result.apply === "now" && result.before.value !== result.after.value)
+            await applySetting(result.key, result.after.value, this.deps).catch((error) => {
+                warning = error instanceof Error ? error.message : String(error);
+            });
+        if (result.overriddenBy !== undefined)
+            warning ??= s.stillOverridden(result.key, result.after.envName ?? result.overriddenBy);
+        if (result.prefixChanged && !this.prefixNoticeShown && hasReplies(this.deps.session())) {
+            this.prefixNoticeShown = true;
+            warning ??= s.prefixNotice;
+        }
+        if (this.panel !== undefined) {
+            this.panel.refresh(result.snapshot);
+            this.panel.setNotice(warning, "warning");
+        }
+        else {
+            const line = s.setDone(result.key, to, s.scope[result.scope]);
+            this.deps.notice(warning === undefined ? "info" : "warn", warning === undefined ? line : `${line}\n${warning}`);
+        }
+        this.deps.render();
+    }
+    /** `/config key=value`: user scope, no panel. */
+    async direct(args) {
+        const s = msg().settings;
+        const parts = splitAssignment(args);
+        if (parts === undefined || parts[1] === "")
+            return this.deps.notice("warn", s.slashUsage);
+        try {
+            const value = parseValue(parts[0], parts[1]);
+            await this.write(parts[0], value, "user", true);
+        }
+        catch (error) {
+            const text = error instanceof Error ? error.message : String(error);
+            this.deps.notice(error instanceof ConfigEditError ? "warn" : "error", text);
+        }
+    }
+}
+/** Line mode `/config`: no args lists the settings, `key=value` sets one (user scope). */
+export function configCommand(runtime, context) {
+    return async (args, ctx) => {
+        const s = msg().settings;
+        const input = layerInputFor(runtime, context);
+        if (args.trim() === "") {
+            const snapshot = readSnapshot(input);
+            const lines = settingsRegistry().map((spec) => {
+                const value = getConfigValue(snapshot, spec.key);
+                return `  ${spec.key} = ${formatSettingValue(value.value)}  ${value.envName ?? value.source}`;
+            });
+            return { kind: "handled", message: [s.cli.listHeader, ...lines].join("\n") };
+        }
+        const parts = splitAssignment(args);
+        if (parts === undefined || parts[1] === "")
+            return { kind: "handled", message: s.slashUsage };
+        try {
+            const value = parseValue(parts[0], parts[1]);
+            if (parts[0] === "permission.mode" && value === "full-auto") {
+                const confirmed = ctx.confirmPermissionMode === undefined
+                    ? false
+                    : await ctx.confirmPermissionMode("full-auto");
+                if (!confirmed)
+                    return { kind: "handled", message: s.cli.needYes };
+            }
+            const result = setConfigValue({ ...input, scope: "user", key: parts[0], value });
+            runtime.replaceConfig?.(result.snapshot.config);
+            if (result.apply === "now" && result.before.value !== result.after.value)
+                await applySetting(result.key, result.after.value, { session: () => ctx.session() });
+            const lines = [s.setDone(result.key, formatSettingValue(result.after.value), s.scope.user)];
+            if (result.overriddenBy !== undefined)
+                lines.push(s.stillOverridden(result.key, result.after.envName ?? result.overriddenBy));
+            return { kind: "handled", message: lines.join("\n") };
+        }
+        catch (error) {
+            if (error instanceof ConfigEditError)
+                return { kind: "handled", message: error.message };
+            throw error;
+        }
+    };
+}
+/** Wiring for interactive-mode.ts (one line there): the session follows `/new` `/resume` `/fork`. */
+export function configUiFor(host, parts) {
+    const { runtime, context, tui } = parts;
+    const env = context.io.env;
+    const home = env["HOME"] ?? env["USERPROFILE"];
+    return new ConfigUi({
+        ...host,
+        runtime,
+        context,
+        view: parts.view,
+        loader: parts.loader,
+        area: parts.area,
+        session: () => currentSession(runtime),
+        notice: parts.notice,
+        render: () => tui.requestRender(),
+        redraw: () => tui.forceFullRedraw(),
+        ...(home !== undefined ? { home } : {}),
+    });
+}

package/dist/modes/interactive/confirm-dialog.js

@@ -8,7 +8,8 @@
  *
  * 用途：进入 Bypass permissions 前的确认（`confirmBypass`，permissions/bypass.ts）。
  */
-import { BYPASS_CHOICES, BYPASS_CONFIRM_TITLE, BYPASS_DEFAULT_CHOICE, BYPASS_RISK_LINES, } from "../../permissions/bypass.js";
+import { msg } from "../../i18n/index.js";
+import { BYPASS_DEFAULT_CHOICE, bypassChoices, bypassConfirmTitle, bypassRiskLines, } from "../../permissions/bypass.js";
 import { Box, defaultKeybindings, matchesKey, padToWidth, truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "../../tui.js";
 /** 宽度低于它（Box 外宽）时用紧凑布局。 */
 const COMPACT_WIDTH = 56;
@@ -64,9 +65,7 @@ export class ChoiceDialog {
         const g = theme.glyphs;
         const arrows = g.arrowUp + g.arrowDown;
         const n = this.spec.options.length;
-        lines.push(theme.fg("dim", compact
-            ? `${arrows} Enter · 1-${n} · Esc`
-            : `${arrows} 选择 · Enter 确认 · 1-${n} 直接选 · Esc 取消`));
+        lines.push(theme.fg("dim", compact ? `${arrows} Enter · 1-${n} · Esc` : msg().approval.choiceHint(arrows, n)));
         return lines.map((l) => truncateToWidth(l, width));
     }
     optionLines(width, compact) {
@@ -108,9 +107,9 @@ export function openChoice(host, spec) {
 /** Bypass 确认框的内容（缺省选中「取消」，边框 warning）。 */
 export function bypassChoiceSpec(theme) {
     return {
-        title: BYPASS_CONFIRM_TITLE,
-        body: BYPASS_RISK_LINES.map((line, i) => (i === 0 ? theme.fg("warning", line) : line)),
-        options: BYPASS_CHOICES,
+        title: bypassConfirmTitle(),
+        body: bypassRiskLines().map((line, i) => (i === 0 ? theme.fg("warning", line) : line)),
+        options: bypassChoices(),
         selected: BYPASS_DEFAULT_CHOICE,
         borderColor: "warning",
     };

package/dist/modes/interactive/event-notices.js

@@ -5,11 +5,12 @@
  *   合并成一条「已省略 N 张早期图片以符合请求上限」，N 按占位文本数；
  * - W5-H1：`compaction_end.error` 的「compaction did not shrink」换成中文说明（其余错误原样）。
  */
+import { msg } from "../../i18n/index.js";
 import { IMAGE_OMITTED_FOR_BUDGET, IMAGE_OMITTED_TOO_LARGE, } from "../../compaction/image-budget.js";
 /** `compaction_end.error` 的显示文本。 */
 export function compactionErrorText(error) {
     if (/compaction did not shrink/i.test(error)) {
-        return "压缩后上下文没有变小，已保留原对话（不写摘要）";
+        return msg().interactive.events.compactionNoShrink;
     }
     return error;
 }
@@ -43,7 +44,7 @@ export class ImageBudgetNotices {
             const n = this.pending;
             this.pending = 0;
             this.scheduled = false;
-            this.notify(`已省略 ${n} 张早期图片以符合请求上限`);
+            this.notify(msg().interactive.events.imagesOmitted(n));
         });
     }
 }
@@ -54,26 +55,27 @@ export class ImageBudgetNotices {
 export const LIMIT_WARNING = "limit_reached";
 /** `limit_reached`：回合 / 费用到限（每次运行每类一次）。 */
 export function limitReachedText(event) {
+    const m = msg().interactive.events;
     if (event.kind === "turns")
-        return `已到回合上限（${event.limit} 回合），本次运行停止；发新消息继续（--max-turns / limits.maxTurns）`;
-    const spent = `$${event.value.toFixed(2)}`;
-    return `已到费用上限 $${event.limit.toFixed(2)}（本次运行已用 ${spent}），本次运行停止；发新消息继续（--max-cost / limits.maxCostUsd）`;
+        return m.limitTurns(event.limit);
+    return m.limitCost(`$${event.limit.toFixed(2)}`, `$${event.value.toFixed(2)}`);
 }
 /** `model_fallback`：主模型失败后改用回退模型重试一次。 */
 export function modelFallbackText(event) {
     const ref = (m) => `${m.provider}/${m.id}`;
-    return `${ref(event.from)} 不可用（${event.reason}），本次请求改用 ${ref(event.to)}，回复后切回`;
+    return msg().interactive.events.modelFallback(ref(event.from), event.reason, ref(event.to));
 }
 /** `background_job`：后台命令启动 / 退出 / 停止。 */
 export function backgroundJobText(event) {
     const command = event.command.replace(/\s+/g, " ").trim();
     const short = command.length > 60 ? `${command.slice(0, 59)}…` : command;
+    const m = msg().interactive.events;
     switch (event.phase) {
         case "started":
-            return `后台命令 ${event.jobId} 已启动：${short}`;
+            return m.backgroundStarted(event.jobId, short);
         case "exited":
-            return `后台命令 ${event.jobId} 已退出（码 ${event.exitCode ?? "?"}）：${short}`;
+            return m.backgroundExited(event.jobId, String(event.exitCode ?? "?"), short);
         case "stopped":
-            return `后台命令 ${event.jobId} 已停止：${short}`;
+            return m.backgroundStopped(event.jobId, short);
     }
 }

package/dist/modes/interactive/interactive-mode.d.ts

@@ -24,7 +24,7 @@ import type { ModeContext } from "../../cli/deps.js";
 import type { Runtime } from "../../cli/runtime.js";
 import type { StatusLineMode } from "../../config/types.js";
 import type { ClipboardDeps } from "../../tools/clipboard-image.js";
-import { Editor, Keybindings, TUI, type Terminal, type Theme } from "../../tui.js";
+import { Editor, TUI, type Keybindings, type Terminal, type Theme } from "../../tui.js";
 import { MessageView } from "./message-view.js";
 import { StatusArea } from "./status-area.js";
 import type { StatusBar } from "./status-bar.js";