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

package/dist/tui/screens/chat.js

@@ -1,30 +1,42 @@
 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 { 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, SlashMenu } 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, 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 { computeInputCursorPosition } from "./input.js";
 import { computeChatLayout } from "./layout.js";
-import { chatReducer } from "./state.js";
-import { LineView, messagesToBlocks } from "./render.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 { 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 { handleCtrlDExit, handleScrollKey } from "./common-keys.js";
 /**
  * 计算回车时应提交的文本。
  *
  * 斜杠候选菜单可见时（输入以 `/` 开头且尚未输入参数），回车应**直接执行高亮命令**，
  * 而不是提交半截输入 —— 否则用户只输入 `/` 或未补全的命令名时，回车会落到
  * 「未知命令」报错（体验很差）。非命令输入原样返回。
- *
- * `menuIndex` 越界时回落到最后一项，避免菜单看似有选中却回车落空。
  */
 export function resolveSubmitText(input, hints, menuIndex) {
     const slash = input.startsWith("/") && !input.includes("\n") && !input.includes(" ");
@@ -38,263 +50,273 @@ export function Chat(props) {
     const { exit, suspendTerminal } = useApp();
     const { setCursorPosition } = useCursor();
     const { columns, rows } = useWindowSize();
-    const [state, dispatch] = useReducer(chatReducer, {
-        blocks: 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);
+    /** 生成速率快照（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);
+    /** 转录显示起点（/clear 清屏用：隐藏此索引之前的消息，但不改上下文） */
+    const [transcriptFrom, setTranscriptFrom] = useState(0);
+    /** 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]);
+    /**
+     * 配置向导宿主（凭据 / 配置中心）：整屏接管与「关闭后让改动生效」见
+     * 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"));
+        },
+    });
+    /**
+     * 重挂载附带的系统提示（如 `/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([readConfig(), readAgentStore(), 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;
+        const notifier = {
+            onChange: (immediate) => {
+                if (disposed)
+                    return;
+                frameBufferRef.current?.push(null, immediate);
+            },
+            onNotice: (text, tone) => {
+                if (!disposed)
+                    noticeChannel.push(text, tone);
+            },
+        };
         ChatSession.create({
-            modelId: props.modelId,
             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;
-        });
-    };
-    const resolvePicker = (value) => {
-        setPickerState((ps) => {
-            ps?.resolve(value);
-            return null;
-        });
-    };
-    // ---- 配置向导（凭据 / 配置中心）----
-    /** 打开配置向导：先取配置 / 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 检查配置`,
-                });
-                return;
-            }
-            currentEndpointRef.current = credential.endpointId;
-            setWizardConfig(config);
-            setWizardStep({ kind: "edit", field: "apiKey", endpointId: credential.endpointId });
-        }
-        catch (error) {
-            dispatch({ type: "error", text: `读取配置失败：${error?.message ?? error}` });
-        }
-    };
-    /** 向导关闭：渲染变更摘要；若改到当前端点则重建会话（消息保留） */
-    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}` }));
-        }
-    };
-    // ---- 滚动视口控制（应用内翻页，回看历史）----
-    /** 跳到指定顶部行；越界钳制；一旦贴到底部则恢复「自动跟随」 */
-    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)
-            return;
-        scrollTo(L.viewTop + dir * Math.max(1, L.budget - 1));
-    };
-    /** 单行滚动（dir：-1 上 / +1 下） */
-    const scrollByLine = (dir) => {
-        const L = layoutRef.current;
-        if (!L)
-            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)
+    // 速率采样：Spinner 的重渲染只影响它自己，不会带着状态栏一起刷，所以生成中要自己定时读快照。
+    // 生成结束（busy → false）时再读一次，拿本轮平均速率并留在状态栏上。
+    useEffect(() => {
+        const read = () => setRate(sessionRef.current?.rateSample ?? null);
+        read();
+        if (!busy)
             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);
+        const timer = setInterval(read, 250);
+        return () => clearInterval(timer);
+    }, [busy]);
+    /** 清屏但保留上下文：把显示起点推到当前消息末尾 */
+    const clearTranscript = () => {
+        setTranscriptFrom(sessionRef.current?.messages.length ?? 0);
+        noticeChannel.clear();
     };
+    /**
+     * 输入编辑（文本 / 光标 / 历史 / kill ring / undo / stash）：
+     * 全部语义在 use-input-editing.ts，这里只把通知出口接上。
+     */
+    const { input, cursor, setInputText, insertAtCursor, deleteBeforeCursor, deleteAfterCursor, deleteWordBeforeCursor, deleteWordAfterCursor, deleteToStartOfLine, deleteToEndOfLine, deletePrevWhitespace, yank, undoEdit, toggleStash, moveCursor, moveCursorToLineStart, moveCursorToLineEnd, moveCursorByWord, historyPrev, historyNext, clearDraft, rememberSubmitted, } = useInputEditing({
+        initialText: props.initialInput,
+        notify: (text, tone) => noticeChannel.push(text, tone),
+    });
+    /** 斜杠候选菜单的高亮索引；输入一变就回到第一个候选 */
+    const [menuIndex, setMenuIndex] = useState(0);
+    useEffect(() => {
+        setMenuIndex(0);
+    }, [input]);
     // 命令候选人
     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);
+        noticeChannel.clear();
+        // 斜杠命令：命令名怎么解析、哪些命令会调用模型（要拦输入框），都来自命令元数据
+        const command = options.asMessage ? null : parseCommandInput(trimmed);
+        if (command) {
+            const name = command.name;
+            const blocksInput = commandBlocksInput(name);
+            if (blocksInput)
+                setBusy(true);
+            try {
+                await runCommand(name, trimmed, {
+                    session: sessionRef.current,
+                    notice: (text, tone) => noticeChannel.push(text, tone),
+                    clearTranscript,
+                    rows: rows ?? 24,
+                    exit,
+                    suspendTerminal,
+                    openWizard,
+                    openKeyEditor,
+                    doExit,
+                    setPickerState,
+                    setConfirmState,
+                    setInputText,
+                    setEffortView,
+                    refreshLocale: () => bumpLocale((n) => n + 1),
+                });
+            }
+            finally {
+                if (blocksInput)
+                    setBusy(false);
+            }
+            return;
+        }
+        rememberSubmitted(trimmed);
+        const base = sessionRef.current.messages.filter((m) => m.role === AgentNS.Role.User).length;
+        setPendingUser({ text: trimmed, base });
+        setBusy(true);
+        try {
+            await sessionRef.current.send(trimmed);
+        }
+        finally {
+            setBusy(false);
+            setPendingUser(null);
+        }
     };
     const doExit = () => {
-        // 会话已由 ConversationPersistPlugin 实时落盘，退出无需再询问是否保存
         exit("done");
     };
+    /**
+     * 两个 `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" });
@@ -304,55 +326,114 @@ export function Chat(props) {
                 exit("done");
             return;
         }
-        // 终端应答序列（如 Kitty 查询应答 `[?0u`）不是用户输入，丢弃
-        if (isTerminalReply(char))
-            return;
-        // 翻页滚动（回看历史）
-        if (key.pageUp) {
-            scrollByPage(-1);
-            return;
-        }
-        if (key.pageDown) {
-            scrollByPage(1);
+        // 回看历史类按键（滚轮 / PgUp/PgDn / ⌘[ ⌘] / ⌘; ⌘' / Alt+V）与忙碌态共用
+        if (handleScrollKey(char, key, scrollKeys))
             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"))) {
+            // 图片粘贴暂未支持：需要先做「文件 → 内容块」的能力探测（见后续迭代）
+            noticeChannel.push(t("notice.pasteImageUnsupported"), "error");
+            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 (hints.length > 0) {
+                setMenuIndex((i) => (up ? (i - 1 + hints.length) % hints.length : (i + 1) % hints.length));
+                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) {
-            // 斜杠候选菜单可见时回车直接执行高亮命令，避免把半截输入（如仅 `/`）当命令提交
             void runSubmit(resolveSubmitText(input, hints, menuIndex));
             return;
         }
@@ -361,7 +442,6 @@ export function Chat(props) {
             return;
         }
         if (key.upArrow || key.downArrow) {
-            // Shift / Alt + ↑↓：单行滚动（优先于历史召回）
             if (key.shift || key.meta) {
                 scrollByLine(key.upArrow ? -1 : 1);
                 return;
@@ -370,40 +450,37 @@ export function Chat(props) {
                 setMenuIndex((i) => key.upArrow ? (i - 1 + hints.length) % hints.length : (i + 1) % hints.length);
                 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]);
-                }
-            }
+            if (key.upArrow)
+                historyPrev();
+            else
+                historyNext();
             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;
@@ -413,8 +490,13 @@ export function Chat(props) {
             return;
         }
         if (key.escape) {
-            setInputText("");
-            scrollToBottom();
+            // Claude Code：生成中 Esc = 中断本轮；否则清空草稿并回到底部
+            if (busy)
+                sessionRef.current?.abort();
+            else {
+                setInputText("");
+                scrollToBottom();
+            }
             return;
         }
         if (key.backspace) {
@@ -425,70 +507,151 @@ 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;
+        }
+        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) => {
+        return (_jsx(ConfigWizard, { config: wizardConfig, reasoningPresets: wizardPresets, initialStep: wizardStep, closeOnSave: wizardStep.kind !== "menu", agents: wizardAgents, mcp: wizardMcp ?? undefined, agentStore: wizardAgentStore ?? undefined, onSave: saveConfig, onSaveMcp: async (scope, cfg) => {
                 await 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 userCount = messages.filter((m) => m.role === AgentNS.Role.User).length;
+    const showPending = pendingUser != null && userCount <= pendingUser.base;
+    const transcript = transcriptLines(messages.slice(transcriptFrom), cols);
+    if (showPending) {
+        transcript.push(...messageToLines({ id: "__pending_user", role: AgentNS.Role.User, content: pendingUser.text }, cols));
+    }
+    const noticeTextLines = noticeLines(notices, cols);
+    // 状态栏：先按当前状态算出「折行后实际几行」，交给布局预留高度（否则窄屏下一旦提示折行，
+    // 整帧就会高出一行，把输入框顶出屏幕）。这里用 `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);
     const layout = computeChatLayout({
         columns: cols,
         rows: usableFrameRows(rows ?? 24),
-        blocks: state.blocks,
-        live: state.live,
+        transcript,
         input,
         busy,
         hintCount: hints.length,
+        noticeCount: noticeTextLines.length,
         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（输入法）候选框正确定位
+    // 光标所在行的三段拆分（与 `CursorInputRow` 的渲染一一对应）
+    const cursorRowIndex = inputLayout.cursorRow;
+    const cursorRowChars = graphemes(bodyLines[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,
+                // 通知栏夹在对话区与斜杠菜单之间：漏算会让硬件光标整体偏上（多行通知如 /help 最明显）
+                noticeCount: noticeTextLines.length,
+                hintCount: hints.length,
+                cursorRow: inputLayout.cursorRow,
+                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) => {
+    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: [_jsx(NoticeBar, { lines: noticeTextLines }), 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 ? (
+                        // 阶段随 SDK 事件推进：连接中 → 排队中 → 思考 / 输出 / 调用工具 → 等工具返回。
+                        // 渲染期现取（不另存 state）：chunk 与轮次边界都会触发重渲染，
+                        // 而 `busy` 置 true 本身也会重渲一次，捕得到首轮的「连接中」。
+                        _jsx(Spinner, { label: phaseLabel(sessionRef.current?.phase ?? null) })) : (bodyLines.map((line, i) => {
                             const prompt = i === 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