minimal-agent 0.5.3 → 0.5.5

package/src/loop.js

@@ -15,18 +15,23 @@
  *    a. 自动压缩检查（防止 context 撑爆）
  *    b. 调 LLM，把流式响应组装成完整的 assistant message
  *    c. 如果 assistant 不调工具 → 结束，return
- *    d. 否则按顺序执行每个工具调用，把 tool 消息追加到历史
+ *    d. 否则并行执行所有工具调用（OpenAI 协议要求 tool 消息按 tool_calls 顺序回填）
  *    e. 进入下一轮（让模型看到 tool_result 后继续推理）
  *
  *  失控保护：maxTurns（默认 50）。
  *  中断支持：AbortSignal 透传到 chat() 和 tool.call()。
+ *
+ *  v0.5.3 新增"工作过程显示"事件：
+ *    - stage_change：thinking / streaming / tool_executing / compacting
+ *    - reasoning：思维链流式增量（仅字符串型 field）
+ *    - token_tick：200ms 节流，UI 用来显示 token / 耗时心跳
  * ============================================================
  */
 import { autoCompactIfNeeded } from './context/compact.js';
 import { microCompact, incrementTurn, expireOldEntries } from './context/microCompactLite.js';
 import { isPromptTooLongError, reactiveCompactIfApplicable, } from './context/reactiveCompact.js';
-import { chat } from './llm/client.js';
-import { ALL_TOOLS, executeTool } from './tools/index.js';
+import { chat as defaultChat } from './llm/client.js';
+import { ALL_TOOLS, executeTool as defaultExecuteTool } from './tools/index.js';
 /**
  * 执行一次"用户输入 → 模型回答完成"的完整流程。
  *
@@ -35,11 +40,20 @@ import { ALL_TOOLS, executeTool } from './tools/index.js';
 export async function* runQuery(userInput, options) {
     const { provider, history, signal, sessionState } = options;
     const maxTurns = options.maxTurns ?? 50;
-    // 1. 用户消息入栈
-    history.push({ role: 'user', content: userInput });
+    // DI fallback：测试可传 stub，生产走真实模块单例
+    const chatFn = options.chat ?? defaultChat;
+    const executeToolFn = options.executeTool ?? defaultExecuteTool;
+    // 1. 用户消息入栈（v2：填 timestamp，让 MessageList 的 turn 边界横线
+    //    能拿到首条 user 的真实时间，否则 fallback Date.now() 会丢失"提交时刻"语义）
+    history.push({ role: 'user', content: userInput, timestamp: Date.now() });
     // 反应式压缩自救：本 runQuery 只允许触发一次，避免压缩失败导致死循环。
     // 配合 reactiveCompact.ts 的 attempted（session 级）双层防爆。
     let reactiveAttempted = false;
+    // token_tick 心跳起点：跨多轮累计估算 token 与耗时
+    const turnStart = Date.now();
+    // v2 工具 step 计数器：跨整次 runQuery 累计每个工具 worker 的派发序号
+    // （每个 worker 启动时 ++）。token_tick yield 时携带 stepN 给 UI 显示 "step N"。
+    let stepN = 0;
     let turn = 0;
     while (turn < maxTurns) {
         turn++;
@@ -50,6 +64,7 @@ export async function* runQuery(userInput, options) {
             history.push({
                 role: 'user',
                 content: '(用户按下了 ESC/Ctrl+C 中断了任务)',
+                timestamp: Date.now(),
             });
             yield { type: 'error', error: '已被用户中断' };
             return;
@@ -59,10 +74,13 @@ export async function* runQuery(userInput, options) {
             const compact = await autoCompactIfNeeded(history, provider);
             if (compact.compacted) {
                 yield { type: 'compact_start' };
+                yield { type: 'stage_change', stage: 'compacting' };
                 // in-place 替换 history（保持调用方持有的引用有效）
                 history.length = 0;
                 history.push(...compact.messages);
                 yield { type: 'compact_done', before: compact.before, after: compact.after };
+                // 压缩完会回到 LLM 调用，stage 退回 thinking
+                yield { type: 'stage_change', stage: 'thinking' };
             }
         }
         catch (e) {
@@ -83,14 +101,24 @@ export async function* runQuery(userInput, options) {
         let reasoningContent = '';
         let reasoningString = '';
         const reasoningDetails = [];
+        /** 首个 text_delta 时切到 streaming，再来不重复 yield */
+        let stageStreamingYielded = false;
+        /** 200ms token_tick 节流游标 */
+        let lastTick = Date.now();
+        // 进入 LLM 流前：等首 token / reasoning，本质是 thinking
+        yield { type: 'stage_change', stage: 'thinking' };
         try {
-            for await (const ev of chat({
+            for await (const ev of chatFn({
                 provider,
                 messages: history,
                 tools: ALL_TOOLS,
                 signal,
             })) {
                 if (ev.type === 'text_delta') {
+                    if (!stageStreamingYielded) {
+                        stageStreamingYielded = true;
+                        yield { type: 'stage_change', stage: 'streaming' };
+                    }
                     assistantText += ev.delta;
                     yield { type: 'text', delta: ev.delta };
                 }
@@ -100,15 +128,35 @@ export async function* runQuery(userInput, options) {
                 else if (ev.type === 'reasoning_delta') {
                     if (ev.field === 'reasoning_content' && ev.delta) {
                         reasoningContent += ev.delta;
+                        yield { type: 'reasoning', delta: ev.delta };
                     }
                     else if (ev.field === 'reasoning' && ev.delta) {
                         reasoningString += ev.delta;
+                        yield { type: 'reasoning', delta: ev.delta };
                     }
                     else if (ev.field === 'reasoning_details' && ev.items) {
+                        // reasoning_details 是结构化数组，没有 delta 字符串，跳过 yield
                         reasoningDetails.push(...ev.items);
                     }
+                    if (ev.delta) {
+                        yield { type: 'reasoning_delta', field: ev.field, delta: ev.delta };
+                    }
                 }
                 // ev.type === 'done' 时无需处理：循环自然结束
+                // 每 chunk 同步检查 200ms 节流，避免起 setInterval 与 generator yield 时机冲突
+                const now = Date.now();
+                if (now - lastTick >= 200) {
+                    lastTick = now;
+                    const usedThisTurn = Math.ceil(assistantText.length / 4) +
+                        Math.ceil(reasoningContent.length / 4) +
+                        Math.ceil(reasoningString.length / 4);
+                    yield {
+                        type: 'token_tick',
+                        usedThisTurn,
+                        elapsedMs: now - turnStart,
+                        stepN,
+                    };
+                }
             }
         }
         catch (e) {
@@ -117,6 +165,7 @@ export async function* runQuery(userInput, options) {
                 history.push({
                     role: 'user',
                     content: '(用户按下了 ESC/Ctrl+C 中断了任务)',
+                    timestamp: Date.now(),
                 });
                 yield { type: 'interrupted' };
                 return;
@@ -127,6 +176,7 @@ export async function* runQuery(userInput, options) {
             if (isPromptTooLongError(e) && !reactiveAttempted) {
                 reactiveAttempted = true;
                 yield { type: 'compact_start' };
+                yield { type: 'stage_change', stage: 'compacting' };
                 const result = await reactiveCompactIfApplicable(history, provider, e, sessionState?.reactive);
                 if (result.recovered) {
                     history.length = 0;
@@ -136,6 +186,8 @@ export async function* runQuery(userInput, options) {
                         before: result.before ?? 0,
                         after: result.after ?? 0,
                     };
+                    // 压缩完回到 LLM 调用
+                    yield { type: 'stage_change', stage: 'thinking' };
                     turn--; // 不消耗 turn 配额，本轮重新走
                     continue;
                 }
@@ -151,6 +203,7 @@ export async function* runQuery(userInput, options) {
             ...(reasoningContent ? { reasoning_content: reasoningContent } : {}),
             ...(reasoningString ? { reasoning: reasoningString } : {}),
             ...(reasoningDetails.length > 0 ? { reasoning_details: reasoningDetails } : {}),
+            timestamp: Date.now(),
         };
         history.push(assistantMsg);
         yield { type: 'assistant_message', message: assistantMsg };
@@ -159,41 +212,116 @@ export async function* runQuery(userInput, options) {
             yield { type: 'turn_done' };
             return;
         }
-        // 5. 顺序执行每个工具
-        for (const tc of toolCallsByIndex) {
-            if (signal?.aborted) {
-                // 中断标记帮助模型理解上下文：为什么输出被截断，用户可以重新输入
+        // 5. 并行执行所有工具
+        //
+        // 设计：用 Promise.allSettled 启动 N 个 worker，配合一个简易事件队列
+        // （queue + signalNew）把多个 worker 的 tool_start / tool_end 事件按
+        // 真实完成顺序交错 yield 给 UI；但 history 里的 tool 消息严格按
+        // toolCallsByIndex 索引顺序 push（OpenAI 协议要求 tool 消息和上一条
+        // assistant 的 tool_calls 一一对应）。
+        yield { type: 'stage_change', stage: 'tool_executing' };
+        const queue = [];
+        let signalNew = null;
+        const enqueue = (ev) => {
+            queue.push(ev);
+            signalNew?.();
+            signalNew = null;
+        };
+        const workers = toolCallsByIndex.map(async (tc) => {
+            // 每个 worker 启动时累加 step 序号；token_tick 携带它给 UI 显示进度感
+            stepN++;
+            enqueue({
+                type: 'tool_start',
+                toolCallId: tc.id,
+                toolName: tc.function.name,
+                argsPreview: previewArgs(tc.function.arguments),
+                argsFriendly: friendlyToolDescription(tc.function.name, tc.function.arguments),
+            });
+            try {
+                const result = await executeToolFn(tc.function.name, tc.function.arguments, signal);
+                enqueue({
+                    type: 'tool_end',
+                    toolCallId: tc.id,
+                    toolName: tc.function.name,
+                    ok: result.ok,
+                    content: result.ok ? result.content : `Error: ${result.error}`,
+                });
+                return { tc, result };
+            }
+            catch (e) {
+                if (e.name === 'AbortError') {
+                    enqueue({
+                        type: 'tool_end',
+                        toolCallId: tc.id,
+                        toolName: tc.function.name,
+                        ok: false,
+                        content: '(已中断)',
+                    });
+                    return { tc, result: { ok: false, error: 'aborted' } };
+                }
+                const msg = e.message;
+                enqueue({
+                    type: 'tool_end',
+                    toolCallId: tc.id,
+                    toolName: tc.function.name,
+                    ok: false,
+                    content: msg,
+                });
+                return { tc, result: { ok: false, error: msg } };
+            }
+        });
+        const allDone = Promise.allSettled(workers);
+        let finished = false;
+        allDone.then(() => {
+            finished = true;
+            signalNew?.();
+            signalNew = null;
+        });
+        while (!finished || queue.length > 0) {
+            while (queue.length > 0)
+                yield queue.shift();
+            if (finished)
+                break;
+            await new Promise((r) => {
+                signalNew = r;
+            });
+        }
+        // 严格按 toolCallsByIndex 顺序 push tool 消息进 history（OpenAI 协议要求）
+        const settled = await allDone;
+        let anyAborted = false;
+        for (let i = 0; i < toolCallsByIndex.length; i++) {
+            const tc = toolCallsByIndex[i];
+            const r = settled[i];
+            if (r.status === 'rejected') {
+                // 理论上 worker 已经 catch 了所有异常，这里只是防御
+                const errMsg = r.reason?.message ?? 'unknown';
                 history.push({
-                    role: 'user',
-                    content: '(用户按下了 ESC/Ctrl+C 中断了任务)',
+                    role: 'tool',
+                    tool_call_id: tc.id,
+                    content: `Error: ${errMsg}`,
+                    timestamp: Date.now(),
                 });
-                yield { type: 'error', error: '已被用户中断' };
-                return;
+                continue;
             }
-            const argsPreview = previewArgs(tc.function.arguments);
-            yield {
-                type: 'tool_start',
-                toolName: tc.function.name,
-                toolCallId: tc.id,
-                argsPreview,
-            };
-            const result = await executeTool(tc.function.name, tc.function.arguments, signal);
-            // 工具结果：失败保留错误信息，成功经微压缩后保留
+            const { result } = r.value;
+            if (!result.ok && result.error === 'aborted')
+                anyAborted = true;
             const rawContent = result.ok ? result.content : `Error: ${result.error}`;
-            const content = microCompact(tc.function.name, rawContent, sessionState?.microCompact);
-            // 工具结果作为 tool 消息回填
+            // 微压缩仅对成功结果走（失败结果通常很短，不需要压缩）
+            const content = result.ok
+                ? microCompact(tc.function.name, rawContent, sessionState?.microCompact)
+                : rawContent;
             history.push({
                 role: 'tool',
                 content,
                 tool_call_id: tc.id,
+                timestamp: Date.now(),
             });
-            yield {
-                type: 'tool_end',
-                toolName: tc.function.name,
-                toolCallId: tc.id,
-                ok: result.ok,
-                content,
-            };
+        }
+        if (anyAborted || signal?.aborted) {
+            // 任一工具抛 AbortError 时，外层 yield interrupted 并 return
+            yield { type: 'interrupted' };
+            return;
         }
         // 6. 继续 while 让模型看到 tool_result 后继续推理
     }
@@ -228,3 +356,47 @@ function previewArgs(rawJson) {
         return oneLine;
     return oneLine.slice(0, 60) + '...';
 }
+/**
+ * 把工具名 + raw arguments JSON 转换成人话描述。
+ * UI 优先用这个显示在 spinner 行（如 "Reading src/foo.ts"）。
+ * 已知工具走 switch；未知工具或 JSON parse 失败 fallback 到 `${toolName}(...)`。
+ */
+function friendlyToolDescription(toolName, rawArgsJson) {
+    let args = {};
+    try {
+        args = JSON.parse(rawArgsJson) ?? {};
+    }
+    catch {
+        return `${toolName}(...)`;
+    }
+    const truncate = (s, n) => {
+        if (typeof s !== 'string')
+            return '';
+        return s.length > n ? s.slice(0, n) + '…' : s;
+    };
+    switch (toolName) {
+        case 'Read': return `Reading ${truncate(args.file_path, 60)}`;
+        case 'Edit': return `Editing ${truncate(args.file_path, 60)}`;
+        case 'Write': return `Writing ${truncate(args.file_path, 60)}`;
+        case 'Bash': return `Running \`${truncate(args.command, 40)}\``;
+        case 'Grep': {
+            const p = truncate(args.pattern, 30);
+            const g = typeof args.glob === 'string' && args.glob.length > 0 ? ` in ${truncate(args.glob, 25)}` : '';
+            return `Searching \`${p}\`${g}`;
+        }
+        case 'Glob': return `Globbing \`${truncate(args.pattern, 50)}\``;
+        case 'WebFetch':
+        case 'WebBrowser': {
+            try {
+                return `Fetching ${new URL(String(args.url)).host}`;
+            }
+            catch {
+                return `Fetching ...`;
+            }
+        }
+        case 'WebSearch': return `Searching \`${truncate(args.query, 50)}\``;
+        default: return `${toolName}(...)`;
+    }
+}
+// 导出供测试用（friendlyToolDescription 是 module-private 纯函数）
+export { friendlyToolDescription };

package/src/prompts/system.js

@@ -34,6 +34,17 @@ export async function getSystemPrompt(cwd, tools) {
 
 # 思维与立场（核心：像专家一样独立思考）
 - **你是工程协作者，不是奉承者**。不无条件夸赞、不为附和而附和、不同意时直说。不用"很好的问题"、"你说得对"、"完全同意"这类前缀——直接答内容。
+- **先判断用户意图再行动**——这是最重要的第一步，区分以下三种情况：
+  - ✅ **明确执行（直接动手，不要犹豫）**：用户表述包含明确的行动指令。
+    动词特征：「修改/改/调整/修复/优化/更新/替换/删/移除/写/创建/实现/做/生成/新建/开发/执行/跑/运行/提交/部署/安装」
+    确认性指令也算：「对就这么改」「是的按这个方案实现」「好的麻烦改一下」
+  - ❌ **纯讨论（绝对不能动文件，只回答）**：用户只是提问、咨询、探讨、评估。
+    特征：问号结尾、「是不是/怎么样/为什么/好不好/能否/你觉得」、纯观点表达「我觉得...」「这里好像有...」
+    即使你发现明显问题，也只能给文字建议，**禁止调用 Edit/Write/MultiEdit/Bash 写操作等任何修改类工具**
+  - ❓ **模糊场景（仅一次确认，不要啰嗦）**：介于两者之间无法判断时。
+    例：「这个接口响应太慢了」「这个正则好像有问题」
+    只问一句：「你是需要我实际修改/修复，还是只是讨论这个问题？」—— 用户说改就立刻改，说讨论就停
+- **兜底原则**：宁可多问一次也不要擅自修改；但只要用户明确说要改，必须立刻执行，不要二次确认。
 - **基于证据，不基于揣测用户想听什么**。没读过的代码先 Read，没验证过的行为先验证，不凭印象答。回答前先问自己：这个判断有具体证据吗，还是我在猜？
 - **不知道就说不知道**。明确边界："这个版本号我不确定"、"这个 API 我没看过文档"、"这部分行为我没验证过"。胡编一个看起来对的答案，代价远高于承认不知道。
 - **明示 confidence 分层**。结论按确定度分层表达——"已 verify / 高度确信"、"基于代码合理推测"、"未验证猜测"——让用户基于你的不确定程度决策，不要把推测说成事实。

package/src/ui/App.js

@@ -8,7 +8,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * ============================================================
  */
 import React from 'react';
-import { Box, Text } from 'ink';
+import { Box, Text, Static } from 'ink';
 import { saveContext } from '../context/persistContext.js';
 import { InputBox } from './InputBox.js';
 import { MessageList } from './MessageList.js';
@@ -33,5 +33,5 @@ export function App({ provider, initialHistory }) {
         await chat.clearHistory();
         process.stdout.write(CLEAR_SCREEN);
     }, [chat]);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: "cyan", bold: true, children: "minimal-agent" }), _jsx(Text, { color: "gray", children: `  · ${provider.name}/${provider.model} · /new 清空 · /compact 压缩 · /exit 退出 · Ctrl+C 中断` })] }), _jsx(MessageList, { history: chat.history, streamingText: chat.streamingText }), _jsx(ToolStatus, { status: chat.toolStatus, compacting: chat.compacting }), chat.error && (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { color: "red", children: ["\u26A0 ", chat.error] }) })), chat.interrupted && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "yellow", children: "\u26A1 \u64CD\u4F5C\u88AB\u7528\u6237\u4E2D\u65AD\uFF0C\u7B49\u5F85\u65B0\u7684\u4EFB\u52A1\u8F93\u5165..." }) })), _jsx(InputBox, { onSubmit: chat.submit, disabled: chat.isLoading, onAbort: chat.abort, onClear: handleClear, onCompact: chat.compactNow }), _jsx(StatusLine, { provider: provider, history: chat.history, pluginProgress: chat.pluginProgress })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: [null], children: () => (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: "cyan", bold: true, children: "minimal-agent" }), _jsx(Text, { color: "gray", children: `  · ${provider.name}/${provider.model} · /new 清空 · /compact 压缩 · /exit 退出 · Ctrl+C 中断` })] })) }), _jsx(MessageList, { history: chat.history, streamingText: chat.streamingText, streamingReasoning: chat.streamingReasoning }), _jsx(ToolStatus, { status: chat.toolStatus, compacting: chat.compacting }), chat.error && (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { color: "red", children: ["\u26A0 ", chat.error] }) })), chat.interrupted && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "yellow", children: "\u26A1 \u64CD\u4F5C\u88AB\u7528\u6237\u4E2D\u65AD\uFF0C\u7B49\u5F85\u65B0\u7684\u4EFB\u52A1\u8F93\u5165..." }) })), _jsx(InputBox, { onSubmit: chat.submit, disabled: chat.isLoading, onAbort: chat.abort, onClear: handleClear, onCompact: chat.compactNow }), _jsx(Static, { items: [chat.history.length], children: () => (_jsx(StatusLine, { provider: provider, history: chat.history, pluginProgress: chat.pluginProgress })) })] }));
 }

package/src/ui/InputBox.js

@@ -20,19 +20,38 @@ import { useRef, useState, useCallback } from 'react';
 import { Box, Text, useApp, useInput } from 'ink';
 import { useTextBuffer } from './hooks/useTextBuffer.js';
 import { usePasteHandler } from './hooks/usePasteHandler.js';
+import { useInputHistory } from './hooks/useInputHistory.js';
 export function InputBox({ onSubmit, disabled, onAbort, onClear, onCompact }) {
     const buf = useTextBuffer();
+    const hist = useInputHistory();
     const ctrlCCountRef = useRef(0);
     const ctrlCTimerRef = useRef(null);
     const { exit } = useApp();
     // ✅ 精准刷新计数器：只在必要时触发重渲染
     const [refreshCounter, setRefreshCounter] = useState(0);
-    // ✅ Delete 专用去重：只防止 Windows 双事件，不影响其他键
-    const lastDeleteTime = useRef(0);
-    const DELETE_DEBOUNCE_MS = 20; // 仅 Delete 键用极短防抖
+    // ✅ 精准刷新函数
     const forceRefresh = useCallback(() => {
         setRefreshCounter((c) => c + 1);
     }, []);
+    // ✅ IME 输入缓冲：非 ASCII 字符（CJK/emoji）累积后批量刷新，减少 rerender 频率
+    const imeBufRef = useRef('');
+    const imeTimerRef = useRef(null);
+    const flushImeBuffer = useCallback(() => {
+        if (imeTimerRef.current) {
+            clearTimeout(imeTimerRef.current);
+            imeTimerRef.current = null;
+        }
+        if (imeBufRef.current.length > 0) {
+            buf.insert(imeBufRef.current);
+            imeBufRef.current = '';
+            forceRefresh();
+        }
+    }, [buf, forceRefresh]);
+    // ✅ Ctrl+R 反向搜索模式（null 表示不在搜索）
+    const [searchMode, setSearchMode] = useState(null);
+    // ✅ Delete 专用去重：只防止 Windows 双事件，不影响其他键
+    const lastDeleteTime = useRef(0);
+    const DELETE_DEBOUNCE_MS = 20; // 仅 Delete 键用极短防抖
     // ✅ 粘贴处理 Hook：支持多行粘贴
     // v0.3 设计：Enter 始终发送, Alt+Enter（Mac: Option+Enter）换行, 粘贴期间拦截 Enter
     const { handleInput: handlePasteInput } = usePasteHandler({
@@ -61,15 +80,72 @@ export function InputBox({ onSubmit, disabled, onAbort, onClear, onCompact }) {
             return;
         }
         // pasteResult === 'continue'，继续普通处理
+        // ---- ✅ Ctrl+R 反向搜索模式（独占按键流）----
+        if (searchMode !== null) {
+            // ESC 退出搜索
+            if (key.escape) {
+                setSearchMode(null);
+                return;
+            }
+            // Enter 选中并提交
+            if (key.return) {
+                if (searchMode.hit !== null) {
+                    const text = searchMode.hit;
+                    setSearchMode(null);
+                    buf.clear();
+                    forceRefresh();
+                    hist.push(text);
+                    hist.resetCursor();
+                    onSubmit(text);
+                }
+                else {
+                    setSearchMode(null);
+                }
+                return;
+            }
+            // Backspace 削 query；query 削空了退出
+            if (key.backspace || key.delete) {
+                const nextQuery = searchMode.query.slice(0, -1);
+                if (nextQuery.length === 0) {
+                    setSearchMode(null);
+                    return;
+                }
+                const nextHit = hist.search(nextQuery)[0] ?? null;
+                setSearchMode({ query: nextQuery, hit: nextHit });
+                return;
+            }
+            // Ctrl+C 退出搜索（不退出程序）
+            if (key.ctrl && input === 'c') {
+                setSearchMode(null);
+                return;
+            }
+            // 字面字符（排除控制键）追加到 query
+            if (input && !key.ctrl && !key.meta && !key.return && !key.escape) {
+                const nextQuery = searchMode.query + input;
+                const nextHit = hist.search(nextQuery)[0] ?? null;
+                setSearchMode({ query: nextQuery, hit: nextHit });
+                return;
+            }
+            // 其他按键在搜索模式下静默吞掉
+            return;
+        }
         // ---- ESC ----
         if (key.escape) {
             if (disabled)
                 onAbort();
             return;
         }
+        // ---- ✅ Ctrl+R 进入反向搜索（仅在空 buf + 非 disabled）----
+        if (key.ctrl && input === 'r') {
+            if (!disabled && buf.state.text.length === 0) {
+                setSearchMode({ query: '', hit: null });
+            }
+            return;
+        }
         // ---- Ctrl+C ----
         if (key.ctrl && input === 'c') {
             if (buf.state.text.length > 0) {
+                flushImeBuffer();
                 buf.clear();
                 forceRefresh();
                 return;
@@ -93,9 +169,13 @@ export function InputBox({ onSubmit, disabled, onAbort, onClear, onCompact }) {
         //   - Ctrl+Enter：返回 'continue' → 这里也执行**强制发送**
         //   - 粘贴期间 + Enter：返回 'enter-in-paste' → **忽略**（防误发）
         if (key.return) {
+            flushImeBuffer(); // 先提交残留 CJK 输入
             const text = buf.state.text.trim();
             if (text.length === 0)
                 return;
+            // 入历史（所有非空提交都记，包括 slash 命令；连续重复 hist 内部去重）
+            hist.push(text);
+            hist.resetCursor();
             if (text === '/exit' || text === '/quit')
                 exit();
             else if (text === '/new' || text === '/clear') {
@@ -133,11 +213,29 @@ export function InputBox({ onSubmit, disabled, onAbort, onClear, onCompact }) {
             return;
         }
         if (key.upArrow) {
+            // 首行按 ↑ → 翻历史；中间行 → 正常移动光标
+            if (buf.layout.cursorRow === 0) {
+                const prev = hist.prev();
+                if (prev !== null) {
+                    buf.setText(prev);
+                    forceRefresh();
+                }
+                return;
+            }
             buf.moveUp();
             forceRefresh();
             return;
         }
         if (key.downArrow) {
+            // 末行按 ↓ → 翻历史；中间行 → 正常移动光标
+            const lastRow = buf.layout.lines.length - 1;
+            if (buf.layout.cursorRow >= lastRow) {
+                const nxt = hist.next();
+                // next 返 null 表示走到 "新输入" 位 → 清空缓冲
+                buf.setText(nxt ?? '');
+                forceRefresh();
+                return;
+            }
             buf.moveDown();
             forceRefresh();
             return;
@@ -207,15 +305,54 @@ export function InputBox({ onSubmit, disabled, onAbort, onClear, onCompact }) {
         // Alt+Enter 在多数终端发 \x1b\r：Ink 把 \x1b 剥掉后 input='\r'、key.return=false、
         // key.meta=false，从这里落地。把 \r/\r\n 统一成 \n，textBuffer 才能真切分逻辑行
         // （否则 layout 永远 1 行 → ↑/↓ 失效、输入框不长高，光标只能左右）。
+        //
+        // IME 兼容优化（方案C：启发式过滤 + 延迟刷新）：
+        //   - ASCII 可打印字符 → 立即插入+刷新（英文打字无延迟）
+        //   - 非 ASCII 字符（CJK/emoji）→ 累积到 imeBuf，50ms 后批量刷新
+        //     （合并连续 CJK 输入，减少 Ink 整树 rerender 次数）
         if (input && !key.meta) {
             const normalized = input.replace(/\r\n?/g, '\n');
-            buf.insert(normalized);
-            forceRefresh();
+            if (normalized.length === 0)
+                return;
+            // ASCII 可打印 + 换行：立即处理
+            if (/^[\x20-\x7E\n]+$/.test(normalized)) {
+                flushImeBuffer(); // 先提交残留 CJK
+                buf.insert(normalized);
+                forceRefresh();
+                return;
+            }
+            // 非 ASCII（CJK / emoji / 特殊字符）：累积后延迟刷新
+            imeBufRef.current += normalized;
+            if (!imeTimerRef.current) {
+                imeTimerRef.current = setTimeout(() => {
+                    if (imeBufRef.current.length > 0) {
+                        buf.insert(imeBufRef.current);
+                        imeBufRef.current = '';
+                        forceRefresh();
+                    }
+                    imeTimerRef.current = null;
+                }, 50);
+            }
         }
     });
+    // ✅ 搜索模式下覆盖整个 BufferView，显示 (reverse-i-search)`<query>': <hit>
+    if (searchMode !== null) {
+        return _jsx(ReverseSearchView, { query: searchMode.query, hit: searchMode.hit });
+    }
     // ✅ 传递 refreshCounter 作为 prop（不放入 key）
     return (_jsx(BufferView, { buf: buf, disabled: disabled, refreshCounter: refreshCounter }));
 }
+// ---------- 反向搜索视图 ----------
+function ReverseSearchView({ query, hit, }) {
+    // hit 可能含换行；仅展示首行避免撑爆 InputBox
+    const hitFirstLine = hit !== null ? hit.split('\n', 1)[0] : null;
+    const hitDisplay = hitFirstLine === null
+        ? '<no match>'
+        : hit !== null && hit.includes('\n')
+            ? `${hitFirstLine} …`
+            : hitFirstLine;
+    return (_jsxs(Box, { borderStyle: "round", borderColor: "magenta", paddingX: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "magenta", bold: true, children: '(reverse-i-search)`' }), _jsx(Text, { color: "yellow", children: query }), _jsx(Text, { color: "magenta", bold: true, children: "': " }), _jsx(Text, { color: hitFirstLine === null ? 'gray' : 'white', children: hitDisplay })] }), _jsx(Box, { children: _jsx(Text, { color: "gray", dimColor: true, children: "Enter \u63D0\u4EA4 \u00B7 ESC \u53D6\u6D88 \u00B7 Backspace \u5220\u5B57\u7B26" }) })] }));
+}
 function BufferView({ buf, disabled, refreshCounter }) {
     // ✅ 关键：用 useMemo 依赖 refreshCounter，而非改变 key
     // 这样不会重建组件，只是强制重新计算 layout

package/src/ui/MessageList.js

@@ -1,8 +1,18 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 const MAX_TOOL_PREVIEW_LINES = 3;
-export function MessageList({ history, streamingText }) {
-    return (_jsxs(Box, { flexDirection: "column", children: [history.map((m, i) => (_jsx(MessageRow, { message: m }, i))), streamingText.length > 0 && (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { children: streamingText }), _jsx(Text, { color: "gray", children: " \u258D" })] }))] }));
+export function MessageList({ history, streamingText, streamingReasoning }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [history.map((m, i) => (_jsx(MessageRow, { message: m }, i))), streamingReasoning.length > 0 && (_jsx(Box, { marginBottom: 1, flexDirection: "column", children: (() => {
+                    const MAX_LINES = 5;
+                    const THRESHOLD = 300;
+                    if (streamingReasoning.length <= THRESHOLD) {
+                        return (_jsxs(Text, { color: "gray", dimColor: true, children: ["\uD83D\uDCA1 ", streamingReasoning] }));
+                    }
+                    const allLines = streamingReasoning.split('\n');
+                    const tailLines = allLines.slice(-MAX_LINES);
+                    const omitted = allLines.length - MAX_LINES;
+                    return (_jsxs(_Fragment, { children: [_jsxs(Text, { color: "gray", dimColor: true, children: ["\uD83D\uDCA1 ... (", Math.round(streamingReasoning.length / 1000), "K\u5B57, \u7701\u7565 ", omitted, " \u884C)"] }), tailLines.slice(0, -1).map((line, i) => (_jsxs(Text, { color: "gray", dimColor: true, children: ['  ', line || ' '] }, i))), _jsxs(Text, { color: "gray", dimColor: true, children: ['  ', tailLines[tailLines.length - 1] || ' '] })] }));
+                })() })), streamingText.length > 0 && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: streamingText }) }))] }));
 }
 function MessageRow({ message }) {
     switch (message.role) {