@ai-zen/cli 1.0.0-alpha.20 → 1.0.0-alpha.22

package/dist/tui/screens/chat-commands.js

@@ -1,17 +1,22 @@
 import { AgentNS } from "@ai-zen/agents-core";
+import { HandoffAbortedError } from "@ai-zen/agents-sdk";
 import { spawnSync } from "node:child_process";
 import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { stripCwdNote } from "../chat-session.js";
-import { matchCommandHints } from "../../conversation-commands/registry.js";
+import { canonicalCommandName, matchCommandHints, parseCommandArgs, } from "../../conversation-commands/registry.js";
 import { conversationRepository, listConversations } from "../../conversation-repository.js";
 import { formatShortTime } from "../../format-time.js";
-import { readConfig, readReasoningPresets } from "../../config.js";
+import { readConfig, readMcpConfig, readReasoningPresets, saveConfig } from "../../config.js";
 import { resetScope } from "../../agent-creator.js";
 import { switchModel } from "../../model-switch.js";
-import { effortChoices, effortLabel, describeEffort, setAgentEffort, } from "../../reasoning-effort.js";
+import { listAgentChoices, switchAgent } from "../../agent-switch.js";
+import { parseMcpScope, pickStartScope } from "../../mcp-command.js";
+import { effortChoices, effortLabel, describeEffort, describeEffortView, setAgentEffort, } from "../../reasoning-effort.js";
 import { matchLevel, presetFor } from "../../reasoning-presets.js";
+import { getLocale, t } from "../../i18n/index.js";
+import { persistLocale } from "../../i18n/preferences.js";
 import { readAgentStore } from "../../agents-store.js";
 import { truncate } from "./render.js";
 import { chooseHandoffMode } from "./handoff-choice.js";
@@ -23,341 +28,475 @@ export function parseHandoffMode(raw) {
     const value = raw?.trim().toLowerCase();
     return value === "self" || value === "summary" ? value : undefined;
 }
-export async function runCommand(name, raw, host) {
-    const { session, notice, clearTranscript, rows, exit, suspendTerminal, openWizard, openKeyEditor, doExit, setPickerState, setInputText, setEffortText, } = host;
-    const push = (text, tone = "info") => {
-        notice(text, tone);
-    };
-    // 命令参数：首个 token 为命令名，其余为参数（如 `/migrate summary`）
-    const args = raw.trim().split(/\s+/).slice(1);
-    const modeArg = args[0]?.toLowerCase();
-    const mode = parseHandoffMode(modeArg);
-    const invalidMode = modeArg !== undefined && mode === undefined;
-    switch (name) {
-        case "config":
-            await openWizard({ kind: "menu" });
-            break;
-        case "key":
-            await openKeyEditor();
-            break;
-        case "model": {
-            const config = await readConfig();
-            const models = config.models ?? [];
-            if (models.length === 0) {
-                push("配置里还没有任何模型，请用 /config 添加端点与模型", "error");
-                break;
-            }
-            // 支持 `/model <id>` 直切，无参时弹选择器
-            let chosen = args[0];
-            if (chosen && !models.some((model) => model.id === chosen)) {
-                push(`未知模型：${chosen}（可选：${models.map((m) => m.id).join(" / ")}）`, "error");
-                break;
-            }
-            if (!chosen) {
-                const items = models.map((model) => ({
-                    label: model.id === session.modelId ? `${model.name}（当前）` : model.name,
-                    value: model.id,
-                    hint: model.id,
-                }));
-                const picked = await new Promise((resolve) => setPickerState({ title: "切换模型（会写入配置）", items, resolve }));
-                if (picked == null) {
-                    push("已取消切换模型");
-                    break;
-                }
-                chosen = picked;
-            }
-            if (chosen === session.modelId) {
-                push(`已经是当前模型：${chosen}`);
-                break;
-            }
-            // 先确认目标模型可用：重挂载走的是 ChatSession.create → createModel，
-            // 端点缺 Key 会直接抛错落到启动错误屏，用户连 /key 都进不去
-            const targetModel = models.find((model) => model.id === chosen);
-            const targetEndpoint = (config.endpoints ?? []).find((endpoint) => endpoint.id === targetModel.endpointId);
-            if (!targetEndpoint) {
-                push(`模型 ${chosen} 引用的端点 ${targetModel.endpointId} 不存在，请用 /config 检查`, "error");
-                break;
-            }
-            if (!targetEndpoint.apiKey) {
-                push(`端点「${targetEndpoint.name}」还没有 API Key，请先用 /config 配置后再切换`, "error");
-                break;
-            }
-            try {
-                // 只写 Agent 定义（模型唯一真相源）
-                const result = await switchModel({ config, agentId: session.agentId, modelId: chosen });
-                // Scope 持有配置快照：不重建的话 getScope() 会把旧模型又交给新 Agent
-                await resetScope();
-                // 重挂载对话屏：模型变了要重算上下文阈值、重建 Agent；消息与上下文保留
-                exit({
-                    restart: true,
-                    agentId: session.agentId,
-                    messages: session.messages,
-                    notice: result.summary,
-                });
-            }
-            catch (error) {
-                push(`切换模型失败：${error?.message ?? error}`, "error");
-            }
-            break;
-        }
-        case "think":
-        case "effort": {
-            const config = await readConfig();
-            const presets = await readReasoningPresets();
-            const store = await readAgentStore();
-            const definition = store.agents.find((item) => item.id === session.agentId) ?? null;
-            const modelId = definition?.modelId;
-            if (!modelId) {
-                push(`Agent「${session.agentId}」未绑定模型，请用 /config 为它选择模型`, "error");
-                break;
-            }
-            const model = (config.models ?? []).find((item) => item.id === modelId);
-            if (!model) {
-                push(`模型 ${modelId} 不存在，请用 /model 或 /config 检查`, "error");
-                break;
-            }
-            const choices = effortChoices(model, presets);
-            if (choices.length === 0) {
-                push(`模型 ${model.id} 未关联可用的思考策略（缺 reasoningPreset，或策略表里没这一档），无法调整`, "error");
-                break;
-            }
-            // 支持 `/think high` 直设、`/think default` 恢复跟随模型默认，无参时弹选择器
-            let picked = args[0];
-            if (picked !== undefined && picked !== "default" && !choices.includes(picked)) {
-                push(`未知强度：${picked}（可选 ${choices.join(" / ")} / default）`, "error");
-                break;
-            }
-            if (!picked) {
-                // 「当前」指 Agent 定义上真正写着的那一档（模型默认参数不算，那是跟随状态）
-                const current = matchLevel(presetFor(model.id, model.reasoningPreset, presets), definition?.modelParams);
-                const items = [
-                    {
-                        label: `跟随模型默认${current ? "" : "（当前）"}`,
-                        value: "default",
-                        hint: "删除 Agent 上的思考参数",
-                    },
-                    ...choices.map((value) => ({
-                        label: `${effortLabel(value)}${value === current ? "（当前）" : ""}`,
-                        value,
-                        hint: value,
-                    })),
-                ];
-                const choice = await new Promise((resolve) => setPickerState({
-                    title: `思考强度（当前：${describeEffort(model, presets, definition)}）`,
-                    items,
-                    resolve,
-                }));
-                if (choice == null) {
-                    push("已取消切换思考强度");
-                    break;
-                }
-                picked = choice;
-            }
-            const effort = picked === "default" ? null : picked;
-            const agentLevel = matchLevel(presetFor(model.id, model.reasoningPreset, presets), definition?.modelParams);
-            const unchanged = effort === null ? agentLevel === undefined : agentLevel === effort;
-            if (unchanged) {
-                push("思考强度未变化");
-                break;
-            }
-            try {
-                const result = await setAgentEffort({
-                    config,
-                    presets,
-                    agentId: session.agentId,
-                    effort,
-                    // 已读过定义，避免命令层与写入层各读一次盘
-                    readAgent: async () => definition,
-                });
-                // 状态栏先跟上；档位要通过重建 Agent 才会进请求参数
-                setEffortText(describeEffort(result.model, presets, result.definition));
-                await session.reload();
-                push(result.summary);
-            }
-            catch (error) {
-                push(`切换思考强度失败：${error?.message ?? error}`, "error");
-            }
-            break;
-        }
-        case "help": {
-            const lines = ["可用命令："];
-            for (const hint of matchCommandHints("")) {
-                lines.push(`  ${hint.label}  ${hint.description}`);
-            }
-            push(lines.join("\n"));
-            break;
-        }
-        case "clear":
-            // 清屏但保留上下文：仅把转录显示起点推到最新
-            clearTranscript();
-            break;
-        case "new": {
-            // reset 会先归档当前对话（有内容才存），返回存档 id（无内容为 null）
-            const archivedId = await session.reset();
-            clearTranscript();
-            push(archivedId ? `旧对话已存档：${archivedId}\n已开始新对话` : "已开始新对话");
-            break;
+/**
+ * 解析 `/handoff` `/migrate` 的执行者参数。
+ *
+ * 单独成函数而不是挂在 `CommandContext` 上：16 个命令里只有这两个用得到，
+ * 挂在上下文中会让另外 14 个命令（`/save` `/help` `/clear` …）每次也白算一遍。
+ */
+export function parseHandoffSelection(args) {
+    const raw = args[0]?.toLowerCase();
+    const mode = parseHandoffMode(raw);
+    return { mode, invalid: raw !== undefined && mode === undefined ? raw : undefined };
+}
+// ==================== 各命令 ====================
+const cmdSave = async ({ session, push }) => {
+    try {
+        const id = await session.save();
+        push(t("cmd.save.done", { id }));
+    }
+    catch (error) {
+        push(t("cmd.save.failed", { error: error?.message ?? error }), "error");
+    }
+};
+const cmdLoad = async ({ push, rows, exit, pick }) => {
+    // 先算可见条数：摘要只为将要显示的那几条解析（会话多时不拖慢 /load）
+    const maxItems = Math.max(1, (rows ?? 24) - 8);
+    const list = await listConversations({ previewLimit: maxItems });
+    if (list.length === 0) {
+        push(t("cmd.load.none"), "error");
+        return;
+    }
+    const allItems = list.map((c) => ({
+        // 有首条消息就用它当标签：纯时间戳 id 根本分不清哪条是哪条
+        label: c.preview || c.name,
+        value: c.id,
+        hint: formatShortTime(c.updatedAt),
+    }));
+    // 覆盖层不能高于终端：仅展示最近的有限条
+    const items = allItems.slice(0, maxItems);
+    const title = allItems.length > maxItems ? t("cmd.load.tooMany", { n: maxItems }) : t("cmd.load.titleReplacing");
+    const choice = await pick(title, items);
+    if (choice == null) {
+        push(t("cmd.load.cancelled"));
+        return;
+    }
+    const conversation = await conversationRepository.read(choice);
+    if (!conversation) {
+        push(t("cmd.load.readFailed", { id: choice }), "error");
+        return;
+    }
+    // 整体切换会话（含模型 / Agent）——交由上层重挂载对话屏
+    exit({
+        load: {
+            agentId: conversation.agentId,
+            messages: conversation.messages,
+            conversationId: conversation.id,
+            conversationName: conversation.id,
+        },
+    });
+};
+const cmdNew = async ({ session, clearTranscript, push }) => {
+    // reset 会先归档当前对话（有内容才存），返回存档 id（无内容为 null）
+    const archivedId = await session.reset();
+    clearTranscript();
+    push(archivedId ? t("cmd.new.archived", { id: archivedId }) : t("cmd.new.started"));
+};
+const cmdBack = async ({ session, push, rows, exit, pick }) => {
+    const allItems = [];
+    session.messages.forEach((message, index) => {
+        if (message.role !== AgentNS.Role.User)
+            return;
+        const content = typeof message.content === "string" ? message.content : "";
+        allItems.push({ label: truncate(stripCwdNote(content), 60), value: String(index) });
+    });
+    if (allItems.length === 0) {
+        push(t("cmd.back.empty"), "error");
+        return;
+    }
+    // 最近的在最前；仅展示最近的有限条，避免覆盖层高于终端
+    const maxItems = Math.max(1, (rows ?? 24) - 8);
+    const items = allItems.reverse().slice(0, maxItems);
+    const title = allItems.length > maxItems ? t("cmd.back.tooMany", { n: maxItems }) : t("cmd.back.title");
+    const choice = await pick(title, items);
+    if (choice == null) {
+        push(t("cmd.back.cancelled"));
+        return;
+    }
+    const text = session.rollbackTo(Number(choice));
+    exit({ restart: true, messages: session.messages, initialInput: text });
+};
+const cmdEditor = async ({ push, suspendTerminal, setInputText }) => {
+    const file = join(tmpdir(), `aizen-input-${Date.now()}.md`);
+    try {
+        writeFileSync(file, "", "utf-8");
+        await suspendTerminal(() => {
+            const editor = process.env.EDITOR || process.env.VISUAL || (process.platform === "win32" ? "notepad" : "vi");
+            const result = spawnSync(editor, [file], { stdio: "inherit" });
+            if (result.error)
+                throw result.error;
+        });
+        const text = readFileSync(file, "utf-8").trim();
+        if (text)
+            setInputText(text);
+    }
+    catch (error) {
+        push(t("cmd.editor.failed", { error: error?.message ?? error }), "error");
+    }
+    finally {
+        try {
+            unlinkSync(file);
         }
-        case "save": {
-            try {
-                const id = await session.save();
-                push(`对话已保存：${id}`);
-            }
-            catch (error) {
-                push(`保存失败：${error?.message ?? error}`, "error");
-            }
-            break;
+        catch {
+            /* 忽略 */
         }
-        case "load": {
-            const list = await listConversations();
-            if (list.length === 0) {
-                push("还没有已保存的对话", "error");
-                break;
-            }
-            const allItems = list.map((c) => ({
-                label: c.name,
-                value: c.id,
-                hint: formatShortTime(c.updatedAt),
-            }));
-            // 覆盖层不能高于终端：仅展示最近的有限条
-            const maxItems = Math.max(1, (rows ?? 24) - 8);
-            const items = allItems.slice(0, maxItems);
-            const title = allItems.length > maxItems
-                ? `选择要加载的对话（仅显示最近 ${maxItems} 条）`
-                : "选择要加载的对话（当前会话将被替换）";
-            const choice = await new Promise((resolve) => setPickerState({ title, items, resolve }));
-            if (choice == null) {
-                push("已取消加载");
-                break;
-            }
-            const conversation = await conversationRepository.read(choice);
-            if (!conversation) {
-                push(`对话不存在或读取失败：${choice}`, "error");
-                break;
-            }
-            // 整体切换会话（含模型 / Agent）——交由上层重挂载对话屏
-            exit({
-                load: {
-                    agentId: conversation.agentId,
-                    messages: conversation.messages,
-                    conversationId: conversation.id,
-                    conversationName: conversation.id,
-                },
-            });
-            break;
+    }
+};
+const cmdClear = async ({ clearTranscript }) => {
+    // 清屏但保留上下文：仅把转录显示起点推到最新
+    clearTranscript();
+};
+const cmdConfig = async ({ openWizard }) => {
+    await openWizard({ kind: "menu" });
+};
+const cmdModel = async ({ session, push, args, exit, pick }) => {
+    const config = await readConfig();
+    const models = config.models ?? [];
+    if (models.length === 0) {
+        push(t("cmd.model.noModels"), "error");
+        return;
+    }
+    // 支持 `/model <id>` 直切，无参时弹选择器
+    let chosen = args[0];
+    if (chosen && !models.some((model) => model.id === chosen)) {
+        push(t("cmd.model.unknown", { id: chosen, options: models.map((m) => m.id).join(" / ") }), "error");
+        return;
+    }
+    if (!chosen) {
+        const items = models.map((model) => ({
+            label: model.id === session.modelId ? `${model.name}${t("common.current")}` : model.name,
+            value: model.id,
+            hint: model.id,
+        }));
+        const picked = await pick(t("cmd.model.title"), items);
+        if (picked == null) {
+            push(t("cmd.model.cancelled"));
+            return;
         }
-        case "handoff": {
-            if (invalidMode) {
-                push(`未知的执行者：${modeArg}（可选 self / summary）`, "error");
-                break;
-            }
-            if (!session.messages.some((m) => m.role === AgentNS.Role.User)) {
-                push("当前对话还没有可交接的内容", "error");
-                break;
-            }
-            // 未显式指定执行者时三选一（与自动迁移统一）；显式 `/handoff self|summary` 则直接采用
-            const chosen = mode ?? (await chooseHandoffMode(setPickerState, "编写交接文档 · 选择交接方式"));
-            if (chosen == null) {
-                push("已取消交接");
-                break;
-            }
-            try {
-                const path = await session.handoff(chosen);
-                push(`交接文档已生成：${path}`);
-            }
-            catch (error) {
-                push(`编写交接文档失败：${error?.message ?? error}`, "error");
-            }
-            break;
+        chosen = picked;
+    }
+    if (chosen === session.modelId) {
+        push(t("cmd.model.already", { id: chosen }));
+        return;
+    }
+    // 先确认目标模型可用：重挂载走的是 ChatSession.create → createModel，
+    // 端点缺 Key 会直接抛错落到启动错误屏，用户连 /key 都进不去
+    const targetModel = models.find((model) => model.id === chosen);
+    const targetEndpoint = (config.endpoints ?? []).find((endpoint) => endpoint.id === targetModel.endpointId);
+    if (!targetEndpoint) {
+        push(t("cmd.model.endpointMissing", { id: chosen, endpoint: targetModel.endpointId }), "error");
+        return;
+    }
+    if (!targetEndpoint.apiKey) {
+        push(t("cmd.model.noApiKey", { name: targetEndpoint.name }), "error");
+        return;
+    }
+    try {
+        // 只写 Agent 定义（模型唯一真相源）
+        const result = await switchModel({ config, agentId: session.agentId, modelId: chosen });
+        // Scope 持有配置快照：不重建的话 getScope() 会把旧模型又交给新 Agent
+        await resetScope();
+        // 重挂载对话屏：模型变了要重算上下文阈值、重建 Agent；消息与上下文保留
+        exit({ restart: true, agentId: session.agentId, messages: session.messages, notice: result.summary });
+    }
+    catch (error) {
+        push(t("cmd.model.failed", { error: error?.message ?? error }), "error");
+    }
+};
+const cmdAgent = async ({ session, push, args, exit, pick }) => {
+    const config = await readConfig();
+    const store = await readAgentStore();
+    const choices = listAgentChoices(config, store.agents);
+    if (choices.length === 0) {
+        push(t("cmd.agent.noAgents"), "error");
+        return;
+    }
+    // 支持 `/agent <id>` 直切，无参时弹选择器（与 /model 同一套做法）
+    let chosen = args[0];
+    if (chosen && !choices.some((choice) => choice.id === chosen)) {
+        push(t("cmd.agent.unknown", { id: chosen, options: choices.map((choice) => choice.id).join(" / ") }), "error");
+        return;
+    }
+    if (!chosen) {
+        const items = choices.map((choice) => {
+            const current = choice.id === session.agentId;
+            return {
+                label: `${choice.name}${current ? t("common.current") : ""}${choice.selectable ? "" : t("cmd.agent.unavailable")}`,
+                value: choice.id,
+                // 可用时给模型名（切换等于连模型一起换，得让用户看见换成哪个）；
+                // 不可用时给原因，否则用户只能干看着选不动
+                hint: choice.selectable ? (choice.modelName ?? choice.id) : (choice.reason ?? ""),
+            };
+        });
+        const picked = await pick(t("cmd.agent.title"), items);
+        if (picked == null) {
+            push(t("cmd.agent.cancelled"));
+            return;
         }
-        case "migrate":
-        case "migration": {
-            if (invalidMode) {
-                push(`未知的执行者：${modeArg}（可选 self / summary）`, "error");
-                break;
-            }
-            if (!session.messages.some((m) => m.role === AgentNS.Role.User)) {
-                push("当前对话还没有可迁移的内容", "error");
-                break;
-            }
-            // 与原 yes/no 确认统一为三选一：选「不交接」即取消本次迁移
-            const chosen = mode ?? (await chooseHandoffMode(setPickerState, "任务迁移 · 选择交接方式（完成后开启新会话）"));
-            if (chosen == null) {
-                push("已取消迁移");
-                break;
-            }
-            try {
-                const path = await session.migrate(chosen);
-                push(`任务迁移完成，已开启新会话\n📄 交接文档：${path}`);
-            }
-            catch (error) {
-                push(`任务迁移失败：${error?.message ?? error}`, "error");
-            }
-            break;
+        chosen = picked;
+    }
+    const target = choices.find((choice) => choice.id === chosen);
+    // 切过去跑不起来（未绑模型 / 端点缺 Key）就别切：重挂载后用户会卡在启动错误屏
+    if (!target.selectable) {
+        push(t("cmd.agent.unavailableReason", { name: target.name, reason: target.reason ?? "" }), "error");
+        return;
+    }
+    try {
+        const result = switchAgent({ config, agents: store.agents, targetAgentId: chosen });
+        await saveConfig(result.config);
+        if (chosen === session.agentId) {
+            // 会话已经在这个 Agent 上：只需把「默认 Agent」记号写对，不必重建
+            push(t("cmd.agent.alreadyOn", { summary: result.summary ?? "" }));
+            return;
         }
-        case "back": {
-            const allItems = [];
-            session.messages.forEach((message, index) => {
-                if (message.role !== AgentNS.Role.User)
-                    return;
-                const content = typeof message.content === "string" ? message.content : "";
-                allItems.push({ label: truncate(stripCwdNote(content), 60), value: String(index) });
-            });
-            if (allItems.length === 0) {
-                push("还没有可撤回的消息", "error");
-                break;
-            }
-            // 最近的在最前；仅展示最近的有限条，避免覆盖层高于终端
-            const maxItems = Math.max(1, (rows ?? 24) - 8);
-            const items = allItems.reverse().slice(0, maxItems);
-            const title = allItems.length > maxItems
-                ? `选择要撤回到的消息（仅显示最近 ${maxItems} 条）`
-                : "选择要撤回到的消息（其后内容将被移除）";
-            const choice = await new Promise((resolve) => setPickerState({ title, items, resolve }));
-            if (choice == null) {
-                push("已取消撤回");
-                break;
-            }
-            const text = session.rollbackTo(Number(choice));
-            exit({ restart: true, messages: session.messages, initialInput: text });
-            break;
+        // Scope 持有 Agent / 配置快照：不重建的话下一轮请求还是旧 Agent
+        await resetScope();
+        // 重挂载对话屏：提示词、工具集、模型都跟着 Agent 变；消息与上下文保留
+        exit({ restart: true, agentId: chosen, messages: session.messages, notice: result.summary });
+    }
+    catch (error) {
+        push(t("cmd.agent.failed", { error: error?.message ?? error }), "error");
+    }
+};
+const cmdReload = async ({ session, push }) => {
+    // 手改配置文件（mcp.json / skills / tools / config.json）后不用重启 CLI：
+    // `session.reload()` 内含 resetScope()（断开旧 MCP 连接）→ 重建 Agent → 重新发现。
+    // 消息与上下文保留，所以「刷新一下就看到新东西」不需要新开对话。
+    try {
+        await session.reload();
+        push(t("cmd.reload.done"));
+    }
+    catch (error) {
+        push(t("cmd.reload.failed", { error: error?.message ?? error }), "error");
+    }
+};
+const cmdMcp = async ({ push, args, openWizard }) => {
+    // 不另建一套 MCP 编辑界面：直接打开配置中心里已有的 MCP 屏。
+    // 增 / 删 / 改 / 启停 / 切换作用域都在那一屏里；关闭后宿主会因 `mcpChanged`
+    // 自动 `session.reload()`，新服务器当场生效（与 /config 走同一条路径）。
+    const rawScope = args[0];
+    const explicit = parseMcpScope(rawScope);
+    if (rawScope && !explicit) {
+        push(t("cmd.mcp.unknownScope", { scope: rawScope }), "error");
+        return;
+    }
+    const scope = explicit ??
+        pickStartScope({
+            global: await readMcpConfig("global"),
+            project: await readMcpConfig("project"),
+        });
+    await openWizard({ kind: "mcp", scope });
+};
+const cmdLang = async ({ push, args, refreshLocale }) => {
+    // `/lang` 无参在中文 / 英文之间切；`/lang zh`、`/lang en` 直接指定。
+    // 状态栏、输入行、通知等界面文案都走 `t()`，但它是模块级函数 —— 语言变了
+    // 已渲染的内容不会自己更新，必须让 React 重跑一遍渲染函数（refreshLocale）。
+    const wanted = args[0]?.toLowerCase();
+    if (wanted && wanted !== "zh" && wanted !== "en") {
+        push(t("cmd.lang.unknown", { lang: wanted }), "error");
+        return;
+    }
+    const target = wanted ?? (getLocale() === "zh" ? "en" : "zh");
+    await persistLocale(target);
+    refreshLocale();
+    push(t("notice.languageChanged"));
+};
+const cmdThink = async ({ session, push, args, setEffortView, pick }) => {
+    const config = await readConfig();
+    const presets = await readReasoningPresets();
+    const store = await readAgentStore();
+    const definition = store.agents.find((item) => item.id === session.agentId) ?? null;
+    const modelId = definition?.modelId;
+    if (!modelId) {
+        push(t("cmd.think.noModel", { id: session.agentId }), "error");
+        return;
+    }
+    const model = (config.models ?? []).find((item) => item.id === modelId);
+    if (!model) {
+        push(t("cmd.think.modelMissing", { id: modelId }), "error");
+        return;
+    }
+    const choices = effortChoices(model, presets);
+    if (choices.length === 0) {
+        push(t("cmd.think.notAdjustable", { id: model.id }), "error");
+        return;
+    }
+    // 支持 `/think high` 直设、`/think default` 恢复跟随模型默认，无参时弹选择器
+    let picked = args[0];
+    if (picked !== undefined && picked !== "default" && !choices.includes(picked)) {
+        push(t("cmd.think.unknown", { level: picked, options: choices.join(" / ") }), "error");
+        return;
+    }
+    if (!picked) {
+        // 「当前」指 Agent 定义上真正写着的那一档（模型默认参数不算，那是跟随状态）
+        const current = matchLevel(presetFor(model.id, model.reasoningPreset, presets), definition?.modelParams);
+        const items = [
+            {
+                label: `${t("cmd.think.followDefault")}${current ? "" : t("common.current")}`,
+                value: "default",
+                hint: t("cmd.think.clearHint"),
+            },
+            ...choices.map((value) => ({
+                label: `${effortLabel(value)}${value === current ? t("common.current") : ""}`,
+                value,
+                hint: value,
+            })),
+        ];
+        const choice = await pick(t("cmd.think.title", { level: describeEffort(model, presets, definition) }), items);
+        if (choice == null) {
+            push(t("cmd.think.cancelled"));
+            return;
         }
-        case "editor": {
-            const file = join(tmpdir(), `aizen-input-${Date.now()}.md`);
-            try {
-                writeFileSync(file, "", "utf-8");
-                await suspendTerminal(() => {
-                    const editor = process.env.EDITOR ||
-                        process.env.VISUAL ||
-                        (process.platform === "win32" ? "notepad" : "vi");
-                    const result = spawnSync(editor, [file], { stdio: "inherit" });
-                    if (result.error)
-                        throw result.error;
-                });
-                const text = readFileSync(file, "utf-8").trim();
-                if (text)
-                    setInputText(text);
-            }
-            catch (error) {
-                push(`编辑器打开失败：${error?.message ?? error}`, "error");
-            }
-            finally {
-                try {
-                    unlinkSync(file);
-                }
-                catch {
-                    /* 忽略 */
-                }
-            }
-            break;
+        picked = choice;
+    }
+    const effort = picked === "default" ? null : picked;
+    const agentLevel = matchLevel(presetFor(model.id, model.reasoningPreset, presets), definition?.modelParams);
+    const unchanged = effort === null ? agentLevel === undefined : agentLevel === effort;
+    if (unchanged) {
+        push(t("cmd.think.unchanged"));
+        return;
+    }
+    try {
+        const result = await setAgentEffort({
+            config,
+            presets,
+            agentId: session.agentId,
+            effort,
+            // 已读过定义，避免命令层与写入层各读一次盘
+            readAgent: async () => definition,
+        });
+        // 状态栏先跟上；档位要通过重建 Agent 才会进请求参数
+        setEffortView(describeEffortView(result.model, presets, result.definition));
+        await session.reload();
+        push(result.summary);
+    }
+    catch (error) {
+        push(t("cmd.think.failed", { error: error?.message ?? error }), "error");
+    }
+};
+const cmdKey = async ({ openKeyEditor }) => {
+    await openKeyEditor();
+};
+const cmdHandoff = async ({ session, push, args, setPickerState }) => {
+    const handoff = parseHandoffSelection(args);
+    if (handoff.invalid !== undefined) {
+        push(t("cmd.handoff.unknownMode", { who: handoff.invalid }), "error");
+        return;
+    }
+    if (!session.messages.some((m) => m.role === AgentNS.Role.User)) {
+        push(t("cmd.handoff.empty"), "error");
+        return;
+    }
+    // 未显式指定执行者时三选一（与自动迁移统一）；显式 `/handoff self|summary` 则直接采用
+    const chosen = handoff.mode ?? (await chooseHandoffMode(setPickerState, t("cmd.handoff.title")));
+    if (chosen == null) {
+        push(t("cmd.handoff.cancelled"));
+        return;
+    }
+    try {
+        const path = await session.handoff(chosen);
+        push(t("cmd.handoff.done", { path }));
+    }
+    catch (error) {
+        // 用户按 Ctrl+C 取消：不是失败，也不该报错堆栈
+        if (error instanceof HandoffAbortedError) {
+            push(t("cmd.handoff.cancelled"));
+            return;
         }
-        case "exit":
-        case "quit": {
-            await doExit();
-            break;
+        push(t("cmd.handoff.failed", { error: error?.message ?? error }), "error");
+    }
+};
+const cmdMigrate = async ({ session, push, args, setPickerState, clearTranscript }) => {
+    const handoff = parseHandoffSelection(args);
+    if (handoff.invalid !== undefined) {
+        push(t("cmd.handoff.unknownMode", { who: handoff.invalid }), "error");
+        return;
+    }
+    if (!session.messages.some((m) => m.role === AgentNS.Role.User)) {
+        push(t("cmd.migrate.empty"), "error");
+        return;
+    }
+    // 与原 yes/no 确认统一为三选一：选「不交接」即取消本次迁移
+    const chosen = handoff.mode ?? (await chooseHandoffMode(setPickerState, t("cmd.migrate.title")));
+    if (chosen == null) {
+        push(t("cmd.migrate.cancelled"));
+        return;
+    }
+    try {
+        const path = await session.migrate(chosen);
+        // 迁移用 `prune` 策略把 messages 剔除到「系统提示 + 交接断点」（仅 1~2 条），
+        // 转录显示起点必须跟着归零，否则 `messages.slice(transcriptFrom)` 恒为空——
+        // 迁移成功、上下文有内容，但屏幕上什么都没有（同 `/new` 分支的做法）。
+        clearTranscript();
+        push(t("cmd.migrate.done", { path }));
+    }
+    catch (error) {
+        // 用户按 Ctrl+C 取消：交接已停下且未改动会话，不是失败
+        if (error instanceof HandoffAbortedError) {
+            push(t("cmd.migrate.cancelled"));
+            return;
         }
-        default:
-            push(`未知命令：${raw}（输入 /help 查看可用命令）`, "error");
+        push(t("cmd.migrate.failed", { error: error?.message ?? error }), "error");
+    }
+};
+const cmdHelp = async ({ push }) => {
+    const lines = [t("cmd.help.title")];
+    for (const hint of matchCommandHints("")) {
+        lines.push(`  ${hint.label}  ${hint.description}`);
+    }
+    push(lines.join("\n"));
+};
+const cmdExit = async ({ doExit }) => {
+    await doExit();
+};
+/**
+ * 命令处理器表 —— 键是**主名**，类型保证与 `COMMAND_REGISTRY` 一一对应。
+ * 别名（`/effort`、`/quit`）由 `canonicalCommandName()` 归一后落到同一处理器。
+ */
+const HANDLERS = {
+    save: cmdSave,
+    load: cmdLoad,
+    new: cmdNew,
+    back: cmdBack,
+    editor: cmdEditor,
+    clear: cmdClear,
+    config: cmdConfig,
+    model: cmdModel,
+    agent: cmdAgent,
+    reload: cmdReload,
+    mcp: cmdMcp,
+    lang: cmdLang,
+    think: cmdThink,
+    key: cmdKey,
+    handoff: cmdHandoff,
+    migrate: cmdMigrate,
+    help: cmdHelp,
+    exit: cmdExit,
+};
+/** 组装执行上下文：参数解析、通知与选择器的统一入口 */
+function buildContext(name, raw, host) {
+    return {
+        ...host,
+        name,
+        raw,
+        // 参数切分与命令名解析同源（registry 的 splitCommandInput），命令层不再自己切一遍
+        args: parseCommandArgs(raw),
+        push: (text, tone = "info") => host.notice(text, tone),
+        pick: (title, items) => new Promise((resolve) => host.setPickerState({ title, items, resolve })),
+    };
+}
+/**
+ * 执行一条斜杠命令。
+ *
+ * @param name 命令名（含别名，大小写不敏感；由 `parseCommandInput()` 从输入里取出）
+ * @param raw  原始输入（含 `/`），用于参数解析与错误回显
+ */
+export async function runCommand(name, raw, host) {
+    const canonical = canonicalCommandName(name);
+    if (!canonical) {
+        host.notice(t("cmd.unknown", { cmd: raw }), "error");
+        return;
     }
+    await HANDLERS[canonical](buildContext(canonical, raw, host));
 }
 //# sourceMappingURL=chat-commands.js.map