minimal-agent 0.8.2 → 0.10.0

package/src/ui/hooks/useChat.js

@@ -15,25 +15,30 @@
  * ============================================================
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { getWorkingDir } from '../../bootstrap/workingDir.js';
+import { stat } from 'node:fs/promises';
+import { getWorkingDir, setWorkingDir } from '../../bootstrap/workingDir.js';
 import { forceCompact } from '../../context/compact.js';
 import { clearContext, loadContext, saveContext, } from '../../context/persistContext.js';
 import { resetReactiveCompactState } from '../../context/reactiveCompact.js';
-import { getActiveSession, setActiveSession, } from '../../context/sessionRegistry.js';
+import { acquireContextLock } from '../../context/contextLock.js';
+import { getActiveSession, setActiveSession, updateSessionMetadata, } from '../../context/sessionRegistry.js';
 import { resolveSessionFile, sessionFileFor, } from '../../context/sessionPath.js';
 import { buildFullSystemPrompt } from '../../prompts/system.js';
-import { ALL_TOOLS } from '../../tools/index.js';
-import { setAskHandler, } from '../../askBridge.js';
+import { ALL_TOOLS, getToolByName } from '../../tools/index.js';
+import { createInputQueue } from '../../messageQueue.js';
+import { createAskCoordinator, setAskHandler, } from '../../askBridge.js';
+import { createAskSlot } from './askSlot.js';
+import { figures } from '../figures.js';
 import { clearFileState } from '../../tools/shared/fileState.js';
 import { runWithPlugins } from '../../plugins/pluginRunner.js';
 import { dlog } from '../../utils/debugLog.js';
 /**
  * reasoningPreview 环形 buffer 容量（字符）。
  * LiveArea 现在多行显示思维链尾部（最近 N 行），需要喂饱足够文本；
- * 1200 字符约 15~20 行中文，LiveArea wrapToDisplayLines 后再取尾部最近 N 行。
+ * 2400 字符约 30~40 行中文，LiveArea wrapToDisplayLines 后再取尾部最近 N 行。
  * 上界由 LiveArea 的 contentMaxLines 兜底，这里只管"留够素材"。
  */
-const REASONING_PREVIEW_MAX_CHARS = 1200;
+const REASONING_PREVIEW_MAX_CHARS = 2400;
 /**
  * streamingText 环形 buffer 容量（字符）—— 仅用于 live 区"答案流式预览"。
  *
@@ -108,15 +113,37 @@ export function useChat(args) {
     const historyRef = useRef(args.initialHistory.slice());
     const [version, setVersion] = useState(0);
     const bump = useCallback(() => setVersion((v) => v + 1), []);
+    // provider 用 ref 存储，支持运行时切换（/model 命令切换基座模型）
+    const providerRef = useRef(args.provider);
     const [streamingText, setStreamingText] = useState('');
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState(null);
+    const [transientError, setTransientError] = useState(null);
     const [interrupted, setInterrupted] = useState(false);
+    /**
+     * 暂态错误状态机的跨事件可变上下文（用 ref，不需要为它单独重渲染）。
+     *   - activeStepId：当前正在执行的 workflow step id（workflow_step_start 记下，
+     *     该 step 的 workflow_step_end 清除）；null = 不在任何 step 内。
+     *   - pendingLlmError：该 step 执行中捕获到的最近一次 llm_error 文案（暂存，
+     *     等 step 结束才决定丢弃 or 提升为永久红字）。
+     * handleEvent 通过 setters.workflowCtx 同步读写这个对象（pure 逻辑，测试可注入 stub）。
+     */
+    const workflowCtxRef = useRef({ activeStepId: null, pendingLlmError: null });
+    // 工作流步骤 id → 人话进度名（title）映射：start 记入、end/skipped 回查，
+    // 让 scrollback 三种进度行（▶/✓/⊘）都显示同一人话名而非 id。跨事件持 ref。
+    const stepTitlesRef = useRef(new Map());
     const [pluginProgress, setPluginProgress] = useState(null);
     // ---- 工作过程显示相关 state ----
     const [compactGeneration, setCompactGeneration] = useState(0);
     const [progressStage, setProgressStage] = useState('idle');
     const [reasoningPreview, setReasoningPreview] = useState('');
+    /**
+     * 内核每轮 yield 的真实上下文用量（含 tools-schema 开销 + 真实 provider usage，
+     * 见 loop.ts 的 context_usage 事件）。收到过至少一次前 StatusLine 用它渲染，
+     * 比 useTokenUsage 的本地估算更准；未收到过（如刚启动、纯只读问答走了只读快速
+     * 路径）时该值仍是 null，StatusLine 降级回 useTokenUsage 估算。
+     */
+    const [contextUsage, setContextUsage] = useState(null);
     /**
      * 工具并行执行：以 callId 为 key 保存所有运行中工具。
      * 用 Map 是为了 O(1) 增删；对外 memo 物化成稳定数组（Map 迭代顺序 = 插入顺序，
@@ -125,12 +152,28 @@ export function useChat(args) {
     const [runningToolsMap, setRunningToolsMap] = useState(new Map());
     const runningTools = useMemo(() => Array.from(runningToolsMap.values()), [runningToolsMap]);
     const abortRef = useRef(null);
+    const [inputQueue] = useState(() => createInputQueue());
+    const [queuedCount, setQueuedCount] = useState(0);
+    const [queuedItems, setQueuedItems] = useState([]);
+    const runningToolsRef = useRef(new Map());
+    useEffect(() => {
+        return inputQueue.subscribe(() => {
+            setQueuedCount(inputQueue.size());
+            setQueuedItems(inputQueue.getSnapshot());
+        });
+    }, [inputQueue]);
     // ---- AskUserQuestion：执行中向用户提问 ----
     // pendingAsk 非 null 时 App 渲染 <AskQuestion> 独占输入（不渲染 InputBox）。
-    // askResolverRef 持当前提问的 resolve/reject —— 用户答完 answerAsk 调 resolve，
-    // 让 askBridge.requestUserChoice 的 Promise 落定、工具 call() 返回、执行继续。
+    // 单槽状态机（resolve/reject 持有、abort 归属校验、悬挂防护）抽在
+    // askSlot.ts（纯函数可单测）；这里只桥接 React 状态。
     const [pendingAsk, setPendingAsk] = useState(null);
-    const askResolverRef = useRef(null);
+    // 提问来源：子任务提问时 kind:'subagent' + description → AskQuestion 显示徽标。
+    const [pendingAskSource, setPendingAskSource] = useState(null);
+    const [pendingAskQueueCount, setPendingAskQueueCount] = useState(0);
+    const [askSlot] = useState(() => createAskSlot((questions, source) => {
+        setPendingAsk(questions);
+        setPendingAskSource(questions ? source ?? null : null);
+    }));
     const streamingFlush = useThrottledFlush({
         delayMs: STREAM_FLUSH_MS,
         maxChars: STREAM_FLUSH_MAX_CHARS,
@@ -171,6 +214,9 @@ export function useChat(args) {
         setProgressStage('idle');
         setReasoningPreview('');
         setRunningToolsMap(new Map());
+        // 暂态错误是"过程级"提示，turn 结束 / 切换时一并清掉，不残留到下一轮
+        setTransientError(null);
+        workflowCtxRef.current = { activeStepId: null, pendingLlmError: null };
     }, []);
     /** turn 结束 / 中断 / 切换时一并取消所有节流 buffer 的 pending timer。 */
     const cancelAllThrottles = useCallback(() => {
@@ -195,48 +241,26 @@ export function useChat(args) {
         };
     }, []);
     // mount 时把「弹选择界面」的处理器注册到 askBridge；unmount 注销。
-    // 工具 isConcurrencySafe:false + workflow 串行 → 同一时刻至多一个 pending，单槽即可。
-    // signal abort（用户 ESC / 中断）时 reject 并清掉 pending，让工具按「失败/取消」收尾。
+    // 两层组合：createAskCoordinator（FIFO 队列——主循环与并行 general 子 Agent 都可能
+    // 提问，用户一次只看一个问题，其余排队；实例按 TUI 挂载创建，不同进程互不阻塞）
+    // 包住 askSlot.handler（呈现层单槽 + abort 归属校验——同轮多次提问共享 turn signal，
+    // 归属校验保证已答完提问的 abort 监听器不会清掉后来提问的槽，否则后者 promise
+    // 永不落定 → 整轮死挂，见 askSlot.ts 头注）。
     useEffect(() => {
-        setAskHandler((questions, signal) => {
-            return new Promise((resolve, reject) => {
-                askResolverRef.current?.reject(new Error('被新的提问取代'));
-                askResolverRef.current = { resolve, reject };
-                dlog('ui', 'ask handler INVOKED (等待用户答题)', {
-                    n: questions.length,
-                    headers: questions.map((q) => q.header),
-                });
-                setPendingAsk(questions);
-                const onAbort = () => {
-                    if (!askResolverRef.current)
-                        return;
-                    askResolverRef.current = null;
-                    setPendingAsk(null);
-                    reject(new Error('已被用户中断'));
-                };
-                if (signal?.aborted) {
-                    onAbort();
-                    return;
-                }
-                signal?.addEventListener('abort', onAbort, { once: true });
-            });
-        });
+        setAskHandler(createAskCoordinator(askSlot.handler, (status) => {
+            setPendingAskQueueCount(status.queuedCount ?? 0);
+        }));
         return () => setAskHandler(null);
-    }, []);
+    }, [askSlot]);
     /** 用户答完当前提问：清 pending + resolve 工具侧 Promise，执行继续。 */
-    const answerAsk = useCallback((answers) => {
-        const r = askResolverRef.current;
-        askResolverRef.current = null;
-        setPendingAsk(null);
-        dlog('ui', 'ask ANSWERED (继续执行)', { selected: answers.map((a) => a.selected) });
-        r?.resolve(answers);
-    }, []);
-    // mount 时异步读 active session（默认 'default'，注册表里有就用注册值）。
-    // 启动时初始 history 已经由 main.tsx/Root 走默认路径加载完了；
-    // 如果注册表说 active 不是 default，理论上 main.tsx 应该按 active 加载——
-    // 但当前 main.tsx 用的是 getContextPath() 走 default。为了兼容这个不一致，
-    // 此处把 ref/state 设为 active id 但不重新 loadContext —— 由用户手动 /session
-    // 切回正确 session（极少数 edge case，避免启动时异步加载导致界面闪烁）。
+    const answerAsk = useCallback((answers) => askSlot.answer(answers), [askSlot]);
+    const cancelAsk = useCallback(() => {
+        if (pendingAskSource?.kind === 'subagent')
+            askSlot.cancel();
+        else
+            abortRef.current?.abort();
+    }, [askSlot, pendingAskSource]);
+    // Root 已按 active session 加载初始历史；这里同步同一 active id 给交互状态。
     useEffect(() => {
         let cancelled = false;
         void (async () => {
@@ -256,13 +280,22 @@ export function useChat(args) {
         };
     }, []);
     const submit = useCallback(async (input) => {
-        if (isLoading)
-            return;
         const trimmed = input.trim();
         if (trimmed.length === 0)
             return;
+        if (isLoading) {
+            inputQueue.enqueue(trimmed, 'next');
+            const running = Array.from(runningToolsRef.current.values());
+            const allCancelable = running.length > 0 && running.every(t => t.isCancelable);
+            if (allCancelable) {
+                abortRef.current?.abort('interrupt');
+            }
+            bump();
+            return;
+        }
         setIsLoading(true);
         setError(null);
+        setTransientError(null);
         setInterrupted(false);
         cancelAllThrottles();
         setStreamingText('');
@@ -271,14 +304,48 @@ export function useChat(args) {
         setProgressStage('idle');
         setReasoningPreview('');
         setRunningToolsMap(new Map());
+        // 重置暂态错误状态机（防上一轮工作流残留）
+        workflowCtxRef.current = { activeStepId: null, pendingLlmError: null };
         const ac = new AbortController();
         abortRef.current = ac;
+        let releaseContextLock = null;
         dlog('ui', 'turn START', { input: trimmed.slice(0, 80) });
+        // 长时间运行时（如工作流 agent 步骤）的定时 token 刷新：
+        // runQuery 的 text/reasoning 事件不触发 bump，导致 StatusLine token 数
+        // 可能冻结数十秒。此定时器每 10s 强制刷新一次，确保用户看到上下文增长。
+        const tokenRefreshTimer = setInterval(() => {
+            bump();
+        }, 10_000);
         try {
+            await updateSessionMetadata(getWorkingDir(), activeSessionIdRef.current, {
+                lastMessagePreview: trimmed,
+            }).catch(() => { });
+            const activeFile = sessionFileFor(getWorkingDir(), activeSessionIdRef.current);
+            releaseContextLock = await acquireContextLock(activeFile, ac.signal);
+            // Gateway/Cron may have written this cwd since the TUI rendered its last frame.
+            // Reload after acquiring the cross-process lock so this turn extends the newest history.
+            const latest = await loadContext(activeFile);
+            if (latest) {
+                const ephemeral = historyRef.current.filter((message) => message.role === 'system' && message._ephemeral);
+                historyRef.current.length = 0;
+                historyRef.current.push(...latest, ...ephemeral);
+            }
             for await (const ev of runWithPlugins(trimmed, {
-                provider: args.provider,
+                provider: providerRef.current,
                 history: historyRef.current,
                 signal: ac.signal,
+                parseInlineImages: true,
+                hasQueuedInput: () => inputQueue.size() > 0,
+                onToolStart: (name, id) => {
+                    const tool = getToolByName(name);
+                    runningToolsRef.current.set(id, {
+                        toolName: name,
+                        isCancelable: tool?.interruptBehavior?.() === 'cancel',
+                    });
+                },
+                onToolEnd: (id) => {
+                    runningToolsRef.current.delete(id);
+                },
             })) {
                 handleEvent(ev, {
                     setStreamingText,
@@ -289,6 +356,12 @@ export function useChat(args) {
                     setProgressStage,
                     setReasoningPreview,
                     setRunningToolsMap,
+                    setContextUsage,
+                    // 暂态错误（工作流步内 llm_error / 重试进度）→ LiveArea 黄字
+                    setTransientError,
+                    workflowCtx: workflowCtxRef.current,
+                    // 步骤 id→人话名映射：scrollback 进度行三态（▶/✓/⊘）统一显示 title
+                    stepTitles: stepTitlesRef.current,
                     // 节流相关 —— buffer 累积 + 100ms timer flush
                     appendStreamingDelta: streamingFlush.append,
                     flushStreamingBuffer: streamingFlush.flush,
@@ -311,16 +384,31 @@ export function useChat(args) {
         }
         finally {
             dlog('ui', 'turn END (finally)');
+            clearInterval(tokenRefreshTimer);
             setIsLoading(false);
             cancelAllThrottles();
             resetTurnState();
             setPluginProgress(null);
             abortRef.current = null;
+            runningToolsRef.current.clear();
             // v2 multi-session：持久化到当前 active session 文件。
-            saveContext(historyRef.current, sessionFile()).catch(() => { });
+            try {
+                await saveContext(historyRef.current, sessionFileFor(getWorkingDir(), activeSessionIdRef.current));
+            }
+            finally {
+                await releaseContextLock?.();
+            }
+            const consumeQueued = () => {
+                const next = inputQueue.dequeue();
+                if (!next)
+                    return;
+                queueMicrotask(() => {
+                    void submit(next.value);
+                });
+            };
+            consumeQueued();
         }
     }, [
-        args.provider,
         bump,
         isLoading,
         sessionFile,
@@ -329,10 +417,17 @@ export function useChat(args) {
         reasoningFlush,
         toolBumpFlush,
         resetTurnState,
+        inputQueue,
     ]);
     const abort = useCallback(() => {
+        inputQueue.clear();
+        runningToolsRef.current.clear();
         abortRef.current?.abort();
+    }, [inputQueue]);
+    const setProvider = useCallback((next) => {
+        providerRef.current = next;
     }, []);
+    const getCurrentProvider = useCallback(() => providerRef.current, []);
     /**
      * v2.x 新增：把一段临时提示文本作为 _ephemeral 的 system 消息插入 history。
      *
@@ -496,6 +591,75 @@ export function useChat(args) {
         setCompactGeneration((g) => g + 1);
         bump();
     }, [bump, isLoading, cancelAllThrottles, resetTurnState]);
+    const switchWorkspace = useCallback(async (cwd, sessionId) => {
+        if (isLoading)
+            return false;
+        const targetCwd = cwd.trim();
+        const targetSessionId = sessionId.trim();
+        if (!targetCwd || !targetSessionId)
+            return false;
+        let loaded = null;
+        let targetExists = false;
+        try {
+            const targetFile = await resolveSessionFile(targetCwd, targetSessionId);
+            try {
+                targetExists = (await stat(targetFile)).isFile();
+            }
+            catch {
+                targetExists = false;
+            }
+            loaded = await loadContext(targetFile);
+            if (targetExists && loaded === null)
+                throw new Error('目标会话历史损坏或无法读取');
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : String(error));
+            bump();
+            return false;
+        }
+        let systemPrompt;
+        try {
+            systemPrompt = await buildFullSystemPrompt(targetCwd, ALL_TOOLS);
+        }
+        catch (error) {
+            setError(`无法打开工作区：${error instanceof Error ? error.message : String(error)}`);
+            bump();
+            return false;
+        }
+        const previousCwd = getWorkingDir();
+        try {
+            await saveContext(historyRef.current, sessionFileFor(previousCwd, activeSessionIdRef.current));
+        }
+        catch {
+            // A damaged old workspace must not trap the user in it.
+        }
+        try {
+            await setActiveSession(targetCwd, targetSessionId);
+        }
+        catch (error) {
+            setError(`无法切换 Session：${error instanceof Error ? error.message : String(error)}`);
+            bump();
+            return false;
+        }
+        setWorkingDir(targetCwd);
+        activeSessionIdRef.current = targetSessionId;
+        setActiveSessionId(targetSessionId);
+        historyRef.current.length = 0;
+        historyRef.current.push({ role: 'system', content: systemPrompt });
+        if (loaded?.length) {
+            historyRef.current.push(...(loaded[0]?.role === 'system' ? loaded.slice(1) : loaded));
+        }
+        clearFileState();
+        resetReactiveCompactState();
+        cancelAllThrottles();
+        setContextUsage(null);
+        setError(null);
+        setInterrupted(false);
+        resetTurnState();
+        setCompactGeneration((generation) => generation + 1);
+        bump();
+        return true;
+    }, [bump, isLoading, cancelAllThrottles, resetTurnState]);
     // history 用 useMemo 托管：version 变化时返回 historyRef.current 的浅拷贝。
     // 为什么必须 .slice()：runQuery 内部 mutate 同一个数组（push 新消息），如果这里
     // 返回同一引用，Ink <Static items={history}> 浅比较看不到 prop 变化 → 不 commit
@@ -507,21 +671,31 @@ export function useChat(args) {
         streamingText,
         isLoading,
         error,
+        transientError,
         interrupted,
         pluginProgress,
         compactGeneration,
         progressStage,
         reasoningPreview,
         runningTools,
+        contextUsage,
         activeSessionId,
+        queuedCount,
+        queuedItems,
         submit,
         abort,
         clearHistory,
         compactNow,
         switchSession,
+        switchWorkspace,
         ephemeralLine,
         pendingAsk,
+        pendingAskSource,
+        pendingAskQueueCount,
         answerAsk,
+        cancelAsk,
+        setProvider,
+        getCurrentProvider,
     };
 }
 export function handleEvent(ev, setters) {
@@ -529,21 +703,73 @@ export function handleEvent(ev, setters) {
     // 渲染成持久的暗色行落进 scrollback：跑到哪一步、成功/失败/跳过都看得见，
     // 且出错后仍停留在屏幕上 —— 解决"工作流执行过程不可见、不知道停在哪"。
     const wf = ev;
+    // 据 id 回查人话进度名：声明了 title 的步走 title，否则回落 id（end/skipped 用）。
+    const titleOrId = (id) => (id && setters.stepTitles?.get(id)) || id || '?';
     switch (wf.type) {
         case 'workflow_start':
-            setters.emitProgressLine?.(`▶ 工作流 ${wf.name} 开始（共 ${wf.totalSteps} 步）`);
+            setters.emitProgressLine?.(`${figures.step} 工作流 ${wf.name} 开始（共 ${wf.totalSteps} 步）`);
+            // 新工作流开始：清空上一条工作流残留的 title 映射，避免同名步串味。
+            setters.stepTitles?.clear();
+            // 工作流开始：立即刷新 token（可能已积累大量前置对话上下文）
+            setters.bump();
             return;
         case 'workflow_step_start':
-            setters.emitProgressLine?.(`  ▶ ${(wf.index ?? 0) + 1}/${wf.total ?? '?'} ${wf.id} (${wf.kind})`);
+            // 声明了 title 的步显示人话名（与状态行一致、不显示块内相对序号——嵌套块
+            // 的 i/total 拼在一起会被误读成"跳步"）；未声明 title 的步保持 legacy 格式。
+            // ⎿ 前缀：step 行挂在「▶ 工作流 x 开始」下的层次连接符（figures.elbow 语汇，
+            // 与工具结果/蜂群树统一）。ephemeral 是尾部追加消息，不触任何既有前缀字节。
+            if (wf.title) {
+                if (wf.id)
+                    setters.stepTitles?.set(wf.id, wf.title);
+                setters.emitProgressLine?.(`  ${figures.elbow} ${figures.step} ${wf.title}`);
+            }
+            else {
+                setters.emitProgressLine?.(`  ${figures.elbow} ${figures.step} ${(wf.index ?? 0) + 1}/${wf.total ?? '?'} ${wf.id} (${wf.kind})`);
+            }
+            // 暂态错误状态机：记下当前正在执行的 step id，进入"该步内的 llm_error 暂态化"窗口。
+            // 进新步先清掉上一步可能残留的暂态错误（上一步已 end、不应跨步显示）。
+            if (setters.workflowCtx) {
+                setters.workflowCtx.activeStepId = wf.id ?? null;
+                setters.workflowCtx.pendingLlmError = null;
+            }
+            setters.setTransientError?.(null);
             return;
         case 'workflow_step_end':
-            setters.emitProgressLine?.(`  ${wf.ok ? '✓' : '✗'} ${wf.id}${wf.error ? `：${wf.error}` : ''}`);
+            setters.emitProgressLine?.(`  ${figures.elbow} ${wf.ok ? figures.ok : figures.fail} ${titleOrId(wf.id)}${wf.error ? `：${wf.error}` : ''}`);
+            // 暂态错误裁决（仅当 end 的是当前活跃步）：
+            //   ok:true  → 重试/恢复成功 → 丢弃 pending llm_error，短暂显示"已恢复"后随刷新消失。
+            //   ok:false → 该步彻底失败 → 把暂态错误提升为永久红字（chat.error，进 scrollback 上方）。
+            if (setters.workflowCtx && setters.workflowCtx.activeStepId === wf.id) {
+                const pending = setters.workflowCtx.pendingLlmError;
+                if (wf.ok) {
+                    if (pending) {
+                        // 成功收回：留一条灰底"已恢复"提示，下一次状态行刷新自然覆盖消失
+                        setters.setTransientError?.(`${figures.ok} ${wf.id} 已恢复（此前 LLM 调用失败已重试成功）`);
+                    }
+                    else {
+                        setters.setTransientError?.(null);
+                    }
+                }
+                else {
+                    // 彻底失败：暂态升永久红字。优先用 step.error，回落到 pending llm_error。
+                    const finalMsg = wf.error ?? pending;
+                    if (finalMsg)
+                        setters.setError(finalMsg);
+                    setters.setTransientError?.(null);
+                }
+                setters.workflowCtx.activeStepId = null;
+                setters.workflowCtx.pendingLlmError = null;
+            }
+            // 步骤完成：强制刷新 token（agent/llm 步骤可能写入大量上下文）
+            setters.bump();
             return;
         case 'workflow_step_skipped':
-            setters.emitProgressLine?.(`  ⊘ ${wf.id}：${wf.reason ?? ''}`);
+            setters.emitProgressLine?.(`  ${figures.elbow} ${figures.skip} ${titleOrId(wf.id)}：${wf.reason ?? ''}`);
             return;
         case 'workflow_done':
-            setters.emitProgressLine?.(`✓ 工作流 ${wf.name} 完成`);
+            setters.emitProgressLine?.(`${figures.ok} 工作流 ${wf.name} 完成`);
+            // 工作流结束：最终刷新（反映完整执行后的上下文量）
+            setters.bump();
             return;
     }
     // 收口到 LoopEvent：未识别的 PluginEvent type 走 default no-op
@@ -592,6 +818,17 @@ export function handleEvent(ev, setters) {
             // 压垮 Ink ANSI 重绘。
             setters.scheduleToolBump();
             break;
+        case 'tool_progress':
+            setters.setRunningToolsMap((prev) => {
+                const current = prev.get(e.toolCallId);
+                if (!current)
+                    return prev;
+                const next = new Map(prev);
+                next.set(e.toolCallId, { ...current, progress: e.message, progressDetail: e.detail });
+                return next;
+            });
+            setters.scheduleToolBump();
+            break;
         case 'tool_end':
             // 仅删除对应 callId 的 entry；其余并行工具继续
             setters.setRunningToolsMap((prev) => {
@@ -636,22 +873,68 @@ export function handleEvent(ev, setters) {
             setters.setInterrupted(true);
             setters.bump();
             break;
-        case 'error':
+        case 'error': {
+            const code = e.code;
+            // compact_failed：非致命压缩失败（loop 会继续硬上）。不当红字，作为黄字暂态提示。
+            if (code === 'compact_failed') {
+                setters.setTransientError?.(`压缩失败（已忽略继续）：${e.error}`);
+                setters.bump();
+                break;
+            }
+            // 工作流步执行中的 max_turns 是可恢复截断信号：runner 会在共享 history 上续跑。
+            // 这里不要落入永久红字错误区；顶层非工作流 max_turns 仍保持原有错误展示。
+            if (code === 'max_turns' &&
+                setters.workflowCtx &&
+                setters.workflowCtx.activeStepId !== null &&
+                setters.setTransientError) {
+                setters.setTransientError('↻ 当前步骤达到轮数预算，正在续跑…');
+                setters.bump();
+                break;
+            }
+            // 工作流步执行中的 llm_error：暂态而非永久红字 ——
+            // 该步通常会被重试，这里只暂存 + 喂 LiveArea 黄字，等 step_end 裁决去留。
+            // 非工作流场景（无活跃 step，或缺 setTransientError 降级）走原有永久红字路径。
+            if (code === 'llm_error' &&
+                setters.workflowCtx &&
+                setters.workflowCtx.activeStepId !== null &&
+                setters.setTransientError) {
+                setters.workflowCtx.pendingLlmError = e.error;
+                setters.setTransientError(`⚠ LLM 调用失败（重试中）：${e.error}`);
+                setters.bump();
+                break;
+            }
+            // 其余：顶层 halt（无 code）、非工作流 llm_error、aborted 等 → 永久红字。
             setters.setError(e.error);
             setters.bump();
             break;
-        case 'warning':
-            // 通用非致命警告。TUI 不把它当红色 error 渲染；workflow 这类插件已另发
-            // plugin_progress 把同一文案镜像到状态行（LiveArea）。这里显式 no-op 让它
-            // 成为"已识别事件"，不触发 default 分支对未知事件的 dev 告警（见 default）。
+        }
+        case 'warning': {
+            // 通用非致命警告。workflow 这类插件已另发 plugin_progress 把同文案镜像到状态行。
+            // 这里额外把"重试 N/M"类警告聚合到 LiveArea 黄色暂态行（覆盖刷新，不 append），
+            // 让用户一眼看出"正在第 N/M 次重试"而非"卡住"。其余 warning 仍 no-op。
+            const msg = e.message;
+            if (setters.setTransientError &&
+                typeof msg === 'string' &&
+                msg.includes('重试')) {
+                setters.setTransientError(`↻ ${msg}`);
+                setters.bump();
+            }
             break;
+        }
         case 'plugin_progress':
             setters.setPluginProgress({
                 pluginId: e.pluginId,
                 current: e.current,
-                max: e.max ?? 0,
+                max: e.max,
                 message: e.message,
             });
+            // 重试进度也镜像到暂态行（覆盖刷新）：runner 在重试时发 "↻ 重试 x N/M…"。
+            // 与 warning 分支互为补充（plugin_progress 文案更短，适合状态行下方一行）。
+            if (setters.setTransientError &&
+                typeof e.message === 'string' &&
+                e.message.includes('↻ 重试')) {
+                setters.setTransientError(e.message);
+            }
             setters.bump();
             break;
         case 'reasoning':
@@ -666,6 +949,17 @@ export function handleEvent(ev, setters) {
             // 工具集合的清空时机是各自 tool_end
             setters.setProgressStage(e.stage);
             break;
+        case 'context_usage':
+            // 内核每轮算出的真实用量（含 tools-schema 开销 + 真实 provider usage）——
+            // 比 StatusLine 本地 useTokenUsage 估算更准，落地后 StatusLine 优先用它。
+            setters.setContextUsage?.({
+                usedTokens: e.usedTokens,
+                contextWindow: e.contextWindow,
+                remainingTokens: e.remainingTokens,
+                compactThreshold: e.compactThreshold,
+                source: e.source,
+            });
+            break;
         default:
             // 落到这里 = 插件私有事件（PluginEvent，type 任意字符串），TUI 不识别即忽略。
             // 这里**故意不**写 console.warn —— Ink 渲染期间写 stdout/stderr 会撕裂终端画面。

package/src/ui/hooks/usePasteHandler.js

@@ -20,7 +20,7 @@
  *    导致只有最后一个换行之前的内容被保留，或者直接触发了发送。
  * ============================================================
  */
-import { useCallback, useRef, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 // 粘贴检测阈值：超过此长度视为粘贴输入
 const PASTE_THRESHOLD = 20;
 // 多 Chunk 等待超时：100ms 内收到的内容视为同一批粘贴
@@ -58,6 +58,16 @@ export function usePasteHandler({ onPasteComplete, multiline = false, }) {
         chunks: [],
         timeoutId: null,
     });
+    // 卸载清理：粘贴中途组件被切走（SessionPicker/ConfigMenu/AskQuestion 顶替）时
+    // 取消挂起的 flush 定时器，防止回调打到已卸载组件。
+    useEffect(() => {
+        return () => {
+            if (pasteStateRef.current.timeoutId) {
+                clearTimeout(pasteStateRef.current.timeoutId);
+                pasteStateRef.current.timeoutId = null;
+            }
+        };
+    }, []);
     /**
      * 刷新 UI 的引用（避免闭包问题）
      */

package/src/ui/hooks/useTextBuffer.js

@@ -8,14 +8,13 @@
  * ============================================================
  */
 import { useCallback, useMemo, useState } from 'react';
-import { bufClear, bufDeleteAt, bufDeleteBefore, bufDeleteWordBefore, bufInsert, bufKillToLineEnd, bufKillToLineStart, bufMoveBufferEnd, bufMoveBufferStart, bufMoveDown, bufMoveLeft, bufMoveLineEnd, bufMoveLineStart, bufMoveRight, bufMoveUp, bufMoveWordLeft, bufMoveWordRight, bufSetText, EMPTY_BUFFER, layoutBuffer, } from '../textBuffer.js';
+import { bufClear, bufDeleteBefore, bufDeleteWordBefore, bufInsert, bufKillToLineEnd, bufKillToLineStart, bufMoveBufferEnd, bufMoveBufferStart, bufMoveDown, bufMoveLeft, bufMoveLineEnd, bufMoveLineStart, bufMoveRight, bufMoveUp, bufMoveWordLeft, bufMoveWordRight, bufSetText, EMPTY_BUFFER, layoutBuffer, } from '../textBuffer.js';
 export function useTextBuffer() {
     const [state, setState] = useState(EMPTY_BUFFER);
     const insert = useCallback((s) => setState((p) => bufInsert(p, s)), []);
     const setText = useCallback((s) => setState(bufSetText(s)), []);
     const clear = useCallback(() => setState(bufClear()), []);
     const deleteBefore = useCallback(() => setState(bufDeleteBefore), []);
-    const deleteAt = useCallback(() => setState(bufDeleteAt), []);
     const deleteWordBefore = useCallback(() => setState(bufDeleteWordBefore), []);
     const killToLineStart = useCallback(() => setState(bufKillToLineStart), []);
     const killToLineEnd = useCallback(() => setState(bufKillToLineEnd), []);
@@ -37,7 +36,6 @@ export function useTextBuffer() {
         setText,
         clear,
         deleteBefore,
-        deleteAt,
         deleteWordBefore,
         killToLineStart,
         killToLineEnd,