mocode-ai 1.7.7 → 1.7.9

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/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

@@ -161,6 +161,7 @@ const zhCN = {
     'intervention.emptyInput': '自动返回空输入',
     'intervention.nonInteractive': '[介入] {title}（非交互环境，{kind}）',
     'repl.idle': '空闲',
+    'repl.queuedCommandHeld': '排队的是斜杠命令，已填入输入框，请确认后手动发送',
     'repl.loadFailed': '（加载失败）',
     'repl.resumeAnchor': '已恢复会话 {id} · {count} 条消息 · 当前模型 {model}（/model switch 可切换）',
     'repl.noSessions': '（没有已保存的会话）',
@@ -208,6 +209,8 @@ const zhCN = {
     'banner.disabled': '关闭',
     'status.modeSwitch': 'Shift+Tab 切换',
     'status.history': '历史 ↑{count}（PgDn 回底）',
+    'status.queued': '排队 ·',
+    'status.queuePlanTag': '（Plan）',
     'status.measured': '实测',
     'status.estimated': '估算',
     'status.messages': '{count} 条消息',
@@ -548,6 +551,7 @@ const en = {
     'intervention.emptyInput': 'automatically returned empty input',
     'intervention.nonInteractive': '[intervention] {title} (non-interactive; {kind})',
     'repl.idle': 'Idle',
+    '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.noSessions': '(no saved sessions)',
@@ -595,6 +599,8 @@ const en = {
     'banner.disabled': 'Disabled',
     'status.modeSwitch': 'Shift+Tab Switch',
     'status.history': 'History ↑{count} (PgDn to bottom)',
+    'status.queued': 'queued ·',
+    'status.queuePlanTag': ' (Plan)',
     'status.measured': 'measured',
     'status.estimated': 'estimated',
     'status.messages': '{count} messages',

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/running-input.js

@@ -4,6 +4,7 @@ import * as layout from '../ui/layout.js';
 import * as mouse from '../ui/mouse.js';
 import { promptComposer } from '../ui/composer.js';
 import { appendCurrentSessionRuntimeEvent } from '../session/index.js';
+import { getAgentMode } from '../agent/mode.js';
 const emitter = stdin;
 // ── 运行态交互(typeahead 输入 + 滚动回看 + Ctrl+C 中断 + Ctrl+G 输入面板)──
 // 只在 await runAgent() 期间挂载;/resume /rollback /compact 等走 askLine(cooked readline)的分支不挂(避免抢 stdin)。
@@ -12,6 +13,12 @@ let runningCursor = 0; // 缓冲内光标字符索引(0..len);运行态支持任
 let runningPlaceholder = '';
 let currentAbort = null;
 let listening = false; // onRunningKey 是否处于挂载期(start → stop 之间)
+/**
+ * 运行态「预加载/排队」消息:运行中打字后按 Enter 入队(单条,再次入队即替换),
+ * 当前 agent 结束后由主循环自动发送,无需用户在 INPUT 态再按一次 Enter。
+ * null = 没有排队。mode 快照入队那一刻的模式,自动执行时沿用(用户选「沿用当前模式」)。
+ */
+let queuedTurn = null;
 /** 运行态打开的输入面板(Ctrl+G);非 null = 面板仍开着。主循环进 INPUT 态前须等它关闭,否则两个 keypress 监听抢键。 */
 let composerPending = null;
 /** 获取运行中输入缓冲(agent 结束后预填下一轮 INPUT 态)。 */
@@ -23,6 +30,20 @@ export function clearRunningInput() {
     runningInput = '';
     runningCursor = 0;
 }
+/** 当前排队消息(运行中按 Enter 预加载);无则 null。主循环在 agent 结束后取走并自动发送。 */
+export function getQueuedTurn() {
+    return queuedTurn;
+}
+/** 取走并清空排队消息(消费一次)。 */
+export function consumeQueuedTurn() {
+    const queued = queuedTurn;
+    queuedTurn = null;
+    return queued;
+}
+/** 取消排队(运行态 Esc 在已有排队时优先取消排队,而不是只清 typeahead)。 */
+export function clearQueuedTurn() {
+    queuedTurn = null;
+}
 /**
  * 等待运行态打开的输入面板关闭(无则立即返回)。
  * agent 可能在面板打开期间结束:主循环在进入 INPUT 态(promptWithSlashMenu 挂自己的 keypress)前必须 await,
@@ -99,6 +120,11 @@ function onRunningKey(_str, key) {
             paint();
         }
         else if (currentAbort && !currentAbort.signal.aborted) {
+            // 中断当前任务 = 明确要停下,排队的下一跳也一并取消,避免 agent 一停又自动发新需求。
+            if (queuedTurn) {
+                queuedTurn = null;
+                layout.setQueuedTurn(undefined); // 只撤状态行 chip,不在内容区写提示
+            }
             appendCurrentSessionRuntimeEvent('abort', { phase: 'requested', source: 'keyboard' });
             currentAbort.abort();
         }
@@ -153,13 +179,32 @@ function onRunningKey(_str, key) {
         return;
     }
     if (key.name === 'escape') {
-        runningInput = '';
-        runningCursor = 0;
-        paint();
+        // 有排队消息时 Esc 只取消排队,不清空 typeahead 草稿(避免误删正在打的字);
+        // 无排队时维持原语义:清空 typeahead。
+        if (queuedTurn) {
+            queuedTurn = null;
+            layout.setQueuedTurn(undefined); // 只撤状态行 chip,不在内容区写提示
+            paint();
+        }
+        else {
+            runningInput = '';
+            runningCursor = 0;
+            paint();
+        }
         return;
     }
-    // Enter / Ctrl+J:运行中 no-op(单行 typeahead;agent 结束后预填,用户在 INPUT 态按 Enter 提交)
+    // Enter / Ctrl+J:把 typeahead 内容入队(单条,再次入队即替换)。当前 agent 结束后
+    // 主循环经 consumeQueuedTurn 自动发送,无需在 INPUT 态再按一次 Enter。空内容 no-op。
     if (key.name === 'return' || key.name === 'enter' || (key.ctrl && key.name === 'j')) {
+        const text = runningInput.trim();
+        if (!text)
+            return;
+        queuedTurn = { text: runningInput, mode: getAgentMode() }; // 单条:再次入队即替换
+        runningInput = '';
+        runningCursor = 0;
+        // 入队只反映在状态行 `● 状态` 右侧的常驻 chip(含预览/模式),不往 agent 输出区写行。
+        layout.setQueuedTurn(queuedTurn.text, queuedTurn.mode);
+        paint(); // 清空底部 typeahead 回显
         return;
     }
     // 可打印字符(>= 空格,非 ctrl/meta)→ 光标处插入 + 非 dim 回显(与空闲态一致)

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';
@@ -32,7 +33,7 @@ import { PROMPT, buildSlashCommands, LLM_ERROR_HINT_KEYS, isCommandShape, sugges
 import { dispatchCommand } from './commands/registry.js';
 import { settlePlanStatus, refreshStatusBase, runningStateFor } from './status-bar.js';
 import { messageAttachments, formatUserMessage, textOf, queryHistoryFromMessages, renderHistory, } from './message-format.js';
-import { startRunningListener, stopRunningListener, getRunningInput, clearRunningInput, waitForRunningComposer, } from './running-input.js';
+import { startRunningListener, stopRunningListener, getRunningInput, clearRunningInput, waitForRunningComposer, consumeQueuedTurn, } from './running-input.js';
 const emitter = stdin;
 // ── 运行态交互已移到 ./running-input.ts ──
 // ── pendingPrefill / pendingTimer / pendingAttachments 保留在此(awaitPendingRecall / echoInput 用)
@@ -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) => {
@@ -676,7 +681,19 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
         // 运行态 Ctrl+G 打开的输入面板可能在 agent 结束时仍开着:等它关闭再进 INPUT 态,
         // 否则面板与 promptWithSlashMenu 两个 keypress 监听抢键;面板确认的内容随后经 getRunningInput 预填。
         await waitForRunningComposer();
-        // INPUT 态:画底栏输入框 + 状态行,光标入输入框
+        // 消息预加载:上一轮运行中用户按 Enter 排了队(consumeQueuedTurn),agent 一结束就自动发送,
+        // 跳过 INPUT 态输入框与撤回窗口(入队那一刻即已确认)。非空才自动发;排队时正在打的 typeahead
+        // 草稿经 pendingPrefill 保住,留到下一轮输入框。
+        const queued = consumeQueuedTurn();
+        const autoSend = !!queued && queued.text.trim().length > 0;
+        if (queued)
+            layout.setQueuedTurn(undefined); // chip 已被消费(或为空丢弃),从状态行撤下
+        if (autoSend && queued) {
+            // 排队时仍在输入框草稿里的字(typeahead)不能丢:回填为下一轮预填。
+            if (getRunningInput().trim())
+                pendingPrefill = [getRunningInput()];
+            clearRunningInput();
+        }
         refreshStatusBase(history);
         // 后台反思若已完成(上轮 fire-and-forget),在安全点 flush 一行 dim 摘要:
         // 不在 RUNNING 态写——防与正在跑的 agent 争屏(contentWrite / 状态行)。
@@ -685,39 +702,54 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             layout.contentWrite(`  ${ui.gray}↳ ${formatReflectResult(reflectRes)}${ui.reset}\n`);
             clearLastReflectResult();
         }
-        // 所有斜杠命令和 Agent 轮次共用同一个输出→输入边界，避免某条命令漏写第二个 \n
-        // 后下一条 ❯ 气泡紧贴确认文案；已有多余空行也会收敛为恰好一行。
-        if (hasSubmittedInput)
-            layout.normalizeInputBoundary();
-        layout.enterInputMode(t('repl.idle'));
-        let input = null;
-        try {
-            input = await promptWithSlashMenu({
-                prompt: PROMPT,
-                commands: buildSlashCommands(),
-                onCycleMode: cycleMode,
-                // Ctrl+R / Ctrl+P 历史搜索候选源:惰性工厂——当前会话内存 queryHistory + 最近落盘会话,
-                // 聚合要读盘,只有面板真正打开(Ctrl+R/P)才求值,平常轮次零开销
-                history: () => collectQueryHistory(queryHistory).map((e) => e.text),
-                // /rollback 预填优先;否则上一轮运行中 typeahead 打的字 → 预填进输入框,用户可改可发
-                ...(pendingPrefill
-                    ? { initialLines: pendingPrefill }
-                    : getRunningInput()
-                        ? { initialLines: [getRunningInput()] }
-                        : {}),
-            });
+        let input;
+        let queuedMode = null;
+        if (autoSend && queued) {
+            input = queued.text.split('\n');
+            queuedMode = queued.mode;
         }
-        catch {
-            break; // Ctrl+C(SIGINT)/ 异常 → 退出
+        else {
+            // 所有斜杠命令和 Agent 轮次共用同一个输出→输入边界，避免某条命令漏写第二个 \n
+            // 后下一条 ❯ 气泡紧贴确认文案；已有多余空行也会收敛为恰好一行。
+            if (hasSubmittedInput)
+                layout.normalizeInputBoundary();
+            layout.enterInputMode(t('repl.idle'));
+            try {
+                const picked = await promptWithSlashMenu({
+                    prompt: PROMPT,
+                    commands: buildSlashCommands(),
+                    onCycleMode: cycleMode,
+                    // Ctrl+R / Ctrl+P 历史搜索候选源:惰性工厂——当前会话内存 queryHistory + 最近落盘会话,
+                    // 聚合要读盘,只有面板真正打开(Ctrl+R/P)才求值,平常轮次零开销
+                    history: () => collectQueryHistory(queryHistory).map((e) => e.text),
+                    // /rollback 预填优先;否则上一轮运行中 typeahead 打的字 → 预填进输入框,用户可改可发
+                    ...(pendingPrefill
+                        ? { initialLines: pendingPrefill }
+                        : getRunningInput()
+                            ? { initialLines: [getRunningInput()] }
+                            : {}),
+                });
+                if (picked === null)
+                    break; // 空 prompt Ctrl+D
+                input = picked;
+            }
+            catch {
+                break; // Ctrl+C(SIGINT)/ 异常 → 退出
+            }
+            pendingPrefill = null; // 预填已消费,清空
+            clearRunningInput(); // 预填已消费,清空(下轮运行态从空开始)
         }
-        pendingPrefill = null; // 预填已消费,清空
-        clearRunningInput(); // 预填已消费,清空(下轮运行态从空开始)
-        if (input === null)
-            break; // 空 prompt Ctrl+D
         let joined = input.join('\n');
         const line = joined.trim();
         if (!line)
             continue;
+        // 排队预加载只对「发给 agent 的需求」自动执行;斜杠命令不静默自动跑
+        // (否则排队 /clear、/exit、/rollback 会在用户没看着时触发),改为填回输入框由用户显式确认。
+        if (autoSend && isCommandShape(line.split(/\s+/)[0] ?? '')) {
+            pendingPrefill = input;
+            layout.contentWrite(`${ui.dim}  ↳ ${t('repl.queuedCommandHeld')}${ui.reset}\n`);
+            continue;
+        }
         hasSubmittedInput = true;
         if (line === '/exit' || line === '/quit')
             break;
@@ -830,7 +862,8 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             continue; // 与其他命令一致:回 INPUT 态由循环顶部的 normalizeInputBoundary + enterInputMode 负责
         }
         const bubbleRows = input.length + 2 + pendingAttachments.length; // N 行 message + 2 行尾随空(含 \n\n 留下的 open current 行) + 每附件 1 行
-        const shouldCommit = await awaitPendingRecall(input);
+        // 排队消息入队时即已确认 → 跳过 500ms 撤回窗口,直接发送。
+        const shouldCommit = autoSend || (await awaitPendingRecall(input));
         if (!shouldCommit) {
             // 撤回:气泡从内容区擦掉 + 行放回输入框(下轮 promptWithSlashMenu 经 initialLines 消费)+ 切回 INPUT 视觉。
             // pendingAttachments **保留** —— 撤回的是输入文本不是意图,再发时随消息一起带走
@@ -842,7 +875,8 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
         }
         // 只记录已过撤回窗口的真实用户 query；slash 命令和合成执行轮不会走到这里。
         queryHistory.push(joined);
-        const initialPlan = getAgentMode() === 'plan'; // 轮首模式(在 runTurn 之前读)
+        // 排队消息沿用「入队那一刻」的模式(用户在运行中预加载时选的模式);普通消息读当前模式。
+        const initialPlan = (queuedMode ?? getAgentMode()) === 'plan';
         const turn = await runTurn(joined, initialPlan, placeholder);
         if (turn.routedCancel) {
             // 路由阶段 Ctrl+C 撤回:与 500ms 撤回窗口同语义——气泡擦掉 + 行回填输入框

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/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/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/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/layout-internal/core.js

@@ -30,7 +30,7 @@ import { paintInput, repaint } from './input-paint.js';
 import { WHEEL_LINES, screenRowToAbsLine, repaintViewport, scrollBy, scrollWheel, resetScroll, lockScrollToBottom, } from './scroll.js';
 import { contentWrite, contentInsertAfter, contentDeleteFrom, contentReplaceLine, reflowContentForResize, flushMdSegment, } from './content-write.js';
 export { isTuiActive, getGeo, setRegion, contentMode, isStreamingPaused } from './screen.js';
-export { drawStatusBar, setStatus, stopTurnTimer, startTurnTimerIfRunning, paintLiveAtCursor, clearLiveAtCursor, setLiveUsage, setStatusBase, } from './statusbar.js';
+export { drawStatusBar, setStatus, stopTurnTimer, startTurnTimerIfRunning, paintLiveAtCursor, clearLiveAtCursor, setLiveUsage, setQueuedTurn, setStatusBase, } from './statusbar.js';
 export { paintInput, paintRunningInput, repaint } from './input-paint.js';
 export { isScrolled, repaintViewport, repaintContentLine, scrollBy, scrollWheel, resetScroll, lockScrollToBottom, unlockScroll, isScrollLocked, } from './scroll.js';
 export { contentWrite, writeBanner, rewriteBanner, bannerHeight, contentWriteMd, contentWriteMdOnce, clearContent, rewindContent, writeWelcomeBlock, dismissWelcomeBlock, contentInsertAfter, contentDeleteFrom, totalRows, isLastContentRowBlank, normalizeMutationBoundary, normalizeInputBoundary, contentReplaceLine, notifyContentReset, } from './content-write.js';

package/dist/ui/layout-internal/state.js

@@ -61,6 +61,10 @@ export const state = {
      *  composeModelLine 在 RUNNING 态把它画成 chip 放 context 进度条左侧;
      *  不主动触发重画——RUNNING 态 turnTimer 80ms 心跳重画自然取最新值。 */
     liveUsage: undefined,
+    /** 运行态已排队、当前任务结束后自动发送的下一条消息(纯文本摘要,无=undefined)。 */
+    queuedText: undefined,
+    /** 排队消息入队时的模式,用于在 chip 上标注 Plan/Auto。 */
+    queuedMode: undefined,
     statusText: '',
     spinnerFrame: undefined,
     turnStart: null, // RUNNING 态起点(Date.now());INPUT 态为 null。composeStatus 据此拼走时。

package/dist/ui/layout-internal/statusbar.js

@@ -64,6 +64,12 @@ export function composeSpinnerLine(status, cols) {
         lead = `${ui.accent}●${ui.reset} ${ui.dim}${status.status}${ui.reset}`;
         leadW = 1 + 1 + displayWidth(status.status);
     }
+    // 排队下一跳:紧跟「● 状态(+走时)」右侧显示,运行中持续可见,当前任务结束即自动发送。
+    const queued = queuedChip();
+    if (queued) {
+        lead += `  ${queued.str}`;
+        leadW += 2 + queued.w;
+    }
     // ── 右段:仅滚动回看时显历史指示 ──
     let tail = '';
     let tailW = 0;
@@ -371,6 +377,28 @@ export function clearLiveAtCursor() {
 export function setLiveUsage(u) {
     state.liveUsage = u;
 }
+/**
+ * 设置/清除运行态已排队的下一条消息 chip(显示在 `● 状态` 右侧)。
+ * 立即重画一次保证入队瞬间可见;之后 RUNNING 态 80ms 心跳会自然带上。
+ */
+export function setQueuedTurn(text, mode) {
+    state.queuedText = text;
+    state.queuedMode = mode;
+    drawStatusBar();
+}
+/** 排队 chip:▸ 排队: <首行…>（Plan)。只拼左段,宽度另计(不含 ANSI)。 */
+function queuedChip() {
+    const raw = state.queuedText;
+    if (!raw)
+        return null;
+    const firstLine = raw.split('\n')[0] ?? '';
+    const preview = truncateDisplay(firstLine.trim(), 32);
+    const modeTag = state.queuedMode === 'plan' ? t('status.queuePlanTag') : '';
+    const label = t('status.queued');
+    const plain = `${label} ${preview}${modeTag}`;
+    const str = `${ui.yellow}▸ ${plain}${ui.reset}`;
+    return { str, w: 2 + displayWidth(plain) };
+}
 /** 更新状态行基线(模型 / context / cwd / 模式标识 / 活跃 plan chip / 本轮 token chip)。repl 在轮次边界与切模式时调。 */
 export function setStatusBase(b) {
     state.base = b;

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.7",
+  "version": "1.7.9",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 27 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {