@ai-zen/cli 1.0.0-alpha.3 → 1.0.0-alpha.30

package/dist/tui/screens/chat.js

@@ -1,30 +1,61 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// 由 src/tui/screens.tsx 拆分而来 —— 对话屏幕 Chat
-import { useEffect, useReducer, useRef, useState } from "react";
+// 对话屏幕 —— 以 SDK 的 `agent.messages` 为唯一数据源渲染（无自定义中间模型）
+import { useEffect, useRef, useState } from "react";
 import { Box, Text, useApp, useCursor, useInput, useWindowSize } from "ink";
+import { spawn } from "node:child_process";
+import { disableMouseTracking } from "../mouse.js";
+import { setSdkNoticeSink } from "../../sdk-log.js";
+import { keyDebug } from "../key-debug.js";
+import { phaseLabel } from "../phase.js";
+import { AgentNS } from "@ai-zen/agents-core";
 import { theme } from "../theme.js";
-import { Spinner, StatusBar, SlashMenu } from "../components.js";
-import { layoutInput, usableFrameRows, isTerminalReply } from "../text.js";
+import { Spinner, StatusBar, statusBarRows, BottomMenu, PastedImagesBar } from "../components.js";
+import { graphemes, layoutInput, usableFrameRows } from "../text.js";
 import { ChatSession } from "../chat-session.js";
-import { matchCommandHints } from "../../conversation-commands/registry.js";
-import { readConfig, readMcpConfig, saveConfig, writeMcpConfig } from "../../config.js";
+import { commandBlocksInput, matchCommandHints, parseCommandInput, } from "../../conversation-commands/registry.js";
+import { readConfig, readMcpConfig, readReasoningPresets, saveConfig, writeMcpConfig } from "../../config.js";
 import { readAgentStore } from "../../agents-store.js";
-import { resolveCredential } from "../../config-editor.js";
 import { ConfigWizard } from "../config-wizard/index.js";
-import { computeInputCursorPosition, wordLeft, wordRight } from "./input.js";
-import { computeChatLayout } from "./layout.js";
-import { chatReducer, trimTranscript } from "./state.js";
-import { LineView, messagesToBlocks } from "./render.js";
+import { computeInputCursorPosition, inputWindow } from "./input.js";
+import { AGENT_TABS_LINES, computeChatLayout } from "./layout.js";
+import { FrameBuffer } from "./frame-buffer.js";
+import { LineView } from "./render.js";
+import { messageToLines, transcriptLines } from "./messages-view.js";
 import { PickerOverlay, Confirm } from "./overlays.js";
+import { CursorInputRow } from "./input-row.js";
+import { chooseHandoffMode } from "./handoff-choice.js";
 import { runCommand } from "./chat-commands.js";
+import { describeEffortView } from "../../reasoning-effort.js";
+import { t } from "../../i18n/index.js";
+import { NoticeChannel, noticeLines } from "./notice.js";
+import { NoticeBar } from "./notice-bar.js";
+import { AgentTabs } from "./agent-tabs.js";
+import { useChatViewport } from "./use-chat-viewport.js";
+import { useChatOverlays } from "./use-overlays.js";
+import { useWizardHost } from "./use-wizard-host.js";
+import { useInputEditing } from "./use-input-editing.js";
+import { extractMention, mentionInsertText, rankPaths } from "../mention.js";
+import { userDrafts } from "../chat-history.js";
+import { listProjectPaths } from "../file-index.js";
+import { MAX_CLIPBOARD_TEXT_BYTES, readClipboardImage, readClipboardText } from "../../clipboard.js";
+import { handleCtrlDExit, handleScrollKey } from "./common-keys.js";
+/**
+ * 单条消息最多附几张粘贴图片。
+ *
+ * 顶在 4 张：一张手机截图内联后 base64 常在 1~3MB，再多一次请求就是几十 MB，
+ * 既扫 token 也容易撞端点的请求体上限。
+ */
+export const MAX_PASTED_IMAGES = 4;
+/** 字节数 → 一位小数的 MB（提示文案用） */
+export function formatMegabytes(bytes) {
+    return (bytes / 1024 / 1024).toFixed(1);
+}
 /**
  * 计算回车时应提交的文本。
  *
  * 斜杠候选菜单可见时（输入以 `/` 开头且尚未输入参数），回车应**直接执行高亮命令**，
  * 而不是提交半截输入 —— 否则用户只输入 `/` 或未补全的命令名时，回车会落到
  * 「未知命令」报错（体验很差）。非命令输入原样返回。
- *
- * `menuIndex` 越界时回落到最后一项，避免菜单看似有选中却回车落空。
  */
 export function resolveSubmitText(input, hints, menuIndex) {
     const slash = input.startsWith("/") && !input.includes("\n") && !input.includes(" ");
@@ -34,268 +65,512 @@ export function resolveSubmitText(input, hints, menuIndex) {
     const picked = hints[index]?.names[0];
     return picked ? `/${picked}` : input;
 }
+/**
+ * 忙碌期那一行 spinner 的文案。
+ *
+ * 生成中由 SDK 的阶段驱动（`phaseLabel`）；但 `/update`、`/migrate` 这类
+ * **阻塞输入的命令**执行时根本没有生成轮次，`phase` 是 `null`，`phaseLabel(null)`
+ * 会兜底成「处理中…」——与实际动作毫无关系。命令期间改显命令名，
+ * 至少能看出「在跑哪条命令」，具体进度由命令自己 push 通知（查版本 / 开始安装 …）。
+ */
+export function busySpinnerLabel(phase, command) {
+    if (phase)
+        return phaseLabel(phase);
+    return command ? t("cmd.running", { name: command }) : phaseLabel(null);
+}
 export function Chat(props) {
+    const deps = {
+        readConfig,
+        readReasoningPresets,
+        readAgentStore,
+        createSession: ChatSession.create,
+        listProjectPaths,
+        readClipboardImage,
+        readClipboardText,
+        wizardReaders: {
+            readConfig,
+            readMcpConfig,
+            readReasoningPresets,
+            readAgentStore,
+        },
+        saveConfig,
+        writeMcpConfig,
+        ...props.deps,
+    };
     const { exit, suspendTerminal } = useApp();
     const { setCursorPosition } = useCursor();
     const { columns, rows } = useWindowSize();
-    const [state, dispatch] = useReducer(chatReducer, {
-        // 载入 / 恢复会话时也封顶：避免把落盘的超大会话整段读进内存
-        blocks: trimTranscript(props.clearTranscript ? [] : messagesToBlocks(props.messages ?? [])),
-        live: null,
-    });
-    const [input, setInput] = useState(props.initialInput ?? "");
-    /** 光标位置：以 code point 计的字符索引（0..len） */
-    const [cursor, setCursor] = useState(Array.from(props.initialInput ?? "").length);
-    const [menuIndex, setMenuIndex] = useState(0);
-    // 输入变化后候选集随之改变：高亮重置回首项，避免索引越界（看似选中实为无高亮 / 回车落空）
-    useEffect(() => {
-        setMenuIndex(0);
-    }, [input]);
-    const [confirmState, setConfirmState] = useState(null);
-    const [pickerState, setPickerState] = useState(null);
-    /** 配置向导：非 null 时整屏接管（凭据设置 / 配置中心） */
-    const [wizardStep, setWizardStep] = useState(null);
-    const [wizardConfig, setWizardConfig] = useState(null);
-    /** 可用 Agent 列表（供配置中心「默认 Agent」选择） */
-    const [wizardAgents, setWizardAgents] = useState([]);
-    /** MCP 配置快照（全局 + 项目），打开向导时刷新 */
-    const [wizardMcp, setWizardMcp] = useState(null);
-    /** Agent / Sub-agent 定义仓储（快照 + 读写），打开向导时刷新 */
-    const [wizardAgentStore, setWizardAgentStore] = useState(null);
-    /** 当前会话所用端点 id（打开向导时刷新，用于判断改动是否影响本会话） */
-    const currentEndpointRef = useRef(null);
-    const [history, setHistory] = useState([]);
-    const historyIndex = useRef(-1);
+    /** 覆盖层（确认框 / 选择器）：弹窗与 resolve 生命周期见 use-overlays.ts */
+    const { confirmState, pickerState, setConfirmState, setPickerState, resolveConfirm, resolvePicker } = useChatOverlays();
     const sessionRef = useRef(null);
     const [bootError, setBootError] = useState(null);
     const [ready, setReady] = useState(false);
-    /** 视口顶部行索引；null = 贴底（自动跟随最新内容） */
-    const [viewTop, setViewTop] = useState(null);
-    /** 最近一次布局，供键盘回调读取总行数 / 视口高度（应用内翻页） */
-    const layoutRef = useRef(null);
-    const busy = state.live != null;
+    /** 视口：滚动状态与翻页 / 按行 / 滚轮换算（唯一入口见 use-chat-viewport.ts） */
+    const { viewTop, layoutRef, scrollByPage, scrollByLine, scrollByWheel, scrollToBottom } = useChatViewport();
+    /** 本轮是否在生成中（spinner / 输入禁用） */
+    const [busy, setBusy] = useState(false);
+    /** 正在执行的**阻塞型命令**名（`blocksInput: true` 的 `/update` / `/migrate` …），见 `busySpinnerLabel` */
+    const [busyCommand, setBusyCommand] = useState(null);
+    /** 生成速率快照（token/s）：生成中为实时值，结束后保留本轮平均 */
+    const [rate, setRate] = useState(null);
+    /**
+     * 当前模型 id —— **从会话（即 Agent 定义）读**，不作为 prop 传入。
+     *
+     * 模型的唯一真相源是 `AgentDefinition.modelId`：所以状态栏、凭据检查、思考状态
+     * 与 SDK 实发请求用的永远是同一个值，不会出现「显示 A、实发 B」。
+     */
+    const [modelId, setModelId] = useState("");
+    /**
+     * 思考强度展示文案（关 / 低 / 中 / 高 / 最高 / 开 / —）。
+     *
+     * 真相在配置里（模型的 `defaultParams`），这里只镜像一份供状态栏用：
+     * `/think` 写入后由命令层回调刷新，切模型（会话重建）时靠 `modelId` 变化重读。
+     */
+    const [effortView, setEffortView] = useState(null);
+    /**
+     * 语言切换计数（`/lang`）：`t()` 是模块级函数，语言变了已渲染的文案不会自更新，
+     * 递增这个计数只为逼 React 重跑一遍渲染函数。
+     */
+    const [localeTick, bumpLocale] = useState(0);
+    /**
+     * IME 光标位置：由光标所在行**渲染后实测**而来（渲染器给的帧内坐标）。
+     * 带上 key —— 只有「产生它的那个输入状态」与当前一致时才能用，否则就是上一帧的陈旧值。
+     */
+    const [imePosition, setImePosition] = useState(null);
+    /** 乐观回显：提交后、真实 user 消息落进 messages 之前，先显示用户提问 */
+    const [pendingUser, setPendingUser] = useState(null);
+    /**
+     * 待发送的粘贴图片（`Ctrl+V` 累积）。
+     *
+     * 存 base64 而不是落盘：SDK 的 `fileToContentSection()` 正好接受 `{ base64, mime }`，
+     * 于是粘贴全程不碰磁盘 —— 也就不会在 `$TMPDIR` 里留下一堆无人清理的 png。
+     */
+    const [pastedImages, setPastedImages] = useState([]);
+    /** 转录显示起点（/clear 清屏用：隐藏此索引之前的消息，但不改上下文） */
+    const [transcriptFrom, setTranscriptFrom] = useState(0);
+    /**
+     * 当前查看的 Agent 视图：`"main"` 或某个子 Agent 的视图 id。
+     *
+     * 只影响**消息列表的数据源**（主 Agent 的 `messages` / 子 Agent 自己的 `messages`），
+     * 不改上下文、不影响发送目标：发出的消息永远属于主 Agent。
+     */
+    const [activeAgentId, setActiveAgentId] = useState("main");
+    /** Ctrl+D 双击退出计时 */
+    const ctrlDAtRef = useRef(0);
+    /**
+     * 通知通道：notice / error 走独立栏位，绝不进对话转录（messages）。
+     */
+    const noticeChannelRef = useRef(null);
+    if (noticeChannelRef.current == null)
+        noticeChannelRef.current = new NoticeChannel();
+    const noticeChannel = noticeChannelRef.current;
+    /**
+     * 通知队列（最近的在最后）。通道内部保留最近 `MAX_NOTICE_HISTORY` 条，
+     * 这里只做镜像：单槽 state 会让「同一批摘要 / 分阶段进度」只剩最后一条。
+     */
+    const [notices, setNotices] = useState(noticeChannel.notices);
+    useEffect(() => noticeChannel.subscribe(setNotices), [noticeChannel]);
+    /**
+     * SDK 的 warn / error 直接进通知栏 —— **通用通道**，不为某个功能单独接线。
+     *
+     * 以前 SDK 日志被整体接管到文件里（不然 `console.log` 会撕坏 Ink 的帧），代价是
+     * 「SDK 说了什么」用户在界面上一个字都看不见，只能事后翻 sdk.log —— 排查成本极高
+     * （连「工具文件把进程杀了」这种事都只能靠猜）。这里注册一个 sink 把 warn/error
+     * 引过来：以后 SDK 任何模块只要打日志，界面上自动就有，不必为新特性再传一个回调。
+     *
+     * 晚绑定、启动期缓冲、去重、封顶都在 `sdk-log.ts` 里做，这里只做接线。
+     */
+    useEffect(() => {
+        setSdkNoticeSink((level, message) => noticeChannel.push(message, level));
+        return () => setSdkNoticeSink(null);
+    }, [noticeChannel]);
+    /**
+     * 配置向导宿主（凭据 / 配置中心）：整屏接管与「关闭后让改动生效」见
+     * use-wizard-host.ts。这里只提供出口：通知走通知通道、重启 / 重载走会话。
+     */
+    const { wizardStep, wizardConfig, wizardPresets, wizardAgents, wizardMcp, wizardAgentStore, openWizard, openKeyEditor, closeWizard, } = useWizardHost({
+        modelId,
+        notify: (text, tone) => noticeChannel.push(text, tone),
+        hasSession: () => sessionRef.current != null,
+        restart: () => exit({ restart: true, messages: props.messages }),
+        reloadSession: () => {
+            void sessionRef.current
+                ?.reload()
+                .then(() => noticeChannel.push(t("notice.reloaded")))
+                .catch((error) => noticeChannel.push(t("chat.sessionReloadFailed", { error: error?.message ?? error }), "error"));
+        },
+        // 向导读快照 / 落盘也走注入：集成测试不该碰真实配置目录
+        readers: deps.wizardReaders,
+    });
+    /**
+     * 重挂载附带的系统提示（如 `/model` 的切换结果）。
+     *
+     * 用 ref 而非 props 直读：本值只在首次挂载消费一次，若写进 create 的依赖数组，
+     * 会把「展示一条提示」误变成「重建会话」。
+     */
+    const initialNoticeRef = useRef(props.initialNotice);
+    /** 钩子带来的首条消息：只在会话建好后发一次，重挂载不再重发 */
+    const initialPromptRef = useRef(props.initialPrompt);
+    /**
+     * 渲染信号 + 合帧：SDK 内容变更 → FrameBuffer 合帧 → setTick 触发重渲染。
+     * 转录内容始终从 `agent.messages` 现取，tick 只负责「告诉 React 该重画了」。
+     */
+    const [, setTick] = useState(0);
+    const frameBufferRef = useRef(null);
+    if (frameBufferRef.current == null) {
+        frameBufferRef.current = new FrameBuffer(() => setTick((t) => t + 1));
+    }
+    // 思考强度展示：从当前模型的 defaultParams 派生；`/think` 写入后由命令层回调刷新，
+    // 切模型（会话重建）时靠 modelId 变化重读。
+    useEffect(() => {
+        if (!modelId)
+            return;
+        let alive = true;
+        // 档位存在 Agent 定义上（`modelParams`），可选档位在策略表里（`reasoningPreset` 指向），两者都要读
+        Promise.all([deps.readConfig(), deps.readAgentStore(), deps.readReasoningPresets()])
+            .then(([config, store, presets]) => {
+            const model = config.models?.find((item) => item.id === modelId);
+            const agentId = props.agentId ?? "default";
+            const definition = store.agents.find((item) => item.id === agentId) ?? null;
+            if (alive)
+                setEffortView(describeEffortView(model, presets, definition));
+        })
+            .catch(() => {
+            if (alive)
+                setEffortView(null);
+        });
+        return () => {
+            alive = false;
+        };
+        // localeTick：切语言后档位文案要重算（它缓存的是已本地化的字符串，不是档位名）
+    }, [modelId, props.agentId, localeTick]);
     // 创建会话
     useEffect(() => {
         let disposed = false;
-        ChatSession.create({
-            modelId: props.modelId,
+        const notifier = {
+            onChange: (immediate) => {
+                if (disposed)
+                    return;
+                frameBufferRef.current?.push(null, immediate);
+            },
+            onNotice: (text, tone) => {
+                if (!disposed)
+                    noticeChannel.push(text, tone);
+            },
+        };
+        deps.createSession({
             agentId: props.agentId,
             messages: props.messages,
             conversationId: props.conversationId,
             conversationName: props.conversationName,
-            requestConfirm: (question) => new Promise((resolve) => setConfirmState({ question, resolve })),
-        }, (event) => {
-            if (!disposed)
-                dispatch(event);
-        })
+            // 自动迁移：与手动 /migrate、/handoff 共用同一套「交接方式三选一」选择器
+            requestMode: (info) => chooseHandoffMode(setPickerState, t("handoff.pickTitle", { used: info.promptTokens, limit: info.handoffTokens })),
+        }, notifier)
             .then((session) => {
             if (disposed) {
                 session.dispose();
                 return;
             }
             sessionRef.current = session;
+            setModelId(session.modelId);
             setReady(true);
+            // 重挂载附带的提示只需展示一次（消费后置空，避免再次触发）
+            if (initialNoticeRef.current) {
+                noticeChannel.push(initialNoticeRef.current);
+                initialNoticeRef.current = undefined;
+            }
+            // shell 钩子：会话就绪后立即把原命令当**用户消息**发出去（不经命令解析）
+            if (initialPromptRef.current) {
+                const prompt = initialPromptRef.current;
+                initialPromptRef.current = undefined;
+                setTick((t) => t + 1);
+                void runSubmit(prompt, { asMessage: true });
+                return;
+            }
+            setTick((t) => t + 1);
         })
             .catch((error) => setBootError(error?.message ?? String(error)));
         return () => {
             disposed = true;
+            frameBufferRef.current?.dispose();
             sessionRef.current?.dispose();
         };
     }, [
-        props.modelId,
         props.agentId,
         props.messages,
         props.conversationId,
         props.conversationName,
     ]);
-    const resolveConfirm = (value) => {
-        setConfirmState((cs) => {
-            cs?.resolve(value);
-            return null;
-        });
+    // 速率采样：Spinner 的重渲染只影响它自己，不会带着状态栏一起刷，所以生成中要自己定时读快照。
+    // 生成结束（busy → false）时再读一次，拿本轮平均速率并留在状态栏上。
+    useEffect(() => {
+        const read = () => setRate(sessionRef.current?.rateSample ?? null);
+        read();
+        if (!busy)
+            return;
+        const timer = setInterval(read, 250);
+        return () => clearInterval(timer);
+    }, [busy]);
+    /** 清屏但保留上下文：把显示起点推到当前消息末尾 */
+    const clearTranscript = () => {
+        setTranscriptFrom(sessionRef.current?.messages.length ?? 0);
+        noticeChannel.clear();
     };
-    const resolvePicker = (value) => {
-        setPickerState((ps) => {
-            ps?.resolve(value);
-            return null;
+    /**
+     * 输入编辑（文本 / 光标 / 历史 / kill ring / undo / stash）：
+     * 全部语义在 use-input-editing.ts，这里只把通知出口接上。
+     */
+    const { input, cursor, setInputText, insertAtCursor, replaceRange, deleteBeforeCursor, deleteAfterCursor, deleteWordBeforeCursor, deleteWordAfterCursor, deleteToStartOfLine, deleteToEndOfLine, deletePrevWhitespace, yank, undoEdit, toggleStash, moveCursor, moveCursorToLineStart, moveCursorToLineEnd, moveCursorUpRow, moveCursorDownRow, moveCursorByWord, historyPrev, historyNext, clearDraft, } = useInputEditing({
+        initialText: props.initialInput,
+        notify: (text, tone) => noticeChannel.push(text, tone),
+        // 历史来自 messages（唯一真相源）：自带图片，`↑` 回到带图消息时附件也一并回来
+        historySource: () => userDrafts(sessionRef.current?.messages ?? []),
+        restoreImages: (images) => setPastedImages(images),
+    });
+    /** 斜杠候选菜单的高亮索引；输入一变就回到第一个候选 */
+    const [menuIndex, setMenuIndex] = useState(0);
+    useEffect(() => {
+        setMenuIndex(0);
+    }, [input]);
+    /** 项目文件索引（`@` 补全的候选源）；null = 还没扫过 */
+    const [fileIndex, setFileIndex] = useState(null);
+    /** 用户按 Esc 主动关掉了 `@` 菜单：输入 / 光标一变就重新允许弹出 */
+    const [mentionOff, setMentionOff] = useState(false);
+    useEffect(() => {
+        setMentionOff(false);
+    }, [input, cursor]);
+    // 命令候选人
+    const slash = input.startsWith("/") && !input.includes("\n") && !input.includes(" ");
+    const hints = slash ? matchCommandHints(input.slice(1)) : [];
+    /**
+     * `@` 文件补全的上下文：光标是否停在一个 `@token` 里（判据见 `mention.ts`）。
+     *
+     * 与斜杠命令**互斥**：`/` 开头就是在写命令，此时不弹文件菜单。
+     */
+    const mention = slash || mentionOff ? null : extractMention(input, cursor);
+    const fileMatches = mention && fileIndex ? rankPaths(mention.query, fileIndex) : [];
+    /** 索引还没就绪：菜单先占一行「扫描中…」，否则敲下 `@` 后一片空白像没反应 */
+    const scanningFiles = mention != null && fileIndex == null;
+    /** 当前菜单条数（两种菜单互斥，非零的那个说了算） */
+    const menuCount = slash ? hints.length : fileMatches.length;
+    /**
+     * 菜单**想吃**的行数：候选条数 + 「扫描中…」占位。
+     *
+     * 实际能拿多少由布局决定（`computeChatLayout` 按输入框上方的剩余空间放行，
+     * 不设固定上限）—— 这里交上去的是「想要多少」，渲染与 IME 光标一律读回
+     * `layout.hintRows`，三处同源。
+     */
+    const menuWant = slash ? hints.length : fileMatches.length + (scanningFiles ? 1 : 0);
+    /** 菜单条目：斜杠命令带说明，`@` 路径目录带尾斜杠（提示「选中后继续下钻」） */
+    const menuItems = slash
+        ? hints.map((hint) => ({ key: hint.names[0], label: hint.label, hint: hint.description }))
+        : fileMatches.map((entry) => ({
+            key: entry.path,
+            label: entry.dir ? `${entry.path}/` : entry.path,
+        }));
+    /** 每次「重新唤起 `@`」都问一次索引：`listProjectPaths` 内部有 15s 缓存，未过期时几乎零成本，
+     *  过期则顺手重扫 —— 于是会话里新建的文件不会因为「只扫过一次」而永远看不到。 */
+    useEffect(() => {
+        if (mention == null)
+            return;
+        let alive = true;
+        void deps.listProjectPaths(process.cwd())
+            .then((paths) => {
+            if (alive)
+                setFileIndex(paths);
+        })
+            .catch(() => {
+            if (alive)
+                setFileIndex([]);
         });
+        return () => {
+            alive = false;
+        };
+        // 只在「从无菜单到有菜单」时触发：同一 token 内每敲一个键都重扫毫无意义
+    }, [mention == null]);
+    /**
+     * 把 `@` 菜单里高亮的那条补进草稿。
+     *
+     * 落字走 `replaceRange`：替换的是**整个 token**（`@src/tu` 这种半截路径、或光标停在
+     * 中间时右半边残留），并且会记一条撤销快照 —— 补错了 `Ctrl+_` 能退回。
+     * 目录带尾斜杠，补完菜单会重新过滤出该目录下的内容，于是可以一路钻下去。
+     */
+    const completeMentionSelection = () => {
+        if (!mention || fileMatches.length === 0)
+            return;
+        const entry = fileMatches[Math.max(0, Math.min(menuIndex, fileMatches.length - 1))];
+        if (!entry)
+            return;
+        replaceRange(mention.start, mention.end, mentionInsertText(entry.path, entry.dir));
     };
-    // ---- 配置向导（凭据 / 配置中心）----
-    /** 打开配置向导：先取配置 / MCP / Agent 快照，再切入指定步骤 */
-    const openWizard = async (step) => {
-        try {
-            const config = await readConfig();
-            currentEndpointRef.current = resolveCredential(config, props.modelId)?.endpointId ?? null;
-            const agentStore = await readAgentStore();
-            setWizardConfig(config);
-            setWizardAgents(agentStore.agents.map((agent) => ({ id: agent.id, name: agent.name || agent.id })));
-            setWizardAgentStore(agentStore);
-            setWizardMcp({ global: await readMcpConfig("global"), project: await readMcpConfig("project") });
-            setWizardStep(step);
-        }
-        catch (error) {
-            dispatch({ type: "error", text: `读取配置失败：${error?.message ?? error}` });
-        }
-    };
-    /** `/key`：直达「当前模型所用端点」的 API Key 编辑步骤 */
-    const openKeyEditor = async () => {
-        try {
-            const config = await readConfig();
-            const credential = resolveCredential(config, props.modelId);
-            if (!credential) {
-                dispatch({
-                    type: "error",
-                    text: `模型 ${props.modelId} 未绑定可用端点，请用 /config 检查配置`,
-                });
+    /**
+     * `Ctrl+V`：**先问剪贴板要图片，没有图片就退回粘贴文本**。
+     *
+     * 顺序不能反 —— 文本一旦先粘进去，再发现「其实剪贴板里是图片」就晚了（草稿里已经
+     * 多了一坨东西）。所以永远是「图片优先、文本兑底」，这也就是用户按 Ctrl+V 的默认期待。
+     *
+     * 异步不阻塞输入：`readClipboardImage()` 要 spawn 一个子进程（几十 ms），期间用户
+     * 还能继续打字；回到结果时只做一次 setState / 插字。
+     */
+    const pasteClipboard = async () => {
+        const result = await deps.readClipboardImage();
+        if (result.kind === "image") {
+            if (pastedImages.length >= MAX_PASTED_IMAGES) {
+                noticeChannel.push(t("notice.imageLimit", { n: MAX_PASTED_IMAGES }), "error");
                 return;
             }
-            currentEndpointRef.current = credential.endpointId;
-            setWizardConfig(config);
-            setWizardStep({ kind: "edit", field: "apiKey", endpointId: credential.endpointId });
-        }
-        catch (error) {
-            dispatch({ type: "error", text: `读取配置失败：${error?.message ?? error}` });
+            setPastedImages((list) => [...list, result.image]);
+            noticeChannel.push(t("notice.imagePasted", { n: pastedImages.length + 1 }));
+            return;
         }
-    };
-    /** 向导关闭：渲染变更摘要；若改到当前端点则重建会话（消息保留） */
-    const closeWizard = (result) => {
-        setWizardStep(null);
-        setWizardConfig(null);
-        setWizardMcp(null);
-        setWizardAgentStore(null);
-        for (const line of result.summary)
-            dispatch({ type: "notice", text: `配置已更新：${line}` });
-        if (!result.dirty)
-            return;
-        // 会话尚未建立（启动失败进入向导）：重挂载对话屏重试
-        if (!sessionRef.current) {
-            exit({ restart: true, messages: props.messages });
-            return;
-        }
-        const endpointChanged = !!currentEndpointRef.current && result.changedEndpointIds.includes(currentEndpointRef.current);
-        if (endpointChanged || result.mcpChanged || result.agentsChanged) {
-            sessionRef.current
-                .reload()
-                .then(() => dispatch({ type: "notice", text: "已按新配置重建会话（消息与上下文保留）" }))
-                .catch((error) => dispatch({ type: "error", text: `重建会话失败：${error?.message ?? error}` }));
+        if (result.kind === "too-large") {
+            noticeChannel.push(t("notice.imageTooLarge", { size: formatMegabytes(result.bytes) }), "error");
+            return;
         }
-    };
-    // ---- 滚动视口控制（应用内翻页，回看历史）----
-    /** 跳到指定顶部行；越界钳制；一旦贴到底部则恢复「自动跟随」 */
-    const scrollTo = (nextTop) => {
-        const L = layoutRef.current;
-        if (!L)
-            return;
-        const maxTop = Math.max(0, L.totalLines - L.budget);
-        const clamped = Math.max(0, Math.min(maxTop, nextTop));
-        setViewTop(clamped >= maxTop ? null : clamped);
-    };
-    /** 翻页滚动（dir：-1 上翻 / +1 下翻） */
-    const scrollByPage = (dir) => {
-        const L = layoutRef.current;
-        if (!L)
+        // 没有图片 → 当成普通粘贴：把剪贴板文本插到光标处
+        const pasted = await deps.readClipboardText();
+        if (pasted.kind === "unavailable") {
+            noticeChannel.push(t("notice.clipboardUnavailable"), "error");
             return;
-        scrollTo(L.viewTop + dir * Math.max(1, L.budget - 1));
-    };
-    /** 单行滚动（dir：-1 上 / +1 下） */
-    const scrollByLine = (dir) => {
-        const L = layoutRef.current;
-        if (!L)
+        }
+        if (pasted.kind === "too-large") {
+            noticeChannel.push(t("notice.textTooLarge", {
+                size: Math.round(pasted.bytes / 1024),
+                limit: MAX_CLIPBOARD_TEXT_BYTES / 1024,
+            }), "error");
             return;
-        scrollTo(L.viewTop + dir);
-    };
-    /** 回到最新（贴底，恢复自动跟随） */
-    const scrollToBottom = () => setViewTop(null);
-    // ---- 输入编辑（光标感知）----
-    /** 替换整个输入并把光标移到末尾 */
-    const setInputText = (text) => {
-        setInput(text);
-        setCursor(Array.from(text).length);
-    };
-    /** 在光标处插入文本 */
-    const insertAtCursor = (text) => {
-        const chars = Array.from(input);
-        const cp = Math.max(0, Math.min(cursor, chars.length));
-        setInput(chars.slice(0, cp).join("") + text + chars.slice(cp).join(""));
-        setCursor(cp + Array.from(text).length);
-    };
-    /** 删除光标前一个字符（Backspace） */
-    const deleteBeforeCursor = () => {
-        const chars = Array.from(input);
-        const cp = Math.max(0, Math.min(cursor, chars.length));
-        if (cp === 0)
-            return;
-        setInput(chars.slice(0, cp - 1).join("") + chars.slice(cp).join(""));
-        setCursor(cp - 1);
-    };
-    /** 删除光标后一个字符（Delete） */
-    const deleteAfterCursor = () => {
-        const chars = Array.from(input);
-        const cp = Math.max(0, Math.min(cursor, chars.length));
-        if (cp >= chars.length)
+        }
+        if (pasted.text.length === 0) {
+            noticeChannel.push(t("notice.clipboardEmpty"));
             return;
-        setInput(chars.slice(0, cp).join("") + chars.slice(cp + 1).join(""));
-    };
-    /** 以字符为单位移动光标 */
-    const moveCursor = (delta) => {
-        const len = Array.from(input).length;
-        setCursor((c) => Math.max(0, Math.min(len, c + delta)));
-    };
-    /** 光标移到当前逻辑行行首（Home） */
-    const moveCursorToLineStart = () => {
-        const chars = Array.from(input);
-        const cp = Math.max(0, Math.min(cursor, chars.length));
-        let i = cp;
-        while (i > 0 && chars[i - 1] !== "\n")
-            i -= 1;
-        setCursor(i);
-    };
-    /** 光标移到当前逻辑行行尾（End） */
-    const moveCursorToLineEnd = () => {
-        const chars = Array.from(input);
-        const cp = Math.max(0, Math.min(cursor, chars.length));
-        let i = cp;
-        while (i < chars.length && chars[i] !== "\n")
-            i += 1;
-        setCursor(i);
+        }
+        // 去掉末尾单个换行：剪贴板文本几乎总带一个尾换行，粘完光标原地跳行很莫妙
+        insertAtCursor(pasted.text.replace(/\n$/, ""));
     };
-    // 命令候选人
-    const slash = input.startsWith("/") && !input.includes("\n") && !input.includes(" ");
-    const hints = slash ? matchCommandHints(input.slice(1)) : [];
-    const runSubmit = async (text) => {
+    const runSubmit = async (text, options = {}) => {
         const trimmed = text.trim();
         if (!trimmed || !sessionRef.current || busy)
             return;
-        setInputText("");
-        historyIndex.current = -1;
+        clearDraft();
         scrollToBottom();
-        if (trimmed.startsWith("/")) {
-            const name = trimmed.slice(1).toLowerCase();
-            await runCommand(name, trimmed, {
-                session: sessionRef.current,
-                dispatch,
-                rows: rows ?? 24,
-                exit,
-                suspendTerminal,
-                openWizard,
-                openKeyEditor,
-                doExit,
-                setPickerState,
-                setConfirmState,
-                setInputText,
-            });
-            return;
-        }
-        setHistory((h) => [...h, trimmed]);
-        await sessionRef.current.send(trimmed);
+        // 发出去的消息永远属于主 Agent：停在子 Agent 视图上会让用户看不到自己的提问
+        setActiveAgentId("main");
+        noticeChannel.clear();
+        // 斜杠命令：命令名怎么解析、哪些命令会调用模型（要拦输入框），都来自命令元数据
+        const command = options.asMessage ? null : parseCommandInput(trimmed);
+        if (command) {
+            const name = command.name;
+            const blocksInput = commandBlocksInput(name);
+            if (blocksInput) {
+                setBusy(true);
+                setBusyCommand(name);
+            }
+            try {
+                await runCommand(name, trimmed, {
+                    session: sessionRef.current,
+                    notice: (text, tone) => noticeChannel.push(text, tone),
+                    clearTranscript,
+                    rows: rows ?? 24,
+                    exit,
+                    suspendTerminal,
+                    openWizard,
+                    openKeyEditor,
+                    doExit,
+                    restartProcess,
+                    setPickerState,
+                    setConfirmState,
+                    setInputText,
+                    setEffortView,
+                    refreshLocale: () => bumpLocale((n) => n + 1),
+                });
+            }
+            finally {
+                if (blocksInput) {
+                    setBusy(false);
+                    setBusyCommand(null);
+                }
+            }
+            return;
+        }
+        const base = sessionRef.current.messages.filter((m) => m.role === AgentNS.Role.User).length;
+        // 先取快照再清空：`send` 要用同一个数组，而输入区要立刻回到「没有附件」的状态
+        const images = pastedImages;
+        setPastedImages([]);
+        setPendingUser({ text: trimmed, base, images });
+        setBusy(true);
+        try {
+            await sessionRef.current.send(trimmed, images);
+        }
+        finally {
+            setBusy(false);
+            setPendingUser(null);
+        }
     };
     const doExit = () => {
-        // 会话已由 ConversationPersistPlugin 实时落盘，退出无需再询问是否保存
         exit("done");
     };
+    /**
+     * 真·重启进程（`/update` 装完新版本后调用）。
+     *
+     * 不能复用 `exit({ restart: true })`：那条路只是 `continue` 回 `mount(<Chat/>)`，
+     * 同一个进程、内存里还是旧模块图——对「磁盘上的代码变了」这种升级等于没装。
+     * 这里退到 shell 的视角：**spawn 一个新的自己**（新进程重新加载新 dist），
+     * 父进程在挂起态里等子进程退出，然后跟着退出。
+     *
+     * 三个必须注意的细节：
+     *
+     * 1. **在挂起态里退出**。`suspendTerminal` 的 `beginSuspend()` 会 `pauseInput()`
+     *    （raw 模式关闭），而 `endSuspend()` 会 `resumeInput()` 把它重新打开。若等
+     *    `suspendTerminal` 返回后再 `process.exit`，终端就停在 raw 模式，回到 shell
+     *    后按键全是乱码。所以子进程一结束就**就地**退出。
+     * 2. **先关鼠标上报**。`mount()` 按 Ink 实例开关它，而本实例此刻只是「挂起」并未
+     *    退出 —— 不关的话，子进程若异常死亡，终端会一直把滚轮写成转义序列。
+     * 3. **不转发 `process.argv.slice(2)`**。`ai --tui --new "..."` 那套是 shell 兜底
+     *    钩子的一次性载荷，重启时重放会把同一条提示词再发一遍。新进程按常规启动即
+     *    续接上一轮会话（重启前已落盘）。
+     */
+    const restartProcess = () => suspendTerminal(() => new Promise((resolve) => {
+        const entry = process.argv[1];
+        if (!entry) {
+            // 拿不到入口脚本（理论上不会发生）：不重启，退回 TUI，由调用方收尾
+            resolve();
+            return;
+        }
+        disableMouseTracking();
+        const child = spawn(process.execPath, [entry], { stdio: "inherit" });
+        child.on("error", () => process.exit(1));
+        child.on("exit", (code) => process.exit(code ?? 0));
+    }));
+    /** 本次会话已出现的子 Agent（渲染期现取；`sessionRef` 在首次渲染时为 null） */
+    const subAgentViews = sessionRef.current?.subAgents ?? [];
+    /**
+     * Agent 栏目切换（← / →）：在「主 Agent + 各子 Agent」之间循环。
+     *
+     * 键位分流见下方两个 `useInput`：输入框**为空**或**生成中**（输入框已被 Spinner 顶替）
+     * 时，左右键本来就无事可做，正好用来切换；输入框**有内容**时左右键仍然是移光标——
+     * 不能为了切栏目把文本编辑的左右移动废掉。
+     */
+    const switchAgentView = (dir) => {
+        const ids = ["main", ...subAgentViews.map((item) => item.id)];
+        // 旧 id 已失效（会话重建）时 indexOf 为 -1，归一后从主 Agent 起步
+        const current = Math.max(0, ids.indexOf(activeAgentId));
+        setActiveAgentId(ids[(current + dir + ids.length) % ids.length]);
+        scrollToBottom();
+    };
+    /**
+     * 两个 `useInput`（空闲 / 忙碌）共用的键位上下文 —— 判定逻辑在 common-keys.ts。
+     * 放这里而不是各自内联，是为了让「什么时候能滚、Ctrl+D 怎么退」只有一份定义。
+     */
+    const scrollKeys = { scrollByWheel, scrollByPage, scrollByLine };
+    const ctrlDExit = {
+        lastAt: ctrlDAtRef,
+        notify: () => noticeChannel.push(t("notice.pressCtrlDAgain")),
+        exit: doExit,
+    };
     // 输入处理
     useInput((char, key) => {
-        // 启动失败：给出「按 k 打开配置中心」的出路，而不是只能退出
+        // 按键诊断（AIZ_DEBUG_KEYS=1）：必须在任何 return 之前记录，否则被吞掉的键不会留痕
+        keyDebug(char, key);
         if (bootError) {
             if (char === "k" || char === "K") {
                 void openWizard({ kind: "menu" });
@@ -305,106 +580,184 @@ export function Chat(props) {
                 exit("done");
             return;
         }
-        // 终端应答序列（如 Kitty 查询应答 `[?0u`）不是用户输入，丢弃
-        if (isTerminalReply(char))
+        // 回看历史类按键（滚轮 / PgUp/PgDn / ⌘[ ⌘] / ⌘; ⌘' / Alt+V）与忙碌态共用
+        if (handleScrollKey(char, key, scrollKeys))
             return;
-        // 翻页滚动（回看历史）
-        if (key.pageUp) {
-            scrollByPage(-1);
-            return;
-        }
-        if (key.pageDown) {
-            scrollByPage(1);
-            return;
-        }
-        // 换行：Ctrl+Enter / Alt+Enter / Shift+Enter
-        // （仅当终端**原生**以 Kitty CSI-u 序列上报这些组合键时才生效 —— 本 CLI 不再
-        //   主动查询/开启该协议，见 tui/index.tsx 的 RENDER_OPTIONS；换行主推 Ctrl+N）
         if (key.return && (key.ctrl || key.meta || key.shift)) {
             insertAtCursor("\n");
             return;
         }
         if (char === "c" && key.ctrl) {
+            // Claude Code：生成中中断；空闲时有草稿就先清空，已空则退出
             if (busy)
                 sessionRef.current?.abort();
+            else if (input.length > 0) {
+                setInputText("");
+                noticeChannel.push(t("notice.inputCleared"));
+            }
             else
                 void doExit();
             return;
         }
-        if (char === "d" && key.ctrl) {
-            void doExit();
+        if (char === "d" && key.ctrl && input.length > 0) {
+            // Claude Code：有草稿时删光标后一个字符（空闲态独有）
+            deleteAfterCursor();
             return;
         }
+        if (handleCtrlDExit(char, key, ctrlDExit))
+            return;
         if (char === "l" && key.ctrl) {
-            exit({ restart: true, messages: sessionRef.current?.messages, clearTranscript: true });
+            clearTranscript();
             return;
         }
+        // ---- kill / yank / undo / stash（照抄 Claude Code / readline）----
         if (char === "u" && key.ctrl) {
-            setInputText("");
+            // 删到行首。macOS 上 ⌘⌫ 会被终端映射成 Ctrl+U，故不能做成「清空全部」
+            deleteToStartOfLine();
+            return;
+        }
+        if (char === "k" && key.ctrl) {
+            deleteToEndOfLine();
+            return;
+        }
+        if (char === "w" && key.ctrl) {
+            // 删到前一空白（标点不切分：`src/utils/foo.ts` 一次删完）
+            deletePrevWhitespace();
+            return;
+        }
+        if (char === "y" && key.ctrl) {
+            yank(false);
+            return;
+        }
+        if (char === "y" && key.meta) {
+            yank(true);
+            return;
+        }
+        // Ctrl+_ / Ctrl+Shift+-：撤销上一次输入编辑
+        if ((char === "_" && key.ctrl) || (char === "-" && key.ctrl && key.shift)) {
+            undoEdit();
+            return;
+        }
+        if (char === "s" && key.ctrl) {
+            toggleStash();
+            return;
+        }
+        if ((char === "v" && key.ctrl) || (key.super && (char === "v" || char === "V"))) {
+            // 剪贴板里有图片就附在消息上（发送时转成内容块），没有就退回粘贴文本
+            void pasteClipboard();
+            return;
+        }
+        // readline 的行首 / 行尾（macOS 上部分终端把 ⌘← / ⌘→ 发成 ^A / ^E）
+        if (char === "a" && key.ctrl) {
+            moveCursorToLineStart();
+            return;
+        }
+        if (char === "e" && key.ctrl) {
+            moveCursorToLineEnd();
             return;
         }
         if (char === "j" && key.ctrl) {
             insertAtCursor("\n");
             return;
         }
-        // 换行：Ctrl+N（不依赖终端协议，兼容性最好）
-        if (char === "n" && key.ctrl) {
-            insertAtCursor("\n");
+        // Ctrl+P / Ctrl+N：历史上下（Claude Code 语义；换行改用 Ctrl+J / Alt+Enter）
+        if ((char === "p" && key.ctrl) || (char === "n" && key.ctrl)) {
+            const up = char === "p";
+            if (menuCount > 0) {
+                // 同上：视觉「上」（Ctrl+P）是 +1
+                setMenuIndex((i) => (up ? (i + 1) % menuCount : (i - 1 + menuCount) % menuCount));
+                return;
+            }
+            if (up)
+                historyPrev();
+            else
+                historyNext();
+            return;
+        }
+        // 按词删除：Alt+Backspace / Ctrl+Backspace 删前一个词；Alt+D / Ctrl+Delete 删后一个词。
+        // 必须在下面「单字符 Backspace/Delete」之前判定，否则带修饰键的删除只掉一个字符。
+        if (key.backspace && (key.ctrl || key.meta || key.super)) {
+            deleteWordBeforeCursor();
+            return;
+        }
+        if (key.delete && (key.ctrl || key.meta || key.super)) {
+            deleteWordAfterCursor();
+            return;
+        }
+        if (char === "d" && key.meta) {
+            deleteWordAfterCursor();
             return;
         }
         if (key.return) {
-            // 斜杠候选菜单可见时回车直接执行高亮命令，避免把半截输入（如仅 `/`）当命令提交
+            // `@` 菜单开着时回车 = 补全（不发送）：让「选完继续接着写」成为默认动作，
+            // 否则选完就得再敲一个空格才能换行/继续，很容易误发半截消息。
+            if (mention && fileMatches.length > 0) {
+                completeMentionSelection();
+                return;
+            }
             void runSubmit(resolveSubmitText(input, hints, menuIndex));
             return;
         }
-        if (key.tab && hints.length > 0) {
+        if (key.tab && menuCount > 0) {
+            if (mention) {
+                completeMentionSelection();
+                return;
+            }
             setInputText(`/${hints[menuIndex]?.names[0] ?? ""} `);
             return;
         }
         if (key.upArrow || key.downArrow) {
-            // Shift / Alt + ↑↓：单行滚动（优先于历史召回）
             if (key.shift || key.meta) {
                 scrollByLine(key.upArrow ? -1 : 1);
                 return;
             }
-            if (hints.length > 0) {
-                setMenuIndex((i) => key.upArrow ? (i - 1 + hints.length) % hints.length : (i + 1) % hints.length);
+            if (menuCount > 0) {
+                // 底部锚定菜单里**下标大 = 视觉靠上**（`items[0]` 贴着输入框，越往后越往上），
+                // 所以视觉「上」是 +1、视觉「下」是 −1；取模环绕：到顶溢出回到底部、到底溢出回到顶部。
+                // 写反了方向就与视觉相反 —— 只有 ≥ 3 条候选时才能从测试里看出来。
+                setMenuIndex((i) => key.upArrow ? (i + 1) % menuCount : (i - 1 + menuCount) % menuCount);
                 return;
             }
-            // 历史召回
-            if (key.upArrow && history.length > 0) {
-                const idx = historyIndex.current < 0 ? history.length - 1 : Math.max(0, historyIndex.current - 1);
-                historyIndex.current = idx;
-                setInputText(history[idx]);
-            }
-            else if (key.downArrow && historyIndex.current >= 0) {
-                const idx = historyIndex.current + 1;
-                if (idx >= history.length) {
-                    historyIndex.current = -1;
-                    setInputText("");
-                }
-                else {
-                    historyIndex.current = idx;
-                    setInputText(history[idx]);
-                }
-            }
+            // 多行输入：先按**视觉行**走光标（含软折行，宽度与渲染一致），走到首/末行才翻历史
+            const wrapWidth = Math.max(4, (columns ?? 80) - 4);
+            if (key.upArrow ? moveCursorUpRow(wrapWidth) : moveCursorDownRow(wrapWidth))
+                return;
+            if (key.upArrow)
+                historyPrev();
+            else
+                historyNext();
+            return;
+        }
+        // Agent 栏目：输入框为空时光标停在 0，←/→ 本无作用 → 拿来切换主 / 子 Agent
+        if ((key.leftArrow || key.rightArrow) && input.length === 0 && subAgentViews.length > 0) {
+            switchAgentView(key.leftArrow ? -1 : 1);
             return;
         }
-        // 光标移动：← → 单字符，Ctrl/Alt+← → 跨词，Home / End 到行首 / 行尾
         if (key.leftArrow) {
-            if (key.ctrl || key.meta)
-                setCursor(wordLeft(input, cursor));
+            if (key.ctrl || key.meta || key.super)
+                moveCursorByWord(-1);
             else
                 moveCursor(-1);
             return;
         }
         if (key.rightArrow) {
-            if (key.ctrl || key.meta)
-                setCursor(wordRight(input, cursor));
+            if (key.ctrl || key.meta || key.super)
+                moveCursorByWord(1);
             else
                 moveCursor(1);
             return;
         }
+        // 跨词移动的「兜底键」：macOS 上 Option+←/→ 往往发的是 ESC b / ESC f
+        // （readline 的 backward-word / forward-word），并不带 leftArrow 标记；
+        // 而 Ctrl+←/→ 常被系统「Mission Control → 左右切换空间」截走，应用根本收不到。
+        if (char === "b" && key.meta) {
+            moveCursorByWord(-1);
+            return;
+        }
+        if (char === "f" && key.meta) {
+            moveCursorByWord(1);
+            return;
+        }
         if (key.home) {
             moveCursorToLineStart();
             return;
@@ -414,8 +767,25 @@ export function Chat(props) {
             return;
         }
         if (key.escape) {
-            setInputText("");
-            scrollToBottom();
+            // `@` 菜单开着时，Esc 只关菜单：清草稿太粗暴（`@` 打一半按 Esc 会连正文一起没）
+            if (mention && menuWant > 0) {
+                setMentionOff(true);
+                return;
+            }
+            // 有附件时先清附件（草稿保留）——误粘一张图后总得有个退路，
+            // 而又不能为了这个把 ESC 变成「清空一切」的随机键
+            if (!busy && pastedImages.length > 0) {
+                setPastedImages([]);
+                noticeChannel.push(t("notice.imagesCleared"));
+                return;
+            }
+            // Claude Code：生成中 Esc = 中断本轮；否则清空草稿并回到底部
+            if (busy)
+                sessionRef.current?.abort();
+            else {
+                setInputText("");
+                scrollToBottom();
+            }
             return;
         }
         if (key.backspace) {
@@ -426,70 +796,195 @@ export function Chat(props) {
             deleteAfterCursor();
             return;
         }
-        if (char && !key.ctrl && !key.meta) {
+        if (char && !key.ctrl && !key.meta && !key.super) {
             insertAtCursor(char);
         }
-    }, { isActive: !confirmState && !pickerState && !wizardStep });
+    }, 
+    // 生成 / 自动迁移期间主输入框整体失活：此时输入框已被 Spinner 顶替，若仍激活，
+    // 按键会被静默吞进隐藏的输入缓冲、待本轮结束后才冒出来（即「迁移过程中输入框
+    // 没被拦住」）。失活后改由下方「忙碌期」处理器只放行中止 / 退出 / 回看滚动。
+    { isActive: !busy && !confirmState && !pickerState && !wizardStep });
+    // 忙碌期（生成 / 迁移中）专用：输入框不可编辑，仅保留「中止(Ctrl+C) / 退出(Ctrl+D) / 回看滚动」。
+    useInput((char, key) => {
+        keyDebug(char, key);
+        // 忙碌期只剩「中止 / 退出 / 回看」，滚轮同样生效（生成时正是最想往回看的时机）
+        if (handleScrollKey(char, key, scrollKeys))
+            return;
+        if (char === "c" && key.ctrl) {
+            sessionRef.current?.abort();
+            return;
+        }
+        if (key.escape) {
+            // 忙碌期 Esc 也充当「中断」（与 Claude Code 一致）
+            sessionRef.current?.abort();
+            return;
+        }
+        if (handleCtrlDExit(char, key, ctrlDExit))
+            return;
+        if ((key.upArrow || key.downArrow) && (key.shift || key.meta || key.super)) {
+            scrollByLine(key.upArrow ? -1 : 1);
+            return;
+        }
+        // Agent 栏目：生成中输入框已失活，←/→ 空闲 → 直接切换（此时最想看子 Agent 在干什么）
+        if ((key.leftArrow || key.rightArrow) && subAgentViews.length > 0) {
+            switchAgentView(key.leftArrow ? -1 : 1);
+            return;
+        }
+        if (char === "v" && key.super) {
+            scrollByPage(-1);
+            return;
+        }
+    }, { isActive: busy && !confirmState && !pickerState && !wizardStep });
     // 配置向导：整屏接管（凭据设置 / 配置中心），关闭后回到对话屏
     if (wizardStep && wizardConfig) {
-        return (_jsx(ConfigWizard, { config: wizardConfig, initialStep: wizardStep, closeOnSave: wizardStep.kind !== "menu", agents: wizardAgents, mcp: wizardMcp ?? undefined, agentStore: wizardAgentStore ?? undefined, onSave: saveConfig, onSaveMcp: async (scope, cfg) => {
-                await writeMcpConfig(cfg, scope);
+        return (_jsx(ConfigWizard, { config: wizardConfig, reasoningPresets: wizardPresets, initialStep: wizardStep, closeOnSave: wizardStep.kind !== "menu", agents: wizardAgents, mcp: wizardMcp ?? undefined, agentStore: wizardAgentStore ?? undefined, onSave: deps.saveConfig, onSaveMcp: async (scope, cfg) => {
+                await deps.writeMcpConfig(cfg, scope);
             }, onClose: closeWizard }));
     }
     if (bootError) {
         setCursorPosition(undefined);
-        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { color: theme.error, wrap: "truncate", children: ["\u2716 \u65E0\u6CD5\u542F\u52A8\u5BF9\u8BDD\uFF1A", bootError] }), _jsx(Text, { color: theme.dim, wrap: "truncate", children: "\u6309 k \u6253\u5F00\u914D\u7F6E\u4E2D\u5FC3\uFF08\u53EF\u8BBE\u7F6E API Key / \u7AEF\u70B9\u5730\u5740\uFF09\u00B7 Enter \u8FD4\u56DE" })] }));
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { color: theme.error, wrap: "truncate", children: t("chat.bootFailed", { error: bootError }) }), _jsx(Text, { color: theme.dim, wrap: "truncate", children: t("chat.bootHint") })] }));
     }
     const session = sessionRef.current;
-    const tokens = session?.lastUsage?.total_tokens;
+    const lastTokens = session?.lastUsage?.total_tokens;
+    const totalTokens = session?.totalUsage.total_tokens;
     const cols = columns ?? 80;
+    const messages = session?.messages ?? [];
+    const subAgents = session?.subAgents ?? [];
+    /** 当前查看的子 Agent；不在列表里（会话重建后 id 失效）时回落到主 Agent */
+    const activeSub = subAgents.find((item) => item.id === activeAgentId) ?? null;
+    const userCount = messages.filter((m) => m.role === AgentNS.Role.User).length;
+    // 乐观回显只属于主 Agent 的视图（子 Agent 不会收到用户直接发的消息）
+    const showPending = !activeSub && pendingUser != null && userCount <= pendingUser.base;
+    // 子 Agent 视图读它**自己**的 messages（从第 0 条起，不受主会话 /clear 的显示起点影响）
+    const transcript = transcriptLines(activeSub ? activeSub.agent.messages : messages.slice(transcriptFrom), cols);
+    if (showPending) {
+        // 带粘贴图片的消息：乐观回显要与实际发送的结构一致（文本段 + 图片占位块），
+        // 否则图片那几条会在真实消息落地前「消失」一下。
+        const images = pendingUser.images ?? [];
+        transcript.push(...messageToLines({
+            id: "__pending_user",
+            role: AgentNS.Role.User,
+            content: images.length > 0
+                ? [
+                    { type: "text", text: pendingUser.text },
+                    ...images.map(() => ({ type: "image_url", image_url: { url: "" } })),
+                ]
+                : pendingUser.text,
+        }, cols));
+    }
+    const noticeTextLines = noticeLines(notices, cols);
+    /** Agent 栏目条目：无子 Agent 时整条栏目不存在（不占高度、也不接管左右键） */
+    const agentTabs = subAgents.length > 0
+        ? [
+            { id: "main", label: t("agentTabs.main") },
+            ...subAgents.map((item) => ({
+                id: item.id,
+                label: t("agentTabs.sub", { n: item.index }),
+                status: item.status,
+            })),
+        ]
+        : [];
+    const activeTabId = activeSub ? activeSub.id : "main";
+    const agentTabLines = agentTabs.length > 0 ? AGENT_TABS_LINES : 0;
+    // 状态栏：先按当前状态算出「折行后实际几行」，交给布局预留高度（否则窄屏下一旦提示折行，
+    // 整帧就会高出一行，把输入框顶出屏幕）。这里用 `viewTop` 状态判断滚动，而不是
+    // `layout.scrolled` —— 后者要等布局算完才有，会与行数测量形成循环。
+    const statusProps = {
+        model: modelId,
+        agent: props.agentId ?? "default",
+        effort: effortView?.text ?? null,
+        effortDimmed: effortView?.dimmed ?? false,
+        lastTokens,
+        totalTokens,
+        busy,
+        hint: !ready
+            ? t("input.hint.initializing")
+            : viewTop != null
+                ? t("input.hint.scrolling")
+                : t("input.hint.ready"),
+        rate,
+        columns: cols,
+    };
+    const statusRows = statusBarRows(statusProps, cols);
+    /** 附件提示行：有粘贴图片时占 1 行（与 `computeChatLayout` 的 `attachmentLines` 同一个判据） */
+    const attachmentLines = pastedImages.length > 0 ? 1 : 0;
     const layout = computeChatLayout({
         columns: cols,
         rows: usableFrameRows(rows ?? 24),
-        blocks: state.blocks,
-        live: state.live,
+        transcript,
         input,
         busy,
-        hintCount: hints.length,
+        hintCount: menuWant,
+        noticeCount: noticeTextLines.length,
+        attachmentLines,
+        agentTabLines,
         overlay: confirmState ? "confirm" : pickerState ? "picker" : "none",
         pickerItems: pickerState?.items.length ?? 0,
         viewTop,
+        statusBarLines: statusRows.length,
     });
     layoutRef.current = layout;
     const isPlaceholder = input.length === 0;
-    const inputLayout = layoutInput(isPlaceholder ? "输入消息，/ 查看命令…" : input, isPlaceholder ? 0 : cursor, Math.max(4, cols - 4));
+    const inputLayout = layoutInput(isPlaceholder ? t("input.placeholder") : input, isPlaceholder ? 0 : cursor, Math.max(4, cols - 4));
     const bodyLines = inputLayout.lines;
-    // 把终端硬件光标移到编辑光标处，让 IME（输入法）候选框正确定位
+    /**
+     * 输入区可见窗口：最多 `INPUT_MAX_ROWS` 行，且**跟随光标**（与 `computeChatLayout`
+     * 的 `inputHeight` 同源）。`cursorRowIndex` 是**窗口内**的行号 —— 渲染用哪一行、
+     * 硬件光标 y 都基于它；用全文本的行号会让 IME 候选框跑到屏外。
+     */
+    const inputWin = inputWindow(bodyLines.length, inputLayout.cursorRow);
+    const shownLines = bodyLines.slice(inputWin.from, inputWin.to);
+    // 光标所在行的三段拆分（与 `CursorInputRow` 的渲染一一对应）
+    const cursorRowIndex = inputLayout.cursorRow - inputWin.from;
+    const cursorRowChars = graphemes(shownLines[cursorRowIndex] ?? "");
+    const cursorColInRow = Math.min(inputLayout.cursorCol, cursorRowChars.length);
+    const cursorBefore = cursorRowChars.slice(0, cursorColInRow).join("");
+    const cursorAt = cursorRowChars[cursorColInRow] ?? " ";
+    const cursorAfter = cursorRowChars.slice(cursorColInRow + 1).join("");
+    /** 实测结果的身份标记：输入段落一改，上一帧的实测值就作废 */
+    const cursorKey = `${cursorRowIndex}\u0000${cursorBefore}\u0000${cursorAt}\u0000${cursorAfter}`;
+    /** 渲染后实测（值不变则不会重渲染）；闭包捕获当帧的 key，保证标的是「这一帧」的结果 */
+    const onCursorMeasure = (position) => {
+        setImePosition((prev) => prev && prev.position.x === position.x && prev.position.y === position.y
+            ? prev
+            : { key: cursorKey, position });
+    };
+    // 把终端硬件光标移到编辑光标处，让 IME（输入法）候选框正确定位：
+    // 首选「渲染器实测」（宽字符 / emoji 的宽度由 Ink 自己算，不会偏）；
+    // 首次渲染还没量到时，退回手算值顶一帧（下一帧即被实测值纠正）。
     if (!busy && !confirmState && !pickerState) {
-        setCursorPosition(computeInputCursorPosition({
-            transcriptLines: layout.lines.length,
-            hintCount: hints.length,
-            cursorRow: inputLayout.cursorRow,
-            cursorCol: inputLayout.cursorCol,
-            lineText: bodyLines[inputLayout.cursorRow] ?? "",
-            placeholder: isPlaceholder,
-        }));
+        const measured = imePosition && imePosition.key === cursorKey ? imePosition.position : null;
+        setCursorPosition(measured ??
+            computeInputCursorPosition({
+                transcriptLines: layout.lines.length,
+                // Agent 栏目与通知栏都夹在对话区与输入行之间：漏算会让硬件光标整体偏上
+                agentTabCount: agentTabLines,
+                noticeCount: noticeTextLines.length,
+                attachmentCount: attachmentLines,
+                hintCount: layout.hintRows,
+                cursorRow: cursorRowIndex,
+                cursorCol: inputLayout.cursorCol,
+                lineText: bodyLines[inputLayout.cursorRow] ?? "",
+                placeholder: isPlaceholder,
+            }));
     }
     else {
         setCursorPosition(undefined);
     }
-    return (_jsxs(Box, { flexDirection: "column", width: cols, children: [layout.lines.map((line) => (_jsx(LineView, { line: line }, line.key))), confirmState ? (_jsx(Confirm, { question: confirmState.question, onAnswer: resolveConfirm })) : pickerState ? (_jsx(PickerOverlay, { title: pickerState.title, items: pickerState.items, columns: cols, onPick: resolvePicker })) : (_jsxs(Box, { flexDirection: "column", children: [hints.length > 0 ? _jsx(SlashMenu, { hints: hints, selected: menuIndex }) : null, _jsx(Box, { paddingX: 1, children: _jsx(Text, { color: theme.border, wrap: "truncate", children: "─".repeat(Math.max(1, cols - 2)) }) }), _jsx(Box, { flexDirection: "column", paddingX: 1, children: busy ? (_jsx(Spinner, { label: "\u601D\u8003\u4E2D\u2026" })) : (bodyLines.map((line, i) => {
-                            const prompt = i === 0 ? (_jsx(Text, { color: theme.brand[0], bold: true, children: "❯ " })) : (_jsx(Text, { children: "  " }));
+    return (_jsxs(Box, { flexDirection: "column", width: cols, children: [layout.lines.map((line) => (_jsx(LineView, { line: line }, line.key))), confirmState ? (_jsx(Confirm, { question: confirmState.question, onAnswer: resolveConfirm })) : pickerState ? (_jsx(PickerOverlay, { title: pickerState.title, items: pickerState.items, columns: cols, onPick: resolvePicker })) : (_jsxs(Box, { flexDirection: "column", children: [agentTabs.length > 0 ? _jsx(AgentTabs, { tabs: agentTabs, activeId: activeTabId }) : null, _jsx(NoticeBar, { lines: noticeTextLines }), attachmentLines > 0 ? _jsx(PastedImagesBar, { count: pastedImages.length }) : null, menuWant > 0 ? (_jsx(BottomMenu, { items: menuItems, selected: menuIndex, maxRows: layout.hintRows, columns: cols, topLine: scanningFiles ? t("mention.scanning") : undefined })) : null, _jsx(Box, { paddingX: 1, children: _jsx(Text, { color: theme.border, wrap: "truncate", children: "─".repeat(Math.max(1, cols - 2)) }) }), _jsx(Box, { flexDirection: "column", paddingX: 1, children: busy ? (_jsx(Spinner, { label: busySpinnerLabel(sessionRef.current?.phase ?? null, busyCommand) })) : (shownLines.map((line, i) => {
+                            const prompt = i === 0 && inputWin.from === 0 ? (_jsx(Text, { color: theme.brand[0], bold: true, children: "❯ " })) : (_jsx(Text, { children: "  " }));
                             if (isPlaceholder) {
-                                return (_jsxs(Text, { wrap: "truncate", children: [prompt, _jsx(Text, { color: theme.faint, children: line }), i === bodyLines.length - 1 ? (_jsx(Text, { color: theme.brand[1], children: "\u258F" })) : null] }, i));
+                                // 占位态不画「假光标」（那个行尾的 ▏）：硬件光标这时就停在提示语开头
+                                // （x = 前缀宽），终端自己会把它显示出来；再画一个方块等于屏幕上两个光标，
+                                // 而且位置还在提示语末尾，反而误导。
+                                return (_jsxs(Text, { wrap: "truncate", children: [prompt, _jsx(Text, { color: theme.faint, children: line })] }, i));
                             }
-                            if (i === inputLayout.cursorRow) {
-                                const rowChars = Array.from(line);
-                                const before = rowChars.slice(0, inputLayout.cursorCol).join("");
-                                const at = rowChars[inputLayout.cursorCol];
-                                const after = rowChars.slice(inputLayout.cursorCol + 1).join("");
-                                return (_jsxs(Text, { wrap: "truncate", children: [prompt, _jsx(Text, { children: before }), _jsx(Text, { inverse: true, color: theme.brand[0], children: at ?? " " }), _jsx(Text, { children: after })] }, i));
+                            // 光标行：把光标字符包成独立节点，渲染后由渲染器给出真实坐标（IME 定位）
+                            if (i === cursorRowIndex) {
+                                return (_jsx(CursorInputRow, { firstLine: i === 0, before: cursorBefore, at: cursorAt, after: cursorAfter, onMeasure: onCursorMeasure }, i));
                             }
                             return (_jsxs(Text, { wrap: "truncate", children: [prompt, _jsx(Text, { children: line })] }, i));
-                        })) })] })), _jsx(StatusBar, { model: props.modelId, agent: props.agentId ?? "default", tokens: tokens, busy: busy, hint: !ready
-                    ? "初始化中…"
-                    : layout.scrolled
-                        ? "↕ 滚动中 · PgUp/PgDn 翻页 · 发送回到底部"
-                        : "Enter 发送 · Ctrl+N 换行 · / 命令 · PgUp 看历史" })] }));
+                        })) })] })), _jsx(StatusBar, { ...statusProps })] }));
 }
 //# sourceMappingURL=chat.js.map