mocode-ai 1.7.8 → 1.7.10

package/bin/mocode.js

@@ -2,6 +2,20 @@
 // mocode 全局入口:shebang + 拉起编译产物。子命令(--resume / config)路由在 dist/index.js 的 main() 内,
 // 用动态 import 按需加载,避免 `mocode config`(零配置时)触发 config/index.ts 的 requireEnv 退出。
 
+// Node 编译缓存:把模块字节码缓存到 ~/.mocode/compile-cache,大幅缩短冷态(开机首跑)启动——
+// 磁盘缓存冷时 openai 等大依赖的逐文件编译是首帧最大瓶颈。enableCompileCache 需 Node ≥22.8;
+// 低版本无此 API,跳过(engines 仍为 >=18,不阻塞安装)。缓存目录不可写时 Node 只打 warning 不失败。
+try {
+  const { enableCompileCache } = await import('node:module');
+  if (typeof enableCompileCache === 'function') {
+    const os = await import('node:os');
+    const path = await import('node:path');
+    enableCompileCache(path.join(os.homedir(), '.mocode', 'compile-cache'));
+  }
+} catch {
+  // 旧 Node / 缓存目录异常:退回无缓存路径,行为不变。
+}
+
 // 抑制 openai v4 -> node-fetch v2 -> whatwg-url v5 链触发的 Node 内置 punycode 弃用警告,
 // 防止 [DEP0040] 输出污染终端 UI 的输入框区域。
 const originalEmit = process.emit;

package/dist/agent/index.js

@@ -130,7 +130,7 @@ function writeToolHeader(tc, toolRuntime) {
         const id = batch.beginBatch();
         currentBatchId = id;
         batch.bindCall(tc.id, id);
-        batch.recordCall(id, tc.name, summarizeToolCall(tc.name, tc.arguments));
+        batch.recordCall(id, tc.name, summarizeToolCall(tc.name, tc.arguments), tc.id);
         batch.showLiveBatch(id, layout);
     }
     else {
@@ -143,7 +143,7 @@ function writeToolHeader(tc, toolRuntime) {
         // 结果按 tool_call id 归位：并行执行时 currentBatchId 会漂移，只按“当前批”回填会漏填，
         // 摘要行就永远停在 ◇（用户实测：子 agent 跑完主侧菱形没变成实心圆）。
         batch.bindCall(tc.id, id);
-        batch.recordCall(id, tc.name, summarizeToolCall(tc.name, tc.arguments));
+        batch.recordCall(id, tc.name, summarizeToolCall(tc.name, tc.arguments), tc.id);
         // 第一条工具开始时立即落摘要；后续调用加入同一 batch，并原地刷新计数。
         batch.showLiveBatch(id, layout);
     }
@@ -160,7 +160,7 @@ function writeToolResult(tc, output, parsed, preWriteOld, editStartLine, toolRun
         // 无需独立批。全部 entry 完成后收口组容器批(落完成态 + 开放点击展开),
         // 并与后续内容约定一条分隔空行。
         const preview = summarizeToolResult(tc.name, output);
-        batch.recordResult(batchId, tc.name, preview, null, output, isToolErrorOutput(output), tc.id);
+        batch.recordResult(batchId, tc.name, preview, null, output, isToolErrorOutput(output), tc.id, layout);
         if (batch.isBatchComplete(batchId)) {
             batch.endBatch(batchId, layout);
             subAgentGroupId = null;
@@ -189,7 +189,7 @@ function writeToolResult(tc, output, parsed, preWriteOld, editStartLine, toolRun
         });
     }
     const preview = diff ? '' : summarizeToolResult(tc.name, output);
-    batch.recordResult(batchId, tc.name, preview, diff, output, isToolErrorOutput(output));
+    batch.recordResult(batchId, tc.name, preview, diff, output, isToolErrorOutput(output), tc.id, layout);
     batch.showLiveBatch(batchId, layout);
     // mutation 结果（成功 diff 或错误输出）立即可见，并阻止后续普通工具并入这一批。
     if (isMutationTool(tc.name, toolRuntime))
@@ -404,6 +404,7 @@ runtimeOrContext = defaultRuntime) {
             writeToolHeader(tc, runtime.context.toolRuntime);
         },
         onToolStart: (name) => spinner.start(t('agent.executing', { tool: name })),
+        onToolOutput: (tc, chunk) => batch.recordOutput(tc.id, chunk, layout),
         onToolDone: () => spinner.stop(),
         onToolResult: (tc, output, parsed, preWriteOld, editStartLine) => writeToolResult(tc, output, parsed, preWriteOld, editStartLine, runtime.context.toolRuntime),
         onToolBatchEnd: () => {

package/dist/agent/run-coordinator.js

@@ -326,6 +326,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                     delegation: delegationForOrchestrator,
                                     readDedup,
                                     argumentErrorHint: (name) => argumentErrorHint(name, runtimeContextState),
+                                    onToolOutput: (call, chunk) => hooks.onToolOutput?.(call, chunk),
                                     ...(opts.toolPolicy
                                         ? {
                                             expandToolGroups: (groups, reason) => opts.toolPolicy.expand(groups, reason),
@@ -396,6 +397,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                         for (const index of eligibleReadonly) {
                                             startedReadonly[index] = ctx.toolRuntime.executeToolOutcome(calls[index].name, calls[index].arguments, signal, {
                                                 callId: calls[index].id,
+                                                onOutput: (chunk) => hooks.onToolOutput?.(calls[index], chunk),
                                                 allowedToolNames: currentAllowedToolNames(),
                                                 delegation: delegationForOrchestrator(),
                                                 readDedup,
@@ -566,6 +568,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                         hooks.onToolStart?.(batch[0].name);
                                         const started = batch.map((tc) => ctx.toolRuntime.executeToolOutcome(tc.name, tc.arguments, signal, {
                                             callId: tc.id,
+                                            onOutput: (chunk) => hooks.onToolOutput?.(tc, chunk),
                                             allowedToolNames: currentAllowedToolNames(),
                                             delegation: delegationForOrchestrator(),
                                             readDedup,
@@ -663,6 +666,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                                     ? entry.denied
                                                     : await ctx.toolRuntime.executeToolOutcome(entry.tc.name, entry.tc.arguments, signal, {
                                                         callId: entry.tc.id,
+                                                        onOutput: (chunk) => hooks.onToolOutput?.(entry.tc, chunk),
                                                         allowedToolNames: currentAllowedToolNames(),
                                                         delegation: delegationForOrchestrator(),
                                                         readDedup,
@@ -751,6 +755,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                             const hint = argumentErrorHint(entry.tc.name, runtimeContextState);
                                             return ctx.toolRuntime.executeToolOutcome(entry.tc.name, entry.tc.arguments, signal, {
                                                 callId: entry.tc.id,
+                                                onOutput: (chunk) => hooks.onToolOutput?.(entry.tc, chunk),
                                                 allowedToolNames: currentAllowedToolNames(),
                                                 delegation: delegationForOrchestrator(),
                                                 readDedup,
@@ -846,6 +851,7 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
                                         const serialHint = argumentErrorHint(tc.name, runtimeContextState);
                                         const outcome = await ctx.toolRuntime.executeToolOutcome(tc.name, tc.arguments, signal, {
                                             callId: tc.id,
+                                            onOutput: (chunk) => hooks.onToolOutput?.(tc, chunk),
                                             allowedToolNames: currentAllowedToolNames(),
                                             delegation: delegationForOrchestrator(),
                                             readDedup,

package/dist/agent/stages/tool-dispatcher.js

@@ -44,6 +44,7 @@ class LegacyCompatibleToolDispatcher {
         });
         const execute = (call, hint, onLockAcquired) => toolRuntime.executeToolOutcome(call.name, call.arguments, request.signal, {
             callId: call.id,
+            onOutput: (chunk) => request.onToolOutput?.(call, chunk),
             allowedToolNames: request.currentAllowedToolNames(),
             delegation: request.delegation(),
             readDedup: request.readDedup,

package/dist/config/index.js

@@ -484,8 +484,9 @@ ${buildWorkDisciplineSection(inferModelFamily(config.model))}
 ## Tool policy
 - Silent Execution: invoke tools directly without preamble. Output visible text ONLY for the final answer and critical mid-task findings. Strictly no step-by-step narration (no "let me…", "让我先…", "now checking…" between calls).
 - Go directly to a known path or symbol; use discovery tools only when the location is unknown.
-- Edit against a FRESH read: before any edit_file or a replacing write_file, call read_file on the exact path and copy both its latest hash and the exact target text. Never reconstruct old_string from a grep/summary/diff — those lose whitespace and indentation and cause edit failures. (write_file with append=true is the exception: it reads and hashes the file itself, so no prior read_file and no expected_hash are needed.)
-- A read_file hash from before a compaction, session resume, edit conflict, or external change is STALE and will be rejected — re-read rather than reuse an old hash.
+- Edit against a FRESH read: before editing, call read_file on the exact path and copy the exact target text. Never reconstruct old_string from a grep/summary/diff — those lose whitespace and indentation and cause edit failures.
+- Pick the right file tool: use edit_file for partial changes to an existing file (expected_hash is OPTIONAL in old_string mode, REQUIRED in line-range mode); use write_file only to create a file, to rewrite most of a file (replacing needs the latest read_file hash), or to append (append=true needs no read_file and no hash). Never write a throwaway script (tmp_patch*.cjs, fix_*.py, ...) to modify source files: scripts run outside ChangeSet tracking, so rollback and diff cannot see them.
+- A read_file hash from before a compaction, session resume, edit conflict, or external change is STALE and will be rejected if you pass it. In edit_file old_string mode just omit expected_hash; otherwise re-read rather than reuse an old hash.
 - Emit multiple independent tool calls in ONE assistant message so they run concurrently — e.g. several read_file regions, a grep plus a glob, or several web_fetch calls. One lookup per message wastes a full model round-trip each time. Place parallel-safe calls consecutively; keep any call that depends on their results (e.g. an edit) for the next message.
 - Never batch a read with an edit that depends on it; do not repeat overlapping reads or unchanged failed calls.
 - On failure, inspect the full error, change the approach, and retry only with a reason. Drop stale tool output when it no longer supports the task.

package/dist/i18n/index.js

@@ -164,6 +164,8 @@ const zhCN = {
     'repl.queuedCommandHeld': '排队的是斜杠命令，已填入输入框，请确认后手动发送',
     'repl.loadFailed': '（加载失败）',
     'repl.resumeAnchor': '已恢复会话 {id} · {count} 条消息 · 当前模型 {model}（/model switch 可切换）',
+    'repl.compactedNotice': '── 更早的对话已被压缩成摘要（助手回复与工具过程不再保留），以下为摘要与保留的用户原话 ──',
+    'repl.compactedTruncated': '…（摘要共 {total} 字符，仅显示前 {shown} 字符）',
     'repl.noSessions': '（没有已保存的会话）',
     'repl.noValue': '（无）',
     'repl.historyCleared': '（历史已清空，保留系统提示）',
@@ -554,6 +556,8 @@ const en = {
     'repl.queuedCommandHeld': 'Queued text is a slash command; filled into the input for you to send manually',
     'repl.loadFailed': '(load failed)',
     'repl.resumeAnchor': 'Resumed session {id} · {count} messages · model {model} (/model switch to change)',
+    'repl.compactedNotice': '── Earlier conversation was compacted into a summary (assistant replies and tool steps are not kept); below are the summary and the preserved user messages ──',
+    'repl.compactedTruncated': '… (summary is {total} chars, showing the first {shown})',
     'repl.noSessions': '(no saved sessions)',
     'repl.noValue': '(none)',
     'repl.historyCleared': '(history cleared; system prompt kept)',

package/dist/llm/index.js

@@ -1,4 +1,3 @@
-import OpenAI from 'openai';
 import { config, getActiveModel } from '../config/index.js';
 import { tools } from '../tools/registry.js';
 import { getPlanDisabledTools, getProfileDisabledTools } from '../tools/constants.js';
@@ -49,8 +48,26 @@ const STREAM_RETRY_MAX_ATTEMPTS = 2;
  * 与 OpenAI 兼容协议的独立 `reasoning_content` 字段不同,这些模型把 thinking 直接嵌进 content
  * 字符串,期间不调 onText(spinner 持续转 ⠹ 思考中…),也不写入可见 content(history 不被思考段污染)。
  */
-function newOpenAIClient(runtimeConfig) {
-    return new OpenAI({
+// ── openai SDK 懒加载 ────────────────────────────────────────────────────────
+// openai 是千余文件的巨型 CJS 包,冷态(开机磁盘缓存冷)首次加载实测 3.8–6s,
+// 是首帧 UI 最大瓶颈。静态 import 会在模块求值时把它整个拉进来。这里:
+//   1) 模块顶层只保留类型,不加载包;
+//   2) getOpenAI() 首次调用时动态 import(异步,不阻塞构造);
+//   3) 首帧后由 src/startup/prewarm 在后台(Worker 冷编译 + 主线程热加载)提前就绪。
+let openAIModulePromise = null;
+/** 加载 openai 包(预热与首次实例化共用,全程只加载一次)。 */
+function loadOpenAIModule() {
+    if (!openAIModulePromise) {
+        openAIModulePromise = import('openai');
+    }
+    return openAIModulePromise;
+}
+/** 首帧后后台预热:提前把 openai 包加载进内存,让首次真实请求零等待。幂等,失败静默。 */
+export function prewarmLlm() {
+    return loadOpenAIModule();
+}
+function newOpenAIClient(mod, runtimeConfig) {
+    return new mod.default({
         baseURL: runtimeConfig.baseURL,
         apiKey: runtimeConfig.apiKey,
         maxRetries: 0,
@@ -58,16 +75,31 @@ function newOpenAIClient(runtimeConfig) {
 }
 /** Build mutable client state owned by one runtime; no module-global overrides are consulted. */
 export function createChatClientState(runtimeConfig, overrides = {}) {
-    installEnvProxy();
+    let cfg = runtimeConfig;
+    let clientPromise = null;
     return {
-        openAI: newOpenAIClient(runtimeConfig),
+        getOpenAI() {
+            if (!clientPromise) {
+                // 代理(undici)同样懒装:百毫秒级依赖,且只影响真实出站请求。
+                clientPromise = (async () => {
+                    await installEnvProxy();
+                    const mod = await loadOpenAIModule();
+                    return newOpenAIClient(mod, cfg);
+                })();
+            }
+            return clientPromise;
+        },
+        resetOpenAI(nextConfig) {
+            cfg = nextConfig;
+            clientPromise = null;
+        },
         openAICreateImpl: overrides.openAICreateImpl ?? null,
         anthropicFetchImpl: overrides.anthropicFetchImpl ?? fetch,
     };
 }
 /** Rebuild only the OpenAI SDK client while preserving runtime-local test/transport overrides. */
 export function reconfigureChatClient(state, runtimeConfig) {
-    state.openAI = newOpenAIClient(runtimeConfig);
+    state.resetOpenAI(runtimeConfig);
 }
 const defaultClientState = createChatClientState(config, { anthropicFetchImpl: defaultAnthropicFetch });
 const defaultProviderRuntime = {
@@ -75,6 +107,13 @@ const defaultProviderRuntime = {
     getModel: getActiveModel,
     clientState: defaultClientState,
 };
+/**
+ * 首帧后后台预热默认客户端:在用户阅读 banner / 输入需求的时间窗里提前加载 openai 并实例化,
+ * 让首次真实请求不必再付冷加载成本。fire-and-forget,任何失败静默(真实请求路径会自行重试/报错)。
+ */
+export function prewarmDefaultClient() {
+    void defaultClientState.getOpenAI().catch(() => undefined);
+}
 /**
  * 运行时重建 OpenAI 客户端(/model 切换 baseURL/apiKey 后调)。
  * config.model 已在 chat() 每次读取(热切),但 client 的 baseURL/apiKey 是构造时固化的实例字段,
@@ -648,7 +687,10 @@ async function chatOnce(messages, handlers, signal, toolsOverride, runtime = def
     const runtimeClientState = runtime.clientState;
     const create = runtimeClientState.openAICreateImpl
         ? runtimeClientState.openAICreateImpl
-        : (body, opts) => runtimeClientState.openAI.chat.completions.create(body, opts);
+        : async (body, opts) => {
+            const client = await runtimeClientState.getOpenAI();
+            return client.chat.completions.create(body, opts);
+        };
     // transport 边界消毒:剔除部分后端(kimi-k3@dashscope 实测)整请求 400 拒绝的
     // uniqueItems 关键字。无需改写时返回原引用,前缀缓存逐字节稳定不受影响。
     const activeTools = sanitizeToolSchemas(toolsOverride ?? chatTools);

package/dist/llm/proxy.js

@@ -9,8 +9,10 @@
  * 幂等：进程内只安装一次。MOCODE_NO_ENV_PROXY=1 可完全关闭。
  */
 import { execSync } from 'node:child_process';
-import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
+// undici 懒加载:它是百毫秒级依赖,而代理安装只在首个真实出站请求时才需要(首帧 UI 不需要)。
+// 故不在模块顶层 import,改在 installEnvProxy 内动态 import。
 let installed = false;
+let installPromise = null;
 function withProtocol(value) {
     return /^https?:\/\//i.test(value) ? value : `http://${value}`;
 }
@@ -87,38 +89,46 @@ function keepAliveTimeoutMs() {
 }
 export function installEnvProxy() {
     if (installed)
-        return;
+        return Promise.resolve();
+    if (installPromise)
+        return installPromise;
     installed = true;
-    if (process.env.MOCODE_NO_ENV_PROXY === '1')
-        return;
-    const envProxy = process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
-    const windowsOptions = windowsProxyOptions();
-    const options = envProxy ? undefined : (windowsOptions ?? undefined);
-    if (!envProxy && !windowsOptions)
-        return;
-    // EnvHttpProxyAgent 构造时会通过 process.emitWarning 打一条 UNDICI-EHPA 实验性警告，
-    // 在 TUI 里可能落成脏行；屏蔽这一条特定警告，其余警告照常。
-    const originalEmitWarning = process.emitWarning.bind(process);
-    process.emitWarning = ((...args) => {
-        const first = args[0];
-        if (typeof first === 'string' && first.includes('EnvHttpProxyAgent is experimental'))
+    installPromise = (async () => {
+        if (process.env.MOCODE_NO_ENV_PROXY === '1')
             return;
-        return originalEmitWarning(...args);
-    });
-    try {
-        // keepalive 调参:EnvHttpProxyAgent 把 ...agentOpts 透传给内部 Agent/ProxyAgent
-        // (undici 6.21 env-http-proxy-agent.js 构造器),Client 层消费这三个选项。
-        // threshold 刻意高于默认 2s:undici 会在「服务端 Keep-Alive 头声明的存活期 − threshold」
-        // 时刻掐自己的空闲连接,若代理声明的存活期略长于我们的 keepAliveTimeout,留出余量
-        // 可避免双方同时收线时撞上刚被掐死的连接(那正是 ECONNRESET 的形态)。
-        setGlobalDispatcher(new EnvHttpProxyAgent({
-            ...(options ?? {}),
-            keepAliveTimeout: keepAliveTimeoutMs(),
-            keepAliveMaxTimeout: 600_000,
-            keepAliveTimeoutThreshold: 5_000,
-        }));
-    }
-    finally {
-        process.emitWarning = originalEmitWarning;
-    }
+        const envProxy = process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
+        // reg query(同步子进程)只在没有 env 代理时才探测 Windows 系统代理,避免无谓启动。
+        const windowsOptions = envProxy ? null : windowsProxyOptions();
+        const options = envProxy ? undefined : (windowsOptions ?? undefined);
+        if (!envProxy && !windowsOptions)
+            return;
+        const { EnvHttpProxyAgent, setGlobalDispatcher } = await import('undici');
+        // EnvHttpProxyAgent 构造时会通过 process.emitWarning 打一条 UNDICI-EHPA 实验性警告，
+        // 在 TUI 里可能落成脏行；屏蔽这一条特定警告，其余警告照常。
+        const originalEmitWarning = process.emitWarning.bind(process);
+        process.emitWarning = ((...args) => {
+            const first = args[0];
+            if (typeof first === 'string' && first.includes('EnvHttpProxyAgent is experimental'))
+                return;
+            return originalEmitWarning(...args);
+        });
+        try {
+            // keepalive 调参:EnvHttpProxyAgent 把 ...agentOpts 透传给内部 Agent/ProxyAgent
+            // (undici 6.21 env-http-proxy-agent.js 构造器),Client 层消费这三个选项。
+            // threshold 刻意高于默认 2s:undici 会在「服务端 Keep-Alive 头声明的存活期 − threshold」
+            // 时刻掐自己的空闲连接,若代理声明的存活期略长于我们的 keepAliveTimeout,留出余量
+            // 可避免双方同时收线时撞上刚被掐死的连接(那正是 ECONNRESET 的形态)。
+            setGlobalDispatcher(new EnvHttpProxyAgent({
+                ...(options ?? {}),
+                keepAliveTimeout: keepAliveTimeoutMs(),
+                keepAliveMaxTimeout: 600_000,
+                keepAliveTimeoutThreshold: 5_000,
+            }));
+        }
+        finally {
+            process.emitWarning = originalEmitWarning;
+        }
+    })();
+    // 安装失败不影响后续重试语义;这里只保证并发调用复用同一 promise。
+    return installPromise;
 }

package/dist/pet/bridge.js

@@ -4,8 +4,20 @@
 import { createRequire } from 'node:module';
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
-import WebSocket from 'ws';
 import { parseServerMessage } from './protocol.js';
+// ws 懒加载:桌宠是可选增强,首帧 UI 与主 agent 循环都不需要 WebSocket。
+// 仅在真正发起本地连接(probePort / connect)时才同步加载;类型仍用 type-only import。
+const require = createRequire(import.meta.url);
+/** ws readyState 常量(open=1),与 WebSocket.OPEN 等价;本地常量避免顶层加载包。 */
+const WS_OPEN = 1;
+let WsCtor = null;
+function getWsCtor() {
+    if (!WsCtor) {
+        const mod = require('ws');
+        WsCtor = mod.default ?? mod;
+    }
+    return WsCtor;
+}
 /** 默认端口;MOCODE_PET_PORT 环境变量覆盖(design.md 默认假设)。 */
 export const DEFAULT_PET_PORT = 47821;
 function petPort() {
@@ -40,7 +52,7 @@ function clearHeartbeat() {
 function startHeartbeat(ws) {
     clearHeartbeat();
     heartbeatTimer = setInterval(() => {
-        if (ws.readyState !== WebSocket.OPEN)
+        if (ws.readyState !== WS_OPEN)
             return;
         try {
             ws.send(JSON.stringify({ type: 'ping', ts: Date.now() }));
@@ -68,7 +80,7 @@ function startHeartbeat(ws) {
 export function probePort(port, timeoutMs = PROBE_TIMEOUT_MS) {
     return new Promise((resolve) => {
         let settled = false;
-        const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+        const ws = new (getWsCtor())(`ws://127.0.0.1:${port}`);
         const timer = setTimeout(() => {
             if (settled)
                 return;
@@ -114,7 +126,6 @@ export function spawnPetProcess() {
     return new Promise((resolve, reject) => {
         let binPath;
         try {
-            const require = createRequire(import.meta.url);
             binPath = require.resolve('mocode-pet-app/bin/pet-app.js');
         }
         catch {
@@ -168,7 +179,7 @@ function sleep(ms) {
 /** 真正建立并返回一条打开的 WS 连接(不做探测,假定端口已确认可连)。 */
 function openConnection(port) {
     return new Promise((resolve, reject) => {
-        const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+        const ws = new (getWsCtor())(`ws://127.0.0.1:${port}`);
         const timer = setTimeout(() => {
             try {
                 ws.terminate();
@@ -241,7 +252,7 @@ function wireConnection(ws) {
  * 后置条件:若 state !== lastSentState,构造并发送一条合法 StateMessage;否则无副作用。
  */
 export function sendState(state, meta) {
-    if (!socket || socket.readyState !== WebSocket.OPEN)
+    if (!socket || socket.readyState !== WS_OPEN)
         return; // 未连接:no-op,不缓冲不报错
     if (state === lastSentState)
         return; // 节流:状态未变化不重发
@@ -256,7 +267,7 @@ export function sendState(state, meta) {
 }
 /** 当前是否已建立活跃连接。 */
 export function isConnected() {
-    return !!socket && socket.readyState === WebSocket.OPEN;
+    return !!socket && socket.readyState === WS_OPEN;
 }
 /** 主动断开连接(best-effort 发 bye 后 close code=1000)。 */
 export function disconnect() {
@@ -288,7 +299,7 @@ export async function killPetProcess() {
     const port = petPort();
     let ws = socket;
     let owned = false; // 是否为本函数临时建立的连接(需要负责关闭)
-    if (!ws || ws.readyState !== WebSocket.OPEN) {
+    if (!ws || ws.readyState !== WS_OPEN) {
         const already = await probePort(port, PROBE_TIMEOUT_MS);
         if (!already) {
             return { ok: false, reason: '桌宠未运行' };
@@ -365,7 +376,7 @@ export async function listSkins() {
  * 后置条件:已连接时发送 set_skin 消息;未连接时不抛错、无副作用。
  */
 export function setSkin(skinId) {
-    if (!socket || socket.readyState !== WebSocket.OPEN)
+    if (!socket || socket.readyState !== WS_OPEN)
         return;
     try {
         socket.send(JSON.stringify({ type: 'set_skin', clientId, skinId, ts: Date.now() }));

package/dist/repl/message-format.js

@@ -3,7 +3,12 @@ import * as layout from '../ui/layout.js';
 import * as batch from '../ui/batch.js';
 import { displayWidth, padEndDisplay, summarizeToolCall, summarizeToolResult } from '../ui/render.js';
 import { renderChip } from '../attachments/image.js';
+import { t } from '../i18n/index.js';
 import { PROMPT } from './commands.js';
+/** compact 摘要消息头(与 session/compact.ts SUMMARY_MARKER 同值;本地复制避免拉入 compact 的重依赖图,同 retention.ts)。 */
+const SUMMARY_MARKER = '# 会话摘要';
+/** 回放时摘要最多显示的字符数(摘要上限 6000,全量回放会淹没保留的用户原话)。 */
+const SUMMARY_REPLAY_MAX_CHARS = 3000;
 /** side channel:history 中 user 消息的 index → 附件列表,供 renderHistory 复显文件名。runTurn 在 push 前设。 */
 export const messageAttachments = new Map();
 export function formatUserMessage(lines, trailingBlank = true) {
@@ -69,8 +74,25 @@ export function renderHistory(history) {
     };
     for (let idx = 0; idx < history.length; idx++) {
         const m = history[idx];
-        if (m.role === 'system')
+        if (m.role === 'system') {
+            // compact 摘要是被压缩掉的助手回复/工具过程的唯一留存:回放时显示出来(history[0] 的系统提示仍跳过)。
+            const body = textOf(m.content);
+            if (idx > 0 && body.startsWith(SUMMARY_MARKER)) {
+                flushBatch();
+                layout.normalizeMutationBoundary();
+                layout.contentWrite(`${ui.dim}${t('repl.compactedNotice')}${ui.reset}\n\n`);
+                const text = body.slice(SUMMARY_MARKER.length).trim();
+                if (text.length > SUMMARY_REPLAY_MAX_CHARS) {
+                    layout.contentWriteMdOnce(text.slice(0, SUMMARY_REPLAY_MAX_CHARS));
+                    layout.contentWrite(`${ui.dim}${t('repl.compactedTruncated', { total: text.length, shown: SUMMARY_REPLAY_MAX_CHARS })}${ui.reset}\n`);
+                }
+                else {
+                    layout.contentWriteMdOnce(text);
+                }
+                layout.normalizeMutationBoundary();
+            }
             continue;
+        }
         if (m.role === 'user') {
             flushBatch(); // 上一轮 batch(若有)收尾
             const lines = textOf(m.content).split('\n');

package/dist/repl/runtime.js

@@ -15,6 +15,7 @@ import * as mouse from '../ui/mouse.js';
 import { promptWithSlashMenu, promptTurnPicker, promptRevertChoice } from '../ui/prompt.js';
 import { promptIntervention } from '../ui/intervention.js';
 import { registerToolsExtension } from '../tools/registry.js';
+import { startPrewarm, defaultWorkerUrl } from '../startup/prewarm.js';
 // 装配官方默认工具包:registry 不再顶层 import builtins(破模块循环),REPL 入口须显式装配。
 import '../tools/builtins/index.js';
 import { initializeAllMcp, getMcpTools, closeAllMcp } from '../mcp/index.js';
@@ -277,6 +278,10 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
     else {
         layout.writeBanner(bannerLines(banner()));
     }
+    // 首帧已渲染(banner / 恢复历史)。立刻后台预热重依赖(openai/fast-glob/cli-highlight/ajv/…):
+    // 占满用户阅读 banner / 思考 / 打字的时间窗,Worker 冷编译不冻结 TUI,主线程随后分块热加载,
+    // 让首次真实请求(首 token)不再付冷加载成本。fire-and-forget,失败静默。
+    startPrewarm(defaultWorkerUrl());
     // MCP 连接结果在就绪后补写(后台并行连接,不再阻塞上方首帧);用户已滚动时仍
     // 落在内容区尾部,与启动期其它提示行为一致。
     void mcpReady.then((mcpReport) => {

package/dist/startup/prewarm-worker.js

@@ -0,0 +1,23 @@
+// 预热 Worker:在独立线程里串行冷加载所有重依赖,目的是:
+//   1) 把磁盘冷读 + V8 冷编译的主线程冻结成本移出 TUI(Worker 不阻塞 UI 事件循环);
+//   2) 热好编译缓存目录(主线程与 Worker 共享同一缓存)。
+// Worker 加载完发 'done' 即退出;它加载的模块不进入主线程模块缓存,主线程随后再热加载一次。
+import { parentPort } from 'node:worker_threads';
+const SPECS = ['openai', 'fast-glob', 'cli-highlight', 'ajv', 'ajv/dist/2020.js', 'undici', 'ws'];
+async function main() {
+    for (const spec of SPECS) {
+        try {
+            await import(spec);
+            parentPort?.postMessage({ type: 'loaded', spec });
+        }
+        catch (error) {
+            parentPort?.postMessage({
+                type: 'failed',
+                spec,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    parentPort?.postMessage({ type: 'done' });
+}
+void main();

package/dist/startup/prewarm.js

@@ -0,0 +1,86 @@
+// 首帧后重依赖预热调度。
+//
+// 启动时序目标:UI 首帧绝不等任何重依赖(openai 冷加载实测 3.8–6s、fast-glob ~3.5s),
+// 但首 token 也不能等——所以在首帧渲染完成后立刻后台预热,占满用户阅读 banner / 思考 /
+// 打字的时间窗:
+//
+//   阶段 A(Worker 冷编译):独立线程串行冷加载 openai/fast-glob/cli-highlight/ajv/undici/ws,
+//     把磁盘冷读 + V8 冷编译的主线程冻结移出 TUI,并热好共享编译缓存。
+//   阶段 B(主线程分块热加载):Worker 完成后,在主线程把真正要用的模块逐个 await 进
+//     模块缓存。经过阶段 A 后每块仅数十毫秒,且用 setTimeout 切到宏任务,不阻塞输入响应。
+//
+// 若 Worker 不可用(旧 Node / 资源限制),退化为直接阶段 B(首次热加载稍慢但功能不变)。
+// 所有失败静默:真实使用路径的懒加载/重试不受影响。
+import { Worker } from 'node:worker_threads';
+import { prewarmLlm, prewarmDefaultClient } from '../llm/index.js';
+import { loadFastGlob } from '../tools/fast-glob-lazy.js';
+import { prewarmCliHighlight } from '../ui/cli-highlight-lazy.js';
+import { prewarmAjv } from '../tools/validation.js';
+let started = false;
+/** 阶段 B:主线程逐个热加载,块间让出事件循环。 */
+async function warmMainThread() {
+    // openai 包 + 默认客户端实例(含代理安装),最先热——它决定首 token。
+    await prewarmLlm();
+    prewarmDefaultClient();
+    const steps = [
+        () => loadFastGlob(),
+        () => prewarmCliHighlight(),
+        () => prewarmAjv(),
+        () => import('undici'),
+        () => import('ws'),
+    ];
+    for (const step of steps) {
+        // 每块之间让出一次事件循环,避免连续热加载累积成可感知的输入卡顿。
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        try {
+            await step();
+        }
+        catch {
+            // 单个依赖预热失败不影响其余;真实路径会自行加载/报错。
+        }
+    }
+}
+/**
+ * 首帧渲染后调用一次(幂等)。fire-and-forget:绝不阻塞返回,绝不向调用方抛错。
+ * @param workerUrl 预热 worker 的文件 URL;由调用方按 dist 布局传入。
+ */
+export function startPrewarm(workerUrl) {
+    if (started)
+        return;
+    started = true;
+    const beginWarmMain = () => {
+        void warmMainThread().catch(() => undefined);
+    };
+    let worker = null;
+    try {
+        worker = new Worker(workerUrl, { stderr: false, stdout: false, execArgv: [] });
+    }
+    catch {
+        // Worker 构造失败:直接在主线程预热(稍慢,但功能等价)。
+        beginWarmMain();
+        return;
+    }
+    let finished = false;
+    const finish = () => {
+        if (finished)
+            return;
+        finished = true;
+        try {
+            worker?.terminate();
+        }
+        catch {
+            // 尽力清理
+        }
+        beginWarmMain();
+    };
+    worker.on('message', (msg) => {
+        if (msg?.type === 'done')
+            finish();
+    });
+    worker.on('error', finish);
+    worker.on('exit', finish);
+}
+/** 供 dist 布局解析 worker 入口:与本文件同目录的 prewarm-worker.js。 */
+export function defaultWorkerUrl() {
+    return new URL('./prewarm-worker.js', import.meta.url);
+}

package/dist/tools/builtins/edit-file.js

@@ -1,6 +1,9 @@
 import { readFile } from 'node:fs/promises';
 import { jailResolve } from '../../sandbox/index.js';
-import { commitChangeSet, createChangeSet, normalizeContentHash, summarizeChangeSet } from '../../changeset/index.js';
+import { commitChangeSet, contentHash, createChangeSet, normalizeContentHash, summarizeChangeSet, } from '../../changeset/index.js';
+import { isProbablyBinary } from '../../attachments/image.js';
+/** 二进制嗅探只需文件头,与 read_file / write_file 同口径(16KB)。 */
+const SNIFF_BYTES = 16 * 1024;
 function conflict(path, details) {
     return {
         status: 'error',
@@ -8,18 +11,16 @@ function conflict(path, details) {
         retryable: false,
         changedFiles: [],
         staleFiles: [path],
-        output: `CHANGE_CONFLICT: ${path} was not changed. ${details} Do not retry these arguments. Call read_file on this exact path and copy both its latest hash and exact target text before editing again.`,
+        output: `CHANGE_CONFLICT: ${path} was not changed. ${details} Do not retry these arguments. Call read_file on this exact path and copy the exact target text (plus its latest hash if you pass expected_hash, which line-range mode requires) before editing again.`,
     };
 }
 export const editFileTool = {
     name: 'edit_file',
     description: `Replace content in a file transactionally. Two modes:
 
-**String replacement (default):** old_string must occur EXACTLY once; copy it verbatim from a fresh read_file output (see Tool policy — never reconstruct it from memory, summaries, or grep output).
+**String replacement (default):** old_string must occur EXACTLY once; copy it verbatim from a fresh read_file output (see Tool policy — never reconstruct it from memory, summaries, or grep output). expected_hash is OPTIONAL in this mode: omit it and the tool checks the file itself (old_string must still match exactly once, and the commit is conflict-checked). If you do pass it, it must match the current file or the edit is rejected.
 
-**Line-range:** line_start/line_end (1-based, inclusive) instead of old_string — for large blocks, repeated patterns, or hard-to-reproduce text.
-
-expected_hash (sha256 from the read_file artifact header) is required and must match the current file; changed-since-read edits are rejected — re-read and retry with the new hash.`,
+**Line-range:** line_start/line_end (1-based, inclusive) instead of old_string — for large blocks, repeated patterns, or hard-to-reproduce text. Line numbers drift when a file changes, so expected_hash (sha256 from the read_file artifact header) is REQUIRED here; if it is stale, re-read and retry with the new hash.`,
     risk: 'confirm',
     parameters: {
         type: 'object',
@@ -40,22 +41,19 @@ expected_hash (sha256 from the read_file artifact header) is required and must m
             },
             expected_hash: {
                 type: 'string',
-                description: 'sha256 hash from the latest read_file artifact header (sha256:<64 hex>).',
+                description: 'sha256 hash from the latest read_file artifact header (sha256:<64 hex>). Optional for old_string mode; required for line-range mode.',
             },
         },
         // 注意:expected_hash 故意不放进 schema 的 required。
-        // 原因:缺失时若被 AJV 在 schema 层拦下,只会得到泛化的
-        // "缺少必填字段 expected_hash",模型据此只补该字段、反而丢掉 path,形成乒乓失败。
-        // 改为只在 execute 内校验(见下方 normalizeContentHash 检查),缺失时返回富指导信息,
-        // 明确要求先 read_file 并复制最新 hash——与 write_file 的设计保持一致。
+        // 原因:old_string 模式下它是可选的(old_string 唯一命中本身就是基于内容的前置条件,
+        // 提交时 ChangeSet 仍会比对读到的内容 hash 防并发改动);行号模式下必填,但缺失时若被
+        // AJV 在 schema 层拦下,只会得到泛化的「缺少必填字段 expected_hash」,模型据此只补该字段、
+        // 反而丢掉 path,形成乒乓失败。故只在 execute 内校验,缺失时返回富指导信息。
         required: ['path', 'new_string'],
     },
     async execute(args, ctx) {
         const file = String(args.path);
         const newString = String(args.new_string);
-        const expectedHash = normalizeContentHash(String(args.expected_hash));
-        if (!expectedHash)
-            return conflict(file, 'expected_hash 必须是 sha256:<64 hex>。');
         const hasOldString = args.old_string !== undefined;
         const hasLineStart = args.line_start !== undefined;
         const hasLineEnd = args.line_end !== undefined;
@@ -66,7 +64,25 @@ expected_hash (sha256 from the read_file artifact header) is required and must m
         if (!hasOldString && (!hasLineStart || !hasLineEnd)) {
             return conflict(file, '必须提供 old_string 或同时提供 line_start 和 line_end。');
         }
-        const data = await readFile(jailResolve(file), 'utf8');
+        // expected_hash:缺省/null/空串都视为「未提供」。提供了就必须格式正确并严格校验。
+        const rawHash = args.expected_hash;
+        const hashProvided = rawHash !== undefined && rawHash !== null && String(rawHash).trim() !== '';
+        let expectedHash = hashProvided ? normalizeContentHash(String(rawHash)) : null;
+        if (hashProvided && !expectedHash)
+            return conflict(file, 'expected_hash 必须是 sha256:<64 hex>。');
+        if (!hasOldString && !expectedHash) {
+            return conflict(file, '行号模式必须提供 expected_hash(行号会随文件变化漂移,需要内容版本锚点)。');
+        }
+        // 以 Buffer 读取并按 Buffer 算 hash,与 ChangeSet 内部口径一致(非法 UTF-8 时字符串 hash 会对不上)。
+        const buffer = await readFile(jailResolve(file));
+        if (isProbablyBinary(buffer.subarray(0, SNIFF_BYTES))) {
+            return conflict(file, '是二进制文件,不能按文本编辑(utf8 往返会损毁原有字节)。');
+        }
+        // 未提供 hash:用刚读到的内容算。读与提交之间的窗口由 ChangeSet 的 dry-run + 提交前复核兜底,
+        // 期间文件被改会报 CHANGE_CONFLICT(fail-loud),不会静默覆盖。
+        if (!expectedHash)
+            expectedHash = contentHash(buffer);
+        const data = buffer.toString('utf8');
         const normalized = data.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
         const newNormalized = newString.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
         let updated;

package/dist/tools/builtins/glob.js

@@ -1,4 +1,4 @@
-import fg from 'fast-glob';
+import { loadFastGlob } from '../fast-glob-lazy.js';
 import { IGNORE } from '../constants.js';
 import { getSandboxRoot, isInsideRoot } from '../../sandbox/index.js';
 /**
@@ -39,6 +39,7 @@ export const globTool = {
         try {
             // fast-glob 3.3 的 signal 选项运行时不生效(实测),用 Promise.race 做超时/中断墙:
             // 触发后不再等待枚举——纯只读 readdir 会自行跑完,用户面即时解锁。
+            const fg = await loadFastGlob();
             const fgPromise = fg(pattern, {
                 cwd,
                 onlyFiles: true,

package/dist/tools/builtins/grep.js

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import fg from 'fast-glob';
+import { loadFastGlob } from '../fast-glob-lazy.js';
 import { IGNORE, MAX_RESULTS } from '../constants.js';
 import { isProbablyBinary } from '../../attachments/image.js';
 import { getSandboxRoot, isInsideRoot, jailResolve } from '../../sandbox/index.js';
@@ -97,6 +97,7 @@ async function nodeFallback(pattern, glob, maxPerFile, context, signal, external
         return `错误:非法正则 ${pattern}: ${e instanceof Error ? e.message : String(e)}`;
     }
     const cwd = getSandboxRoot() ?? process.cwd();
+    const fg = await loadFastGlob();
     const entries = (await fg(glob, {
         cwd,
         onlyFiles: true,

package/dist/tools/builtins/run-command.js

@@ -46,7 +46,7 @@ class BoundedCommandOutput {
     }
 }
 /** Execute a command with the same sandbox, output cap and cancellation semantics as run_command. */
-export async function runCommandRaw(command, timeout = DEFAULT_COMMAND_TIMEOUT_MS, signal, cwd, shell) {
+export async function runCommandRaw(command, timeout = DEFAULT_COMMAND_TIMEOUT_MS, signal, cwd, shell, onOutput) {
     const startedAt = Date.now();
     // 内部调用方(skill 注入等)也走同一钳制:防止任何路径把前台命令挂成无限期持锁。
     const effectiveTimeout = clampCommandTimeout(timeout);
@@ -124,7 +124,16 @@ export async function runCommandRaw(command, timeout = DEFAULT_COMMAND_TIMEOUT_M
         const onAbort = () => {
             terminate('aborted');
         };
-        const onChunk = (chunk) => output.append(chunk.toString('utf8'));
+        const onChunk = (chunk) => {
+            const text = chunk.toString('utf8');
+            output.append(text);
+            try {
+                onOutput?.(text);
+            }
+            catch {
+                // Output observers must not affect the command process lifecycle.
+            }
+        };
         // 先起 timer 再挂事件:finish/onAbort 是闭包,里面要 clearTimeout(timer)。
         // 把 timer 的初始化提到所有引用它的注册点之前,避免依赖"事件回调必然异步"这一前提。
         const timer = setTimeout(() => {
@@ -221,7 +230,7 @@ export const runCommandTool = {
             }
             shell = parsed;
         }
-        const result = await runCommandRaw(command, timeout, ctx?.signal, undefined, shell);
+        const result = await runCommandRaw(command, timeout, ctx?.signal, undefined, shell, ctx?.onOutput);
         const outcome = commandOutcome(result);
         // 钳制要显式告知:模型传了 30min 却按 10min 判超时,不说清它会以为是环境抽风而盲目重试。
         if (args.timeout !== undefined && Number(args.timeout) !== timeout && result.status === 'timed_out') {

package/dist/tools/fast-glob-lazy.js

@@ -0,0 +1,12 @@
+let fgPromise = null;
+/** 首次调用动态加载 fast-glob;之后返回同一实例。 */
+export function loadFastGlob() {
+    if (!fgPromise) {
+        fgPromise = import('fast-glob').then((m) => m.default ?? m);
+    }
+    return fgPromise;
+}
+/** 首帧后后台预热;幂等,失败静默(真实枚举路径会自行处理)。 */
+export function prewarmFastGlob() {
+    return loadFastGlob();
+}

package/dist/tools/tool-runtime.js

@@ -290,6 +290,7 @@ export class ToolRuntime {
                     raw = await tool.execute(args, {
                         signal,
                         callId: opts?.callId,
+                        onOutput: opts?.onOutput,
                         allowedToolNames: opts?.allowedToolNames,
                         delegation: opts?.delegation,
                         readDedup: opts?.readDedup,

package/dist/tools/validation.js

@@ -1,5 +1,10 @@
-import Ajv from 'ajv';
-import Ajv2020 from 'ajv/dist/2020.js';
+import { createRequire } from 'node:module';
+// ajv 懒加载:它本身不算巨包,但顶层就构造 draft7/draft2020 两个实例会把包求值提前到启动路径
+// (tool-runtime → validation)。首帧 UI 不做任何参数校验,故推迟到首次 compile 时才加载。
+const require = createRequire(import.meta.url);
+let draft7 = null;
+let draft2020 = null;
+let ajvPromise = null;
 const options = {
     allErrors: true,
     strict: false,
@@ -12,16 +17,32 @@ const options = {
     validateFormats: false,
     allowUnionTypes: true,
 };
-const draft7 = new Ajv(options);
-const draft2020 = new Ajv2020(options);
+/** 首次真实工具参数校验时才加载 ajv 并构造两个 draft 实例。 */
+function ensureAjv() {
+    if (draft7 && draft2020)
+        return { draft7, draft2020 };
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const Ajv = require('ajv');
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const Ajv2020 = require('ajv/dist/2020.js');
+    draft7 = new Ajv(options);
+    draft2020 = new Ajv2020(options);
+    return { draft7, draft2020 };
+}
+/** 首帧后后台预热;与同步 require 共享模块缓存。失败静默。 */
+export function prewarmAjv() {
+    if (!ajvPromise) {
+        ajvPromise = Promise.all([import('ajv'), import('ajv/dist/2020.js')]).catch(() => undefined);
+    }
+    return ajvPromise;
+}
 const cache = new WeakMap();
 function compile(schema) {
     const cached = cache.get(schema);
     if (cached)
         return cached;
-    const preferred = typeof schema.$schema === 'string' && schema.$schema.includes('2020-12')
-        ? [draft2020, draft7]
-        : [draft7, draft2020];
+    const { draft7: d7, draft2020: d2020 } = ensureAjv();
+    const preferred = typeof schema.$schema === 'string' && schema.$schema.includes('2020-12') ? [d2020, d7] : [d7, d2020];
     let lastError;
     for (const ajv of preferred) {
         try {

package/dist/ui/batch.js

@@ -38,6 +38,8 @@ const callToBatch = new Map();
 const groupChildIndexByCall = new Map();
 /** 展开时完整输出的最大行数;超出截断,避免巨型输出撑爆 viewport。 */
 const MAX_EXPAND_LINES = 200;
+const MAX_LIVE_OUTPUT_CHARS = 256 * 1024;
+const LIVE_OUTPUT_REFRESH_MS = 80;
 /** 自洽行允许的最大显示宽(= 终端 cols)。buffer 行超 cols 会被终端 auto-wrap,
  *  物理行与缓冲行失配 → repaintViewport 的 CUP 寻址全错(屏幕错乱)。 */
 let maxCols = 200;
@@ -66,6 +68,12 @@ export function isMutationToolName(name) {
 }
 /** 通知 buffer 整体清空(clearContent / exitAltScreen / 新一轮 turn)——本模块状态同步归零。 */
 export function reset() {
+    for (const record of batches.values()) {
+        for (const entry of record.entries) {
+            if (entry.liveRefreshTimer)
+                clearTimeout(entry.liveRefreshTimer);
+        }
+    }
     batches.clear();
     absLineToBatchId.clear();
     absLineToEntry.clear();
@@ -154,7 +162,61 @@ export function isBatchComplete(id) {
 /** 记一条工具结果(diff 块或单行 preview);agent 在 onToolResult 时调,匹配最后一条未填的 entry。
  *  fullOutput:工具原始完整输出(纯文本),展开时显示;mutation 工具的 diff 块已自含无需传。
  *  callId:组容器批用,直接把结果填到对应 entry(避免多个 sub-agent 同名时反向匹配错位)。 */
-export function recordResult(id, name, resultSummary, diffBlock, fullOutput, failed = false, callId) {
+function refreshEntryDetails(b, entryIndex, layout) {
+    if (!expandedBatches.has(b.id) || !b.expandedEntries.has(entryIndex))
+        return;
+    const headerIdx = [...absLineToEntry].find(([, target]) => target.batchId === b.id && target.entryIndex === entryIndex)?.[0];
+    if (headerIdx == null)
+        return;
+    const entry = b.entries[entryIndex];
+    const oldCount = entry.renderedDetailCount ?? 0;
+    const lines = buildEntryDetailLines(entry, entryDetailIndent(b.indent ?? ''));
+    const replacement = lines.slice(0, MAX_EXPAND_LINES);
+    if (oldCount > 0)
+        layout.contentDeleteFrom(headerIdx + 1, oldCount);
+    if (replacement.length > 0)
+        layout.contentInsertAfter(headerIdx, replacement, false);
+    entry.renderedDetailCount = replacement.length;
+    entry.renderedDigest = entryLineDigest(entry);
+    layout.contentReplaceLine(headerIdx, buildEntryLine(b, entryIndex, b.indent ?? ''));
+}
+export function recordOutput(callId, chunk, layout) {
+    const batchId = callToBatch.get(callId);
+    const b = batchId ? batches.get(batchId) : undefined;
+    const entryIndex = groupChildIndexByCall.get(callId);
+    if (!b || entryIndex == null || b.entries[entryIndex]?.name !== 'run_command')
+        return;
+    const entry = b.entries[entryIndex];
+    entry.liveOutput = `${entry.liveOutput ?? ''}${chunk}`;
+    if (entry.liveOutput.length > MAX_LIVE_OUTPUT_CHARS) {
+        entry.liveOutput = entry.liveOutput.slice(-MAX_LIVE_OUTPUT_CHARS);
+    }
+    if (!expandedBatches.has(b.id))
+        return;
+    if (!b.expandedEntries.has(entryIndex)) {
+        const headerIdx = [...absLineToEntry].find(([, target]) => target.batchId === b.id && target.entryIndex === entryIndex)?.[0];
+        if (headerIdx != null) {
+            entry.renderedDigest = entryLineDigest(entry);
+            layout.contentReplaceLine(headerIdx, buildEntryLine(b, entryIndex, b.indent ?? ''));
+        }
+        return;
+    }
+    if (entry.liveRefreshTimer)
+        return;
+    const refresh = () => {
+        entry.liveRefreshTimer = undefined;
+        entry.liveRefreshAt = Date.now();
+        refreshEntryDetails(b, entryIndex, layout);
+    };
+    const wait = Math.max(0, LIVE_OUTPUT_REFRESH_MS - (Date.now() - (entry.liveRefreshAt ?? 0)));
+    if (wait === 0)
+        refresh();
+    else {
+        entry.liveRefreshTimer = setTimeout(refresh, wait);
+        entry.liveRefreshTimer.unref();
+    }
+}
+export function recordResult(id, name, resultSummary, diffBlock, fullOutput, failed = false, callId, layout) {
     const b = batches.get(id);
     if (!b || b.entries.length === 0)
         return;
@@ -168,8 +230,14 @@ export function recordResult(id, name, resultSummary, diffBlock, fullOutput, fai
             e.fullOutput = fullOutput;
             e.failed = failed;
             e.done = true;
+            if (e.liveRefreshTimer)
+                clearTimeout(e.liveRefreshTimer);
+            e.liveRefreshTimer = undefined;
+            e.liveOutput = undefined;
             if (b.entries.every(isEntryDone))
                 b.finishedAt = Date.now();
+            if (layout)
+                refreshEntryDetails(b, idx, layout);
             return;
         }
     }
@@ -181,8 +249,14 @@ export function recordResult(id, name, resultSummary, diffBlock, fullOutput, fai
             b.entries[i].fullOutput = fullOutput;
             b.entries[i].failed = failed;
             b.entries[i].done = true;
+            if (b.entries[i].liveRefreshTimer)
+                clearTimeout(b.entries[i].liveRefreshTimer);
+            b.entries[i].liveRefreshTimer = undefined;
+            b.entries[i].liveOutput = undefined;
             if (b.entries.every(isEntryDone))
                 b.finishedAt = Date.now();
+            if (layout)
+                refreshEntryDetails(b, i, layout);
             return;
         }
     }
@@ -194,8 +268,14 @@ export function recordResult(id, name, resultSummary, diffBlock, fullOutput, fai
         last.fullOutput = fullOutput;
         last.failed = failed;
         last.done = true;
+        if (last.liveRefreshTimer)
+            clearTimeout(last.liveRefreshTimer);
+        last.liveRefreshTimer = undefined;
+        last.liveOutput = undefined;
         if (b.entries.every(isEntryDone))
             b.finishedAt = Date.now();
+        if (layout)
+            refreshEntryDetails(b, b.entries.length - 1, layout);
     }
 }
 // ── 摘要行文本生成 ──
@@ -465,11 +545,10 @@ function buildEntryDetailLines(e, indent = DETAIL_INDENT) {
             lines.push(sanitizeRow(prefixed));
         }
     }
-    else if (e.fullOutput) {
-        // 完整工具输出(纯文本):按行展开,每行缩进 + dim 样式;长输出截断到 MAX_EXPAND_LINES 行。
-        // 每行经 sanitizeRow 钳宽:fullOutput 可能含 grep 扫二进制(db/压缩文件)得到的
-        // 超长行 + 控制字符,不钳会让终端 auto-wrap 打乱屏位。
-        const rawLines = e.fullOutput.split('\n');
+    else if (e.liveOutput || e.fullOutput) {
+        // 实时输出优先展示;结束后由 recordResult 替换成最终有界工具结果。
+        // 每行 sanitizeRow 会清除控制字符并钳宽,避免 ANSI/终端控制序列污染 TUI。
+        const rawLines = (e.liveOutput || e.fullOutput || '').split(/\r\n|\n|\r/);
         const truncated = rawLines.length > MAX_EXPAND_LINES;
         const displayLines = truncated ? rawLines.slice(0, MAX_EXPAND_LINES) : rawLines;
         for (const line of displayLines) {
@@ -493,7 +572,7 @@ function buildEntryDetailLines(e, indent = DETAIL_INDENT) {
  * 只取有无不取内容:完整输出可能上万字符,拼进指纹是浪费,且其内容不影响 entry 行渲染。
  */
 function entryLineDigest(e) {
-    return `${e.resultSummary}\u0001${e.diffBlock ? '1' : '0'}\u0001${e.fullOutput ? '1' : '0'}\u0001${e.failed ? '1' : '0'}`;
+    return `${e.resultSummary}\u0001${e.diffBlock ? '1' : '0'}\u0001${e.fullOutput || e.liveOutput ? '1' : '0'}\u0001${e.failed ? '1' : '0'}`;
 }
 /**
  * 第二层展开三角:折叠 ▸ / 展开 ▾。替代原先的 ├─ / └─。
@@ -537,7 +616,7 @@ const DETAIL_RESULT_MARK = '· ';
 /** entry 是否有可展开的详情行。须与 buildEntryDetailLines 的分支一致,
  *  否则会画出点了没反应的三角(toggleEntry 对空 details 直接 return)。 */
 function hasEntryDetail(e) {
-    return Boolean(e.diffBlock || e.fullOutput || e.resultSummary);
+    return Boolean(e.diffBlock || e.fullOutput || e.liveOutput || e.resultSummary);
 }
 /** entry 行的展开三角(含尾随空格与配色)。折叠 dim、展开 accent,一眼区分当前态。 */
 function entryCaret(e, expanded) {
@@ -938,9 +1017,11 @@ export function toggleEntry(batchId, entryIndex, layout) {
     layout.contentReplaceLine(headerIdx, buildEntryLine(b, entryIndex, b.indent ?? ''));
     if (wasExpanded) {
         layout.contentDeleteFrom(headerIdx + 1, details.length);
+        b.entries[entryIndex].renderedDetailCount = 0;
     }
     else {
         layout.contentInsertAfter(headerIdx, details);
+        b.entries[entryIndex].renderedDetailCount = Math.min(details.length, MAX_EXPAND_LINES);
     }
 }
 /**

package/dist/ui/cli-highlight-lazy.js

@@ -0,0 +1,27 @@
+// cli-highlight(highlight.js)懒加载:它含近四百个语言文件,冷态首次加载是百毫秒级,
+// 而首帧 banner 不含代码块、不需要高亮。渲染函数是同步的,故用 createRequire 同步懒取,
+// 配合 src/startup/prewarm 在首帧后后台预热:用户输入含代码的首个响应到达前,包通常已在内存。
+// 预热未及时完成时,首次代码块渲染会承担一次(热缓存下很短的)加载成本,功能不变。
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+let mod = null;
+let requirePromise = null;
+/** 同步取 cli-highlight(渲染路径用);首次调用才真正加载。 */
+export function getCliHighlight() {
+    if (!mod) {
+        mod = require('cli-highlight');
+    }
+    return mod;
+}
+/** 后台预热:动态 import 与同步 require 共享模块缓存,预热后 getCliHighlight 零成本。 */
+export function prewarmCliHighlight() {
+    if (!requirePromise) {
+        requirePromise = import('cli-highlight')
+            .then((m) => {
+            mod = m;
+            return m;
+        })
+            .catch(() => undefined);
+    }
+    return requirePromise;
+}

package/dist/ui/diff.js

@@ -1,6 +1,8 @@
-import { highlight, plain } from 'cli-highlight';
+import { getCliHighlight } from './cli-highlight-lazy.js';
 import { ui } from './theme.js';
 import { charWidth, displayWidth } from './render.js';
+/** cli-highlight 的 plain 主题就是恒等函数(已实测),这里本地等价实现,避免顶层加载整包。 */
+const plain = (codePart) => codePart;
 const MAX_FULL_DIFF_LINES = 800; // 任一边超此行数则跳过全量 LCS(避免大文件 O(n·m) 高开销)
 const MAX_BODY_LINES = 24; // 正文最多展示行数(超出尾注「还有 N 行未显示」)
 const MAX_LINE_DISPLAY = 120; // 单行截断显示宽度(CJK / 全角按 2 计)
@@ -115,7 +117,7 @@ function highlightLine(text, lang) {
     if (!lang || text === '')
         return text;
     try {
-        return highlight(text, { language: lang, theme: THEME });
+        return getCliHighlight().highlight(text, { language: lang, theme: THEME });
     }
     catch {
         return text; // 语言未注册 / 解析失败:退化为纯文本

package/dist/ui/markdown.js

@@ -11,7 +11,7 @@
 // 硬约束:每行 ansiDisplayWidth ≤ cols(layout.repaintViewport 直出行,超宽会让终端 auto-wrap
 // 错位;若上层 <Text wrap=truncate> 补 … U+2026 在中文终端算 2 宽会顶屏)。所有路径软折行 +
 // clipAnsiLine 兜底,绝不溢出。颜色一律嵌入式 ANSI(ui.*)写进字符串。
-import { highlight, supportsLanguage } from 'cli-highlight';
+import { getCliHighlight } from './cli-highlight-lazy.js';
 import { ui, getThemeVersion } from './theme.js';
 import { charWidth, displayWidth, ansiDisplayWidth, stripAnsi } from './render.js';
 const RESET = '\x1b[0m';
@@ -296,6 +296,7 @@ function highlightCodeBlock(code, lang) {
     if (!lang)
         return code;
     try {
+        const { highlight, supportsLanguage } = getCliHighlight();
         if (supportsLanguage(lang)) {
             return highlight(code, { language: lang, ignoreIllegals: true });
         }

package/dist/ui/prompt-internal/editor.js

@@ -725,6 +725,12 @@ export async function promptWithSlashMenu(opts) {
                     selected = (selected - 1 + filtered.length) % filtered.length;
                     redraw();
                 }
+                else if (buildDisplay().lines.length <= 1) {
+                    // 单行输入 + 菜单关闭:裸 ↑/↓ 视作鼠标滚轮。Trae/VSCode 内置终端(xterm)在鼠标
+                    // 报表未被接收时会把滚轮降级成 ↑/↓ 方向键;这里转成内容区滚动,与运行态滚轮一致,
+                    // 否则空/单行输入框里滚轮"毫无反应"。多行输入时仍跳到全文首/尾(保留编辑语义)。
+                    layout.scrollWheel(1);
+                }
                 else {
                     // ↑ 始终跳到全文最前(含跨只读粘贴块,落到首个可编辑段开头)
                     const p = firstEditableStart();
@@ -738,6 +744,9 @@ export async function promptWithSlashMenu(opts) {
                     selected = (selected + 1) % filtered.length;
                     redraw();
                 }
+                else if (buildDisplay().lines.length <= 1) {
+                    layout.scrollWheel(-1);
+                }
                 else {
                     // ↓ 始终跳到全文最后(含跨只读粘贴块,落到末个可编辑段末尾)
                     const p = lastEditableEnd();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocode-ai",
-  "version": "1.7.8",
+  "version": "1.7.10",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 27 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {