mocode-ai 1.6.9 → 1.7.0

package/dist/repl/commands/diff.js

@@ -0,0 +1,189 @@
+/**
+ * 工作区命令组:/diff
+ *
+ * `/diff` = 最近一轮 agent turn 的快照(before) vs 工作区当前内容(after),
+ * 逐文件渲染 unified diff 到内容区;`/diff <N>` 选第 N 轮(1-based,与 /rollback
+ * 轮次口径一致);`/diff all` = 全部轮次的累计改动(最早的 before vs 现在)。
+ *
+ * 数据源:rollback 快照(每轮文件修改前捕获,不依赖 git)——好处是「没有 git 的目录」
+ * 也能看 agent 改了什么,且口径与 /rollback 完全一致(所见即可撤)。
+ * 限制:run_command 等不透明工具的工作区扫描快照在文件超 CAPTURE_FILE_LIMIT 时只留
+ * 指纹(contentUnavailable),这些文件显示「快照不可用」而非 diff。
+ *
+ * diff 算法:前后缀等行消除 + 单 hunk 输出,不引依赖(与 agent/index.ts lineDelta
+ * 同思路)。文件较少、行数中等的会话内 diff 足够快。
+ */
+import { readFileSync } from 'node:fs';
+import * as layout from '../../ui/layout.js';
+import { ui } from '../../ui/theme.js';
+import { getActiveRollbackStore } from '../../rollback/index.js';
+import { unhandled, next } from './types.js';
+const MAX_DIFF_LINES = 400; // 单文件输出上限:防止把万行生成文件刷满内容区
+const MAX_FILES = 60; // 单次命令最多渲染文件数(超出提示收窄)
+const CONTEXT = 3; // hunk 上下文行数
+/** 快照 before 内容 → 文本(null → 无内容/不可用;base64 解码失败按 null)。 */
+function snapshotText(snapshot) {
+    if (snapshot.before === null)
+        return null;
+    if (snapshot.encoding === 'base64') {
+        try {
+            return Buffer.from(snapshot.before, 'base64').toString('utf8');
+        }
+        catch {
+            return null;
+        }
+    }
+    return snapshot.before; // v1 快照:UTF-8 原文
+}
+/** 是否可当文本 diff:kind=file 且非 contentUnavailable(目录/软链/超预算跳过)。 */
+function diffable(snapshot) {
+    return snapshot.kind === 'file' && snapshot.contentUnavailable !== true;
+}
+/** 按行求公共前缀/后缀长度(与 lineDelta 同思路,但这里要保留行号做 hunk)。 */
+function hunkBoundaries(before, after) {
+    let head = 0;
+    while (head < before.length && head < after.length && before[head] === after[head])
+        head++;
+    let tail = 0;
+    while (tail < before.length - head &&
+        tail < after.length - head &&
+        before[before.length - 1 - tail] === after[after.length - 1 - tail])
+        tail++;
+    return { head, tail };
+}
+/**
+ * 行级 unified diff 单文件段(纯文本,颜色渲染层加)。
+ * 策略:前后缀等行消除后,中间区整段输出为「先删后加」的单 hunk。对单文件一次
+ * 编辑(agent 编辑的绝大多数形态:改一处/几处)等价于标准 diff;全文重写时输出
+ * 体积与正确 diff 同量级,只是 hunk 划分更粗。无变化返回 ''(指纹差异但文本相同)。
+ */
+export function unifiedFileDiff(pathRel, beforeText, afterText) {
+    const before = beforeText === null ? [] : beforeText.split('\n');
+    const after = afterText === null ? [] : afterText.split('\n');
+    const { head, tail } = hunkBoundaries(before, after);
+    const midBefore = before.slice(head, before.length - tail);
+    const midAfter = after.slice(head, after.length - tail);
+    if (midBefore.length === 0 && midAfter.length === 0)
+        return '';
+    const contextStart = Math.max(0, head - CONTEXT);
+    const tailStartBefore = before.length - tail;
+    const tailStartAfter = after.length - tail;
+    const contextEndBefore = Math.min(before.length, tailStartBefore + CONTEXT);
+    const contextEndAfter = Math.min(after.length, tailStartAfter + CONTEXT);
+    const lines = [];
+    lines.push(`--- a/${pathRel}`);
+    lines.push(`+++ b/${pathRel}`);
+    lines.push(`@@ -${contextStart + 1},${contextEndBefore - contextStart} +${contextStart + 1},${contextEndAfter - contextStart} @@`);
+    for (let i = contextStart; i < head; i++)
+        lines.push(` ${before[i]}`);
+    for (const line of midBefore)
+        lines.push(`-${line}`);
+    for (const line of midAfter)
+        lines.push(`+${line}`);
+    for (let i = tailStartBefore; i < contextEndBefore; i++)
+        lines.push(` ${before[i]}`);
+    return lines.join('\n');
+}
+/** 渲染一条 diff 行:加绿/删红/hunk 头青/上下文 dim。 */
+function writeDiffLine(line) {
+    if (line.startsWith('+'))
+        layout.contentWrite(`${ui.green}${line}${ui.reset}\n`);
+    else if (line.startsWith('-'))
+        layout.contentWrite(`${ui.red}${line}${ui.reset}\n`);
+    else if (line.startsWith('@@'))
+        layout.contentWrite(`${ui.cyan}${line}${ui.reset}\n`);
+    else
+        layout.contentWrite(`${ui.dim}${line}${ui.reset}\n`);
+}
+/** 读当前文件(不存在→null=「删除」;读失败→null)。 */
+function readCurrent(full) {
+    try {
+        return readFileSync(full, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+export const diffCommands = [
+    (ctx) => {
+        if (ctx.line !== '/diff' && !ctx.line.startsWith('/diff '))
+            return unhandled();
+        const arg = ctx.line === '/diff' ? '' : ctx.line.slice('/diff '.length).trim();
+        const store = getActiveRollbackStore();
+        const turns = store.listTurns();
+        if (turns.length === 0) {
+            layout.contentWrite(`${ui.dim}(本会话尚无文件改动记录——rollback 快照为空)${ui.reset}\n`);
+            return next();
+        }
+        // 轮次选择:/diff = 最近一轮;/diff N = 第 N 轮(1-based,与 /rollback 同口径);/diff all = 全部累计。
+        let label;
+        let minTurnIdExclusive; // 只统计 turnId > 此值的快照
+        if (arg === '') {
+            const last = turns[turns.length - 1];
+            minTurnIdExclusive = last.turnId - 1;
+            label = `第 ${turns.length} 轮(最近)`;
+        }
+        else if (arg === 'all') {
+            minTurnIdExclusive = 0;
+            label = '全部轮次累计';
+        }
+        else {
+            const n = Number(arg);
+            if (!Number.isInteger(n) || n < 1 || n > turns.length) {
+                layout.contentWrite(`${ui.yellow}(轮次无效:本会话共 ${turns.length} 轮,可用 /diff 1..${turns.length} 或 /diff all)${ui.reset}\n`);
+                return next();
+            }
+            minTurnIdExclusive = (turns[n - 1].turnId ?? 0) - 1;
+            label = `第 ${n} 轮`;
+        }
+        const byPath = new Map();
+        for (const snapshot of store.snapshotsSince(minTurnIdExclusive)) {
+            const existing = byPath.get(snapshot.path);
+            if (!existing || snapshot.turnId < existing.snapshot.turnId) {
+                byPath.set(snapshot.path, {
+                    snapshot,
+                    unavailable: (existing?.unavailable ?? false) || !diffable(snapshot),
+                });
+            }
+            else if (!diffable(snapshot)) {
+                existing.unavailable = true;
+            }
+        }
+        if (byPath.size === 0) {
+            layout.contentWrite(`${ui.dim}(${label}:无文件改动记录)${ui.reset}\n`);
+            return next();
+        }
+        const root = process.cwd();
+        const files = [...byPath.entries()].sort(([a], [b]) => a.localeCompare(b));
+        const shown = files.slice(0, MAX_FILES);
+        layout.contentWrite(`${ui.bold}${ui.accent}● ${label} 文件改动${ui.reset}  ${ui.dim}${shown.length}/${files.length} 文件${ui.reset}\n`);
+        for (const [rel, entry] of shown) {
+            if (entry.unavailable) {
+                layout.contentWrite(`${ui.yellow}  ⚠ ${rel}(快照不可用:超出捕获预算或非文本,无法展示 diff)${ui.reset}\n`);
+                continue;
+            }
+            const beforeText = snapshotText(entry.snapshot);
+            const afterText = readCurrent(`${root}${rel.startsWith('/') || rel.startsWith('\\') ? '' : '/'}${rel}`);
+            const diffText = unifiedFileDiff(rel, beforeText, afterText);
+            if (!diffText) {
+                // 快照记录了变更但当前内容已与 before 相同(后续轮改回/用户手改回):
+                // 仍列文件名,让用户知道它被动过,只是无净变化。
+                layout.contentWrite(`${ui.dim}  = ${rel}(已与轮前状态一致,无净变化)${ui.reset}\n`);
+                continue;
+            }
+            layout.contentWrite(`\n${ui.bold}${rel}${ui.reset}\n`);
+            const lines = diffText.split('\n');
+            const truncated = lines.length > MAX_DIFF_LINES;
+            for (const line of lines.slice(0, MAX_DIFF_LINES))
+                writeDiffLine(line);
+            if (truncated) {
+                layout.contentWrite(`${ui.dim}  …(diff 超过 ${MAX_DIFF_LINES} 行已截断,如需完整内容请直接 read_file)${ui.reset}\n`);
+            }
+        }
+        if (files.length > MAX_FILES) {
+            layout.contentWrite(`${ui.dim}  …(${files.length - MAX_FILES} 个文件未展示;改动面过大,建议 /diff <N> 收窄到单轮)${ui.reset}\n`);
+        }
+        layout.contentWrite('\n');
+        return next();
+    },
+];

package/dist/repl/commands/jobs.js

@@ -62,7 +62,7 @@ export const jobsCommands = [
         return next();
     },
     // /jobs kill [id前缀]
-    (ctx) => {
+    async (ctx) => {
         if (ctx.cmd !== '/jobs')
             return unhandled();
         const parts = ctx.line.split(/\s+/);
@@ -77,7 +77,7 @@ export const jobsCommands = [
             layout.contentWrite(`${ui.dim}任务 ${job.id} 已是 ${job.status}，无需 kill${ui.reset}\n`);
             return next();
         }
-        const ok = killBackgroundJob(job);
+        const ok = await killBackgroundJob(job);
         layout.contentWrite(ok
             ? `${ui.yellow}已 kill 任务 ${job.id}${ui.reset}\n`
             : `${ui.red}kill 失败（进程可能已退出；PID=${job.pid ?? '?'})${ui.reset}\n`);

package/dist/repl/commands/registry.js

@@ -17,6 +17,7 @@ import { effortCommands } from './effort.js';
 import { routerCommands } from './router.js';
 import { toolGroupCommands } from './tool-group.js';
 import { jobsCommands } from './jobs.js';
+import { diffCommands } from './diff.js';
 import { scheduleCommands } from './schedule.js';
 import { botsCommands } from './bots.js';
 /**
@@ -44,6 +45,7 @@ export const commandHandlers = [
     ...routerCommands,
     ...toolGroupCommands,
     ...jobsCommands,
+    ...diffCommands,
     ...scheduleCommands,
     ...botsCommands,
 ];

package/dist/repl/commands.js

@@ -29,6 +29,7 @@ export function buildSlashCommands() {
         { name: '/resume', desc: d('commands.sessionResume') },
         { name: '/sessions', desc: d('commands.sessionBrowse') },
         { name: '/rollback', desc: d('commands.sessionRollback') },
+        { name: '/diff', desc: '查看 agent 文件改动 diff(/diff [N]|all,快照 vs 工作区)' },
         { name: '/ssearch <关键词>', value: '/ssearch ', submit: false, desc: '跨会话搜索归档会话' },
         { name: '/jobs', desc: '后台任务列表(/jobs log/kill <id前缀>)' },
         { name: '/schedules', desc: '查看定时计划与调度守护状态' },

package/dist/repl/runtime.js

@@ -173,10 +173,17 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
     const runtime = defaultRuntime;
     await runtime.start();
     const runtimeContext = runtime.context;
-    // MCP 在工具表和 LLM schema 创建前连接；失败的单个 server 只给提示，不阻断 REPL。
-    const mcpReport = await initializeAllMcp();
-    registerToolsExtension('mcp', getMcpTools());
-    refreshChatTools();
+    // MCP 异步并行连接(不阻塞首帧):旧序「await initializeAllMcp() → banner」在
+    // npx/stdio 类 server 上把 REPL 首屏卡住数秒(黑屏等待)。现在 banner/欢迎块先画,
+    // MCP 在后台连;完成后注册工具 + refreshChatTools + 在内容区补连接结果行。
+    // runTurn 前 mcpReady barrier 兜底:用户在连接完成前就发消息时等它就绪(见 runTurn)。
+    const mcpReady = (async () => {
+        const report = await initializeAllMcp();
+        registerToolsExtension('mcp', getMcpTools());
+        refreshChatTools();
+        return report;
+    })();
+    void mcpReady.catch(() => undefined); // 连接失败不产生 unhandledRejection;报告行由 then 写
     // --resume:读回该会话的轮次/快照;无文件则从 history 重建 turns(无快照→旧轮次文件改动不可撤销)
     let currentSessionId = sessionId;
     if (!currentSessionId)
@@ -270,12 +277,16 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
     else {
         layout.writeBanner(bannerLines(banner()));
     }
-    if (mcpReport.connected.length > 0) {
-        layout.contentWrite(`${ui.dim}  ↳ 已连接 MCP: ${mcpReport.connected.join(', ')} (${getMcpTools().length} 个工具;外部工具每次均需授权)${ui.reset}\n`);
-    }
-    for (const warning of mcpReport.warnings) {
-        layout.contentWrite(`${ui.yellow}  ⚠ ${warning}${ui.reset}\n`);
-    }
+    // MCP 连接结果在就绪后补写(后台并行连接,不再阻塞上方首帧);用户已滚动时仍
+    // 落在内容区尾部,与启动期其它提示行为一致。
+    void mcpReady.then((mcpReport) => {
+        if (mcpReport.connected.length > 0) {
+            layout.contentWrite(`${ui.dim}  ↳ 已连接 MCP: ${mcpReport.connected.join(', ')} (${getMcpTools().length} 个工具;外部工具每次均需授权)${ui.reset}\n`);
+        }
+        for (const warning of mcpReport.warnings) {
+            layout.contentWrite(`${ui.yellow}  ⚠ ${warning}${ui.reset}\n`);
+        }
+    });
     if (!isModelConfigured()) {
         // 未配置 baseURL/apiKey:醒目提示引导 /model(不退出,REPL 仍可用;发消息会失败但不崩)。
         layout.contentWrite(`${ui.yellow}  ⚠ 未配置大模型。输入 ${ui.cyan}/model${ui.yellow} 配置 baseURL / apiKey / model(即时生效),或退出后运行 ${ui.cyan}mocode config${ui.yellow} 走向导。${ui.reset}\n`);
@@ -456,6 +467,9 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
         let routingDone = toolPolicy != null;
         try {
             signal = startRunningListener(placeholder);
+            // MCP 后台连接兜底:启动后在连接完成前就发消息的极端窗口,先等就绪再路由,
+            // 保证路由看到的工具表含 MCP 工具(否则本 turn 工具簇不含 mcp__,模型路由失真)。
+            await mcpReady.catch(() => undefined);
             // 入口设定本轮初始模式（合成执行轮传 false→auto；用户轮传当前 mode）。
             // setAgentMode 触发 listener 重写 history[0]；模式只由用户面切换，runAgent 每步读取当前值。
             setAgentMode(planMode ? 'plan' : 'auto');
@@ -533,6 +547,11 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
                 refreshStatusBase(history);
                 layout.drawStatusBar();
             }, toolPolicy, initialToolRoute, runtime);
+            // 撞限 salvage 摘要要在 TUI 落地:runAgent 只把 finalText 带回不渲染,主线撞限的
+            // 收尾摘要若不打印,这笔收尾请求的 token 就白花(用户只看到「达到最大步数」一行)。
+            if (result.terminationReason === 'max_steps' && result.finalText) {
+                layout.contentWrite(result.finalText.endsWith('\n') ? result.finalText : `${result.finalText}\n`);
+            }
             if (toolPolicy)
                 lastToolGroups = toolPolicy.groupNames;
             // 本轮 token 累计(底栏模式 chip 右边显示)。undefined = 后端不开 include_usage。

package/dist/rollback/store.js

@@ -54,6 +54,54 @@ const SCAN_CONCURRENCY = 16;
 const YIELD_EVERY = 64;
 const YIELD_BYTES = 1024 * 1024;
 const FRESH_WINDOW_MS = 2000;
+/**
+ * contentCache 的常驻字节上限(base64 后的长度和);0 = 不限。
+ *
+ * contentCache 是「上次扫描读到的内容」的跨扫描复用:命中则省一次 readFile,
+ * 这就是第 2 次及以后的 workspace 扫描只要 ~35ms 而首次要 500ms+ 的原因
+ * (实测 2026-10-05,2000 entries / 42.7MB base64)。它原先只增不减(唯一清理点是
+ * resetState),即一次扫描就把整个工作区文本永久常留内存。
+ *
+ * **默认保持不限(0)**:实测把上限压到 16MB 会把命中率打崩 —— 缓存从 664 条掉到 54 条,
+ * 扫描耗时从 ~67ms 反弹到 ~1000ms(涨 15倍)。原因是遍历顺序下累积的大文件会挤掉后续
+ * 所有条目,淘汰机制天然对「后访问的小文件」不友好。42.7MB 换每条命令 67ms 是划算的,
+ * 不值得为省内存牺牲 15 倍扫描速度。
+ *
+ * 保留这个旋门是为了「大工作区内存吃紧」的场景(比如 node_modules 被误纳入扫描),
+ * 可通过 MOCODE_ROLLBACK_CACHE_MB 收紧;不设则沿用无上限的既有行为。
+ */
+const CONTENT_CACHE_MAX_BYTES = (() => {
+    const mb = Number(process.env.MOCODE_ROLLBACK_CACHE_MB);
+    return Number.isFinite(mb) && mb > 0 ? Math.floor(mb) * 1024 * 1024 : 0;
+})();
+/**
+ * 把扫描产出的缓存裁到 CONTENT_CACHE_MAX_BYTES 以内,按插入序淘汰最旧条目。
+ *
+ * 仅在 CONTENT_CACHE_MAX_BYTES > 0(即用户显式设了 MOCODE_ROLLBACK_CACHE_MB)时生效;
+ * 默认无上限,保持既有行为。淘汰只影响性能,不影响正确性:被淘汰的条目下次扫描时
+ * stamp 不匹配 → 重新 readFile 而已(snapshot 记录的是**本次扫描当场读到**的内容,
+ * 见 scanWorkspace 的 `cached.stamp === stamp` 校验)。
+ */
+function trimContentCache(cache) {
+    if (CONTENT_CACHE_MAX_BYTES <= 0)
+        return cache;
+    let total = 0;
+    for (const entry of cache.values())
+        total += entry.data.length;
+    if (total <= CONTENT_CACHE_MAX_BYTES)
+        return cache;
+    // Map 保插入序 → 最旧的在最前。逐个删到回到预算内,单趟 O(n) 足够。
+    for (const key of cache.keys()) {
+        if (total <= CONTENT_CACHE_MAX_BYTES)
+            break;
+        const entry = cache.get(key);
+        if (!entry)
+            continue;
+        total -= entry.data.length;
+        cache.delete(key);
+    }
+    return cache;
+}
 /**
  * 一个完整、实例隔离的回滚事务存储。每个 runtime 可持有独立实例，使轮次、序号、
  * 快照、mutation generation 和扫描缓存互不干扰。
@@ -336,7 +384,7 @@ export class RollbackStore {
             }
         };
         await Promise.all(Array.from({ length: Math.min(SCAN_CONCURRENCY, Math.max(1, paths.length)) }, worker));
-        this.contentCache = nextCache;
+        this.contentCache = trimContentCache(nextCache);
         return entries;
     }
     async beginWorkspaceMutation() {
@@ -392,6 +440,13 @@ export class RollbackStore {
     listTurns() {
         return this.turns.slice();
     }
+    /**
+     * 只读侧门(供 /diff 渲染):返回 turnId > sinceTurnId 的全部快照,浅拷贝数组。
+     * 快照内容含 before 原文,调用方不得 mutate 返回值;用于展示,不影响回滚语义。
+     */
+    snapshotsSince(sinceTurnId) {
+        return this.snapshots.filter((snapshot) => snapshot.turnId > sinceTurnId);
+    }
     findCutoffIndex(n, history) {
         let seen = 0;
         for (let i = 0; i < history.length; i++) {

package/dist/runtime/dev-server-manager.js

@@ -127,7 +127,29 @@ async function probeReady(url) {
         clearTimeout(timer);
     }
 }
-function killTree(pid) {
+/**
+ * 异步树杀(运行期路径):spawnSync('taskkill') 会同步阻塞事件循环(扫树期间流式渲染/
+ * 并行工具停摆)。发出 kill 后等 taskkill 退出,不牺牲「进程已终止」语义。
+ * 退出路径(stopAllDevServersSync)必须同步,用 killTreeSync 保留原行为。
+ */
+async function killTree(pid) {
+    if (!IS_WINDOWS) {
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch {
+            // 已退出或无权限:best-effort。
+        }
+        return;
+    }
+    await new Promise((resolve) => {
+        const killer = spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' });
+        killer.on('close', () => resolve());
+        killer.on('error', () => resolve());
+    });
+}
+/** 同步树杀:仅供进程退出钩子(stopAllDevServersSync)使用,运行期请走异步版。 */
+function killTreeSync(pid) {
     try {
         if (IS_WINDOWS) {
             spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' });
@@ -266,13 +288,13 @@ export async function startDevServer(opts) {
     catch (error) {
         // 启动失败 / 被中断:不留孤儿进程。
         record.stopRequested = true;
-        killTree(record.pid);
+        await killTree(record.pid);
         finalizeExit(record, record.child.exitCode, record.child.signalCode);
         throw error;
     }
     if (wantsReadySignal && !ready) {
         record.stopRequested = true;
-        killTree(record.pid);
+        await killTree(record.pid);
         finalizeExit(record, record.child.exitCode, record.child.signalCode);
         throw new DevServerManagerError('TIMEOUT', `Dev server did not become ready within ${timeoutMs}ms and was stopped. Recent output:\n${record.recentLog.trim() || '(no output)'}`);
     }
@@ -328,7 +350,7 @@ export async function stopDevServer(id) {
         return { ...snapshot(record), alreadyStopped: true };
     }
     record.stopRequested = true;
-    killTree(record.pid);
+    await killTree(record.pid);
     const deadline = Date.now() + STOP_GRACE_MS;
     while (Date.now() < deadline && isAlive(record.pid)) {
         await sleep(50);
@@ -350,7 +372,7 @@ export function stopAllDevServersSync() {
         if (record.state !== 'running')
             continue;
         record.stopRequested = true;
-        killTree(record.pid);
+        killTreeSync(record.pid);
         finalizeExit(record, record.child.exitCode, record.child.signalCode);
     }
 }

package/dist/schedule/cli.js

@@ -83,7 +83,7 @@ export async function runScheduleCli(rawArgs) {
             return 0;
         }
         case 'stop':
-            process.stdout.write(stopDaemon() ? 'Scheduler stopped\n' : 'Scheduler was not running\n');
+            process.stdout.write((await stopDaemon()) ? 'Scheduler stopped\n' : 'Scheduler was not running\n');
             return 0;
         case 'status': {
             const state = getDaemonState();

package/dist/schedule/daemon.js

@@ -150,12 +150,12 @@ export function startDaemon(port = DEFAULT_PORT) {
     fs.writeFileSync(daemonStatePath(), `${JSON.stringify(state, null, 2)}\n`);
     return { started: true, state };
 }
-/** 停止守护进程并清状态。 */
-export function stopDaemon() {
+/** 停止守护进程并清状态。异步:树杀不再阻塞事件循环(见 jobs/launch.ts killTree)。 */
+export async function stopDaemon() {
     const state = getDaemonState();
     if (!state)
         return false;
-    const ok = killTree(state.pid);
+    const ok = await killTree(state.pid);
     try {
         fs.rmSync(daemonStatePath());
     }

package/dist/session/store.js

@@ -66,6 +66,20 @@ export class SessionStore {
     currentSessionIdProvider;
     currentSessionIdSetter;
     currentSessionId;
+    /**
+     * 已确保存在的会话目录缓存(2026-10-05)。
+     *
+     * `mkdirSync(recursive)` 单次 0.20ms —— 比 existsSync+statSync(合计 0.009ms)贵 20 倍,
+     * 因为 recursive 模式要逐级向下 stat 每层路径。而 appendTrace 每 step 调 14 次
+     * (step_start/end + model_start/end + 每工具 2 个),每轮 20 step ≈ 280 次全花在
+     * 「确认目录已存在」上,一轮白烧 56ms。
+     *
+     * 缓存的是「已 mkdir 成功」这件事,不是路径存在性。**代价**:外部删掉目录后缓存会失真。
+     * 兜底是三个写盘方法统一的「失败 → invalidateEnsuredDir → 重试一次」模式
+     * (见 appendTrace / appendUsage / save),既保住性能又不丢数据。
+     * 护栏见 tests/session-dir-cache.test.ts 的「外部删除后自愈」三例。
+     */
+    ensuredDirs = new Set();
     constructor(options = {}) {
         if (typeof options.workspaceRoot === 'function') {
             const provider = options.workspaceRoot;
@@ -92,9 +106,26 @@ export class SessionStore {
     }
     sessionDir() {
         const root = this.sessionsRoot;
-        mkdirSync(root, { recursive: true });
+        this.ensureDir(root);
         return root;
     }
+    /**
+     * 幂等建目录:同一路径只在首次真正 mkdir(见 ensuredDirs 的成本说明)。
+     *
+     * 缓存意味着「外部删掉目录后不自愈」,故所有写盘方法都用
+     * {@link invalidateEnsuredDir} + 重试一次兜住(retention 归档后 rmSync、
+     * 用户手工清理等)。单靠这里的 Set 不会自愈,必须配对那个重试。
+     */
+    ensureDir(dir) {
+        if (this.ensuredDirs.has(dir))
+            return;
+        mkdirSync(dir, { recursive: true });
+        this.ensuredDirs.add(dir);
+    }
+    /** 让 ensureDir 下次真正 mkdir(用于 append 失败后的自愈重试)。 */
+    invalidateEnsuredDir(dir) {
+        this.ensuredDirs.delete(dir);
+    }
     createId() {
         return createTimestampId();
     }
@@ -119,22 +150,38 @@ export class SessionStore {
      * 然后清空当前文件。纯诊断数据,任何失败静默降级为普通追加。
      */
     appendTrace(id, value) {
-        try {
-            const dir = path.join(this.sessionsRoot, id);
-            mkdirSync(dir, { recursive: true });
-            const line = `${JSON.stringify(value)}\n`;
-            const tracePath = path.join(dir, 'trace.jsonl');
-            // env 覆盖仅供测试:MOCODE_MAX_TRACE_BYTES=200 可立刻触发轮转。
-            const envMax = Number(process.env.MOCODE_MAX_TRACE_BYTES);
-            const maxTraceBytes = Number.isFinite(envMax) && envMax >= 0 ? envMax : MAX_TRACE_BYTES;
-            const size = existsSync(tracePath) ? statSync(tracePath).size : 0;
-            if (size >= maxTraceBytes) {
-                this.rotateTrace(dir, tracePath);
+        const dir = path.join(this.sessionsRoot, id);
+        const line = `${JSON.stringify(value)}\n`;
+        const tracePath = path.join(dir, 'trace.jsonl');
+        // env 覆盖仅供测试:MOCODE_MAX_TRACE_BYTES=200 可立刻触发轮转。
+        const envMax = Number(process.env.MOCODE_MAX_TRACE_BYTES);
+        const maxTraceBytes = Number.isFinite(envMax) && envMax >= 0 ? envMax : MAX_TRACE_BYTES;
+        // 目录缓存可能因外部删除而失真(如 retention 归档后 rmSync):首次失败清缓存重试一次。
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                this.ensureDir(dir); // 缓存:每 step 14 次调用,省 14×0.20ms
+                // statSync 一次即可拿到「不存在 / 大小」两种答案,省掉 existsSync 那一跳
+                // (两者合计仅 0.009ms,但顺手消掉一次 TOCTOU 窗口)。
+                let size = 0;
+                try {
+                    size = statSync(tracePath).size;
+                }
+                catch {
+                    size = 0;
+                }
+                if (size >= maxTraceBytes) {
+                    this.rotateTrace(dir, tracePath);
+                }
+                writeFileSync(tracePath, line, { encoding: 'utf8', flag: 'a' });
+                return;
+            }
+            catch {
+                this.invalidateEnsuredDir(dir);
+                if (attempt === 1) {
+                    // Observability is best-effort and cannot block coding work.
+                    return;
+                }
             }
-            writeFileSync(tracePath, line, { encoding: 'utf8', flag: 'a' });
-        }
-        catch {
-            // Observability is best-effort and cannot block coding work.
         }
     }
     rotateTrace(dir, tracePath) {
@@ -174,13 +221,23 @@ export class SessionStore {
      * 与 appendTrace 同策略:纯诊断,失败静默,不做轮转(长会话的量级远小于 trace)。
      */
     appendUsage(id, value) {
-        try {
-            const dir = path.join(this.sessionsRoot, id);
-            mkdirSync(dir, { recursive: true });
-            writeFileSync(path.join(dir, 'usage.jsonl'), `${JSON.stringify(value)}\n`, { encoding: 'utf8', flag: 'a' });
-        }
-        catch {
-            // Metrics must never block coding work.
+        const dir = path.join(this.sessionsRoot, id);
+        const line = `${JSON.stringify(value)}\n`;
+        const file = path.join(dir, 'usage.jsonl');
+        // 同 appendTrace:目录缓存失真时清缓存重试一次。
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                this.ensureDir(dir); // 同appendTrace:每 step 1 次,省 0.20ms
+                writeFileSync(file, line, { encoding: 'utf8', flag: 'a' });
+                return;
+            }
+            catch {
+                this.invalidateEnsuredDir(dir);
+                if (attempt === 1) {
+                    // Metrics must never block coding work.
+                    return;
+                }
+            }
         }
     }
     /** 读取 <id>/usage.jsonl 全部记录;文件不存在或损坏行跳过。 */
@@ -202,6 +259,13 @@ export class SessionStore {
         }
         return out;
     }
+    /**
+     * 全量落盘会话(history + queryHistory + lastToolGroups),原子写(先 tmp 再 rename)。
+     *
+     * 与 appendTrace/appendUsage 的差别:**失败会抛给调用方**——这是用户数据,
+     * 静默丢失不可接受(那两个是诊断数据,静默降级是对的)。目录缓存失真时会
+     * 清缓存重试一次,仍失败则照旧抛出。
+     */
     save(history, id, queryHistory = [], lastToolGroups = []) {
         const meta = {
             id,
@@ -216,21 +280,33 @@ export class SessionStore {
         if (history.length <= 1 && queryHistory.length === 0 && !existsSync(currentPath) && !existsSync(legacyPath)) {
             return meta;
         }
-        mkdirSync(path.join(this.sessionsRoot, id), { recursive: true });
+        const dir = path.join(this.sessionsRoot, id);
+        const tmpPath = path.join(dir, 'session.json.tmp');
         const record = {
             ...meta,
             history,
             queryHistory: [...queryHistory],
             lastToolGroups: [...lastToolGroups],
         };
-        // 原子落盘:先写同目录 tmp 再 rename——全量重写(长会话可达数 MB)中途崩溃/断电
-        // 不会留下半个 JSON 把整个会话写坏(对齐 memory/store.ts writeAtomic)。
-        const tmpPath = path.join(this.sessionsRoot, id, 'session.json.tmp');
-        writeFileSync(tmpPath, JSON.stringify(record), 'utf8');
-        renameSync(tmpPath, currentPath);
-        if (existsSync(legacyPath))
-            unlinkSync(legacyPath);
-        return meta;
+        // 目录缓存失真时清缓存重试一次(与 appendTrace 同理);仍失败则照旧抛给调用方
+        // —— save 是用户数据落盘,失败必须可见(appendTrace/appendUsage 是诊断数据,静默)。
+        for (let attempt = 0;; attempt++) {
+            try {
+                this.ensureDir(dir);
+                // 原子落盘:先写同目录 tmp 再 rename——全量重写(长会话可达数 MB)中途崩溃/断电
+                // 不会留下半个 JSON 把整个会话写坏(对齐 memory/store.ts writeAtomic)。
+                writeFileSync(tmpPath, JSON.stringify(record), 'utf8');
+                renameSync(tmpPath, currentPath);
+                if (existsSync(legacyPath))
+                    unlinkSync(legacyPath);
+                return meta;
+            }
+            catch (error) {
+                this.invalidateEnsuredDir(dir);
+                if (attempt === 1)
+                    throw error;
+            }
+        }
     }
     load(id) {
         const currentPath = this.sessionPath(id);