mocode-ai 1.2.1 → 1.2.3

package/dist/agent/core.js

@@ -337,9 +337,20 @@ export async function runAgentCore(opts) {
                 const modelStartedAt = Date.now();
                 const provider = safeProviderId(requestBaseURL);
                 emitTrace('model_start', { model: requestModel, provider });
-                const dynamicSystemSuffix = historyRebuilt
-                    ? '## Post-compaction recovery\nContext was compacted before this request. Re-establish the current objective and unresolved work from retained evidence or the session note, avoid repeating completed investigation, and re-read exact file context before any dependent edit.'
-                    : '';
+                // 动态注入(仅追加到 system 末尾,不触碰 staticBody 前缀 → 不破坏 prompt 缓存):
+                //  - 开场分析:仅主线(step===0 且 !suppressOpeningAnalysis)注入——即"用户发一个任务后,
+                //    agent 第一次模型调用"。子代理经 spawn.ts 传 suppressOpeningAnalysis:true 排除。
+                //  - historyRebuilt:compact 恢复步;要求重新锚定目标。两者可叠加但互不串扰。
+                //  .filter(Boolean) 保证空段不产生多余空行;后续 step 均为空串 → system 前缀稳定命中缓存。
+                //  安全保证:此段只拼进 requestHistory(新建对象),绝不回写 history[0],故不会跨 step/跨 turn 残留。
+                const dynamicSystemSuffix = [
+                    (!opts.suppressOpeningAnalysis && step === 0)
+                        ? '## Opening analysis\nBegin your FIRST response of this turn with a brief analysis of the request and your planned approach (1-3 sentences, no filler), THEN start tool calls. This opening is the only place where pre-tool prose is expected; after it, work quietly with no narration between tool calls.'
+                        : '',
+                    historyRebuilt
+                        ? '## Post-compaction recovery\nContext was compacted before this request. Re-establish the current objective and unresolved work from retained evidence or the session note, avoid repeating completed investigation, and re-read exact file context before any dependent edit.'
+                        : '',
+                ].filter(Boolean).join('\n\n');
                 const systemMessage = history[0];
                 const requestHistory = dynamicSystemSuffix
                     && systemMessage?.role === 'system'

package/dist/agent/spawn.js

@@ -225,6 +225,7 @@ export async function spawnAgent(opts) {
         maxSteps,
         toolsOverride,
         contextState: localContextState,
+        suppressOpeningAnalysis: true, // 子代理不注入「开场分析」:仅主线面对用户的首次响应用
         onToolOutcome: (tool, args) => {
             if (tool === 'read_file' && typeof args.path === 'string')
                 readSet.add(args.path);

package/dist/rollback/index.js

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
-import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, rmdirSync, rmSync, symlinkSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, rmdirSync, rmSync, symlinkSync, unlinkSync, writeFileSync, } from 'node:fs';
+import * as fsp from 'node:fs/promises';
 import path from 'node:path';
 import { config } from '../config/index.js';
 import { truncateDisplay } from '../ui/render.js';
@@ -50,8 +51,19 @@ function readState(full) {
     }
     return { kind: 'missing' };
 }
+/**
+ * 状态等价判定。两侧都捕获了内容时按内容比(与旧行为一致,精确);
+ * 任一侧内容未捕获(超预算的大文件)时退化为 stamp 比较——size+mtimeNs 变了就算变。
+ */
 function sameState(a, b) {
-    return a.kind === b.kind && a.data === b.data && a.mode === b.mode;
+    if (a.kind !== b.kind || a.mode !== b.mode)
+        return false;
+    if (a.data !== undefined && b.data !== undefined)
+        return a.data === b.data;
+    if (a.data === undefined && b.data === undefined && a.stamp === undefined && b.stamp === undefined) {
+        return true; // directory / missing:kind+mode 已足够
+    }
+    return a.stamp === b.stamp;
 }
 function stateFingerprint(state) {
     return createHash('sha256')
@@ -82,6 +94,8 @@ function snapshotFromState(rel, state, sequence, op, createdParents = [], after)
         ops: [op],
         createdParents: createdParents.length > 0 ? createdParents : undefined,
         afterFingerprint: after ? stateFingerprint(after) : undefined,
+        // 文件但没有内容 = 工作区扫描时超出捕获预算,只能报告"变了",不能拿它覆盖磁盘。
+        contentUnavailable: state.kind === 'file' && state.data === undefined ? true : undefined,
     };
 }
 /** 同轮同路径只保留最早的 before；后续实际改动仅合并工具名。 */
@@ -163,55 +177,172 @@ export function endPathMutation(capture, op) {
     if (changed)
         mutationVersion += 1;
 }
-// 构建产物 / 临时 / 缓存目录：可再生运行时状态，扫描它们既昂贵（dist/ 含大量 .js bundle，
-// 全量 readFileSync 会同步卡死事件循环，表现为 run_command 期间滚轮划不动、spinner 冻结），
-// 也易把后台 daemon / 打包器的写入误判成模型改动。回滚本就只应覆盖源码，构建产物可再生。
+// 构建产物 / 依赖树 / 缓存 / 运行时状态目录：可再生，扫描它们既昂贵也易把后台 daemon、
+// 打包器、mocode 自身(会话日志 / dev-server 日志 / 截图)的写入误判成模型改动。
+// 回滚本就只应覆盖源码。
 const EXCLUDED_WORKSPACE_DIRS = new Set([
-    '.git', '.codegraph', 'node_modules',
-    'dist', 'build', 'out', 'coverage', '.tmp', 'tmp',
-    '.output', '.next', '.vite', '.turbo', '.svelte-kit',
+    // VCS / 索引 / mocode 自身运行时状态(会话、trace、dev-server 日志、记忆、截图每轮都在写,
+    // 既无回滚意义,又会被误判成模型改动)
+    '.git', '.hg', '.svn', '.codegraph', '.mocode',
+    // 依赖树与包管理器缓存
+    'node_modules', 'vendor', 'bower_components', '.yarn', '.pnpm-store', '.venv', 'venv', 'pods',
+    // 构建产物
+    'dist', 'build', 'out', 'target', 'coverage', '.output', '.next', '.nuxt', '.vite',
+    '.turbo', '.svelte-kit', '.angular', '.astro', '.docusaurus', '.dart_tool', '.terraform',
+    // 临时与缓存
+    '.tmp', 'tmp', '.cache', '.parcel-cache', '.nyc_output', '__pycache__',
+    '.pytest_cache', '.mypy_cache', '.ruff_cache', '.gradle',
 ]);
+/** 单文件内容捕获上限：更大的文件只留 stamp(可检测变化,不可恢复),避免把巨型二进制读进内存。 */
+const CAPTURE_FILE_LIMIT = 1024 * 1024;
+/** 单次扫描的内容总预算：超出后剩余文件只留 stamp。 */
+const CAPTURE_TOTAL_LIMIT = 32 * 1024 * 1024;
+/** 条目上限：超大工作区不做无边界遍历(超出部分不参与变更检测)。 */
+const CAPTURE_ENTRY_LIMIT = 20000;
+/** 并发文件操作数：冷缓存(尤其 Windows 杀软逐文件扫描)下 I/O 重叠远快于串行。 */
+const SCAN_CONCURRENCY = 16;
+/** 让出事件循环的节奏:每 N 个条目,或每累计编码 M 字节(base64 是纯 CPU,大文件靠字节数兜底)。 */
+const YIELD_EVERY = 64;
+const YIELD_BYTES = 1024 * 1024;
+/**
+ * 刚被写过的文件不信缓存,强制重读内容。
+ * 原因:stamp 依赖 mtime 精度。NTFS/ext4/APFS 是 100ns~ns 级,但 exFAT / 部分网络盘只有 1~2s,
+ * 那里一条"同尺寸原地改写"可能与快照前共享同一时间戳,只比 stamp 会漏掉真实变化。
+ * 只对最近 2s 内改动的文件付重读代价(通常正是命令刚碰过的那几个),开销可忽略。
+ */
+const FRESH_WINDOW_MS = 2000;
+/** path → 上次扫描捕获的内容。stamp(size+mtimeNs)未变即复用，未改动的文件不重复读盘。 */
+let contentCache = new Map();
+let cachedSessionDir = '';
+let resolvedSessionDir = '';
+function sessionDirAbs() {
+    if (config.sessionDir !== cachedSessionDir) {
+        cachedSessionDir = config.sessionDir;
+        resolvedSessionDir = path.resolve(config.sessionDir);
+    }
+    return resolvedSessionDir;
+}
 function isWorkspaceExcluded(full) {
     const base = path.basename(full).toLowerCase();
     // Git 元数据必须永久排除以保护 index；依赖树/代码索引/构建产物/临时目录是可再生运行时状态。
     if (EXCLUDED_WORKSPACE_DIRS.has(base))
         return true;
-    const sessionDir = path.resolve(config.sessionDir);
-    return isInside(sessionDir, full);
+    return isInside(sessionDirAbs(), full);
 }
-function scanWorkspace() {
+const yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
+/**
+ * 工作区快照(run_command / dev_server / MCP 等不透明工具用)。
+ *
+ * **必须是异步且带缓存的**：本函数在每次这类工具调用前后各跑一次，直接坐在用户交互
+ * 路径上。旧实现用 readdirSync + 全量 readFileSync(base64) 同步遍历整棵工作树 ——
+ * 冷文件缓存下 400 个文件实测就要 ~3s(Windows)，几千个文件即数十秒，期间事件循环
+ * 完全阻塞：spinner 冻结、走时停摆、键鼠无响应，用户看到的就是「卡在 执行 run_command」。
+ *
+ * 现在:
+ *  1) fs/promises + 有界并发 + 定期 setImmediate 让出 → 事件循环全程可呼吸;
+ *  2) 内容按 (size, mtimeNs, mode) 缓存复用 → 未改动的文件不再重复读盘,
+ *     一次会话里只有首次扫描付全量代价,之后只读真正变化的文件;
+ *  3) 单文件 / 总量 / 条目数三重预算 → 巨型仓库不会把内存和时间吃穿。
+ */
+async function scanWorkspace() {
     const entries = new Map();
-    const walk = (dir) => {
+    const nextCache = new Map();
+    const paths = [];
+    // 第一趟:只 readdir 收集条目(廉价,不读内容)。目录本身即刻记账,顺序稳定。
+    const walk = async (dir) => {
+        if (paths.length >= CAPTURE_ENTRY_LIMIT)
+            return;
         let children;
         try {
-            children = readdirSync(dir, { withFileTypes: true });
+            children = await fsp.readdir(dir, { withFileTypes: true });
         }
         catch {
             return;
         }
         for (const child of children) {
+            if (paths.length >= CAPTURE_ENTRY_LIMIT)
+                return;
             const full = path.join(dir, child.name);
             if (isWorkspaceExcluded(full))
                 continue;
-            const state = readState(full);
+            paths.push(full);
+            // isDirectory() 对 symlink 为 false —— 与旧实现一致:不跟随软链。
+            if (child.isDirectory())
+                await walk(full);
+        }
+    };
+    await walk(rootDir());
+    // 第二趟:有界并发读状态。budget 由完成顺序消费——两次扫描间某个大文件是否被捕获
+    // 可能不同,sameState 在任一侧缺内容时退化为 stamp 比较,故不会产生伪变化。
+    let budget = CAPTURE_TOTAL_LIMIT;
+    let cursor = 0;
+    let processed = 0;
+    let bytesSinceYield = 0;
+    const worker = async () => {
+        while (cursor < paths.length) {
+            const full = paths[cursor++];
+            if (++processed % YIELD_EVERY === 0 || bytesSinceYield >= YIELD_BYTES) {
+                bytesSinceYield = 0;
+                await yieldToEventLoop();
+            }
+            let state;
+            try {
+                const stat = await fsp.lstat(full, { bigint: true });
+                const mode = Number(stat.mode) & 0o777;
+                if (stat.isSymbolicLink()) {
+                    const target = await fsp.readlink(full);
+                    state = { kind: 'symlink', data: target, stamp: target, mode };
+                }
+                else if (stat.isDirectory()) {
+                    state = { kind: 'directory', mode, stamp: '' };
+                }
+                else if (stat.isFile()) {
+                    const size = Number(stat.size);
+                    const stamp = `${size}:${stat.mtimeNs}`;
+                    // 未来时间戳(时钟偏移)同样按"新鲜"处理 —— 宁可多读一次,不可漏判变化。
+                    const fresh = Date.now() - Number(stat.mtimeNs / 1000000n) < FRESH_WINDOW_MS;
+                    const cached = fresh ? undefined : contentCache.get(full);
+                    if (cached && cached.stamp === stamp && cached.mode === mode) {
+                        budget -= size; // 命中也计预算,保证冷/热缓存下的捕获集合一致
+                        state = { kind: 'file', data: cached.data, stamp, mode };
+                        nextCache.set(full, cached);
+                    }
+                    else if (size <= CAPTURE_FILE_LIMIT && budget - size >= 0) {
+                        budget -= size;
+                        bytesSinceYield += size;
+                        const data = (await fsp.readFile(full)).toString('base64');
+                        state = { kind: 'file', data, stamp, mode };
+                        nextCache.set(full, { stamp, mode, data });
+                    }
+                    else {
+                        // 超大文件 / 预算耗尽:只留指纹,能报告变化但不参与内容恢复。
+                        state = { kind: 'file', stamp, mode };
+                    }
+                }
+                else {
+                    state = { kind: 'missing' };
+                }
+            }
+            catch {
+                state = { kind: 'missing' }; // 不存在或不可读:工具若最终也不可读,不会产生伪变化
+            }
             if (state.kind === 'missing')
                 continue;
-            const rel = toRel(full);
-            entries.set(rel, state);
-            if (state.kind === 'directory')
-                walk(full);
+            entries.set(toRel(full), state);
         }
     };
-    walk(rootDir());
+    await Promise.all(Array.from({ length: Math.min(SCAN_CONCURRENCY, Math.max(1, paths.length)) }, worker));
+    // 缓存整体替换:已删除的文件自然被淘汰,内存上限 ≈ CAPTURE_TOTAL_LIMIT。
+    contentCache = nextCache;
     return entries;
 }
 /** run_command/MCP 前调用。不跟随 symlink，并排除 .git、会话快照、依赖树与代码索引。 */
-export function beginWorkspaceMutation() {
-    return { sequence: ++sequenceCounter, entries: scanWorkspace() };
+export async function beginWorkspaceMutation() {
+    return { sequence: ++sequenceCounter, entries: await scanWorkspace() };
 }
 /** 不透明工具执行后比较整个工作区，把实际变化压入当前轮事务日志。 */
-export function endWorkspaceMutation(capture, op) {
-    const after = scanWorkspace();
+export async function endWorkspaceMutation(capture, op) {
+    const after = await scanWorkspace();
     const paths = new Set([...capture.entries.keys(), ...after.keys()]);
     let changed = false;
     for (const rel of paths) {
@@ -234,10 +365,16 @@ export function getCurrentTurnMutationState() {
             continue;
         let change = byPath.get(snapshot.path);
         if (!change) {
-            change = { path: snapshot.path, ops: [], snapshotAvailable: true };
+            change = {
+                path: snapshot.path,
+                ops: [],
+                snapshotAvailable: snapshot.contentUnavailable !== true,
+            };
             byPath.set(snapshot.path, change);
             order.push(snapshot.path);
         }
+        if (snapshot.contentUnavailable)
+            change.snapshotAvailable = false;
         for (const op of snapshot.ops ?? ['file_change']) {
             if (!change.ops.includes(op))
                 change.ops.push(op);
@@ -281,6 +418,8 @@ export function planRollback(n, history) {
         if (snapshot.turnId <= cutoffTurnId)
             continue;
         const change = ensure(snapshot.path);
+        if (snapshot.contentUnavailable)
+            change.snapshotAvailable = false;
         for (const op of snapshot.ops ?? ['file_change']) {
             if (!change.ops.includes(op))
                 change.ops.push(op);
@@ -300,6 +439,9 @@ function restoreSnapshot(snapshot) {
     const full = safeFullPath(snapshot.path);
     if (!full)
         return false;
+    // 内容未捕获(工作区扫描时超出预算):宁可报冲突,也不能拿空内容覆盖用户文件。
+    if (snapshot.contentUnavailable)
+        return false;
     const state = stateFromSnapshot(snapshot);
     try {
         if (state.kind === 'missing') {
@@ -413,6 +555,7 @@ export function resetState() {
     turnIdCounter = 0;
     currentTurnId = 0;
     sequenceCounter = 0;
+    contentCache = new Map();
 }
 export function rebuildFromHistory(history) {
     const rebuilt = [];

package/dist/tools/registry.js

@@ -148,8 +148,10 @@ async function executeToolOnce(tool, args, signal, opts) {
                 ? beginPathMutation(args.path)
                 : null;
             capturedPath = pathCapture?.path;
+            // 工作区快照是异步的:它遍历整棵工作树,同步实现会在每次 run_command/MCP 调用前后
+            // 阻塞事件循环数秒(TUI 完全冻结)。await 让 spinner / 走时 / 键鼠在扫描期间继续工作。
             const workspaceCapture = capabilities.effect === 'process' || capabilities.effect === 'unknown'
-                ? beginWorkspaceMutation()
+                ? await beginWorkspaceMutation()
                 : null;
             let raw;
             try {
@@ -159,7 +161,7 @@ async function executeToolOnce(tool, args, signal, opts) {
                 if (pathCapture)
                     endPathMutation(pathCapture, tool.name);
                 if (workspaceCapture)
-                    endWorkspaceMutation(workspaceCapture, tool.name);
+                    await endWorkspaceMutation(workspaceCapture, tool.name);
             }
             const mutationAfter = getCurrentTurnMutationState();
             const changedFiles = mutationAfter.version !== mutationBefore.version

package/dist/ui/intervention.js

@@ -210,7 +210,7 @@ export async function promptIntervention(req) {
             layout.resetScroll();
         else
             layout.repaintViewport();
-        // 恢复走时计时器(RUNNING 态):面板期间 stopTurnTimer 停了心跳,退出后恢复状态行 200ms 刷新。
+        // 恢复走时计时器(RUNNING 态):面板期间 stopTurnTimer 停了心跳,退出后恢复状态行 80ms 刷新。
         layout.startTurnTimerIfRunning();
     }
     function onKey(_str, key) {
@@ -339,7 +339,7 @@ export async function promptIntervention(req) {
     return new Promise((res, rej) => {
         resolve = res;
         try {
-            // 进入面板:停 spinner(避免 onFrame 覆盖)+ 停走时计时器(避免 drawStatusBar 200ms 心跳
+            // 进入面板:停 spinner(避免 onFrame 覆盖)+ 停走时计时器(避免 drawStatusBar 80ms 心跳
             // 把真光标拉到 runningCaretPos 覆盖 paintInput 的正确光标位)+ 禁鼠标框选(防拖拽 viewport 重画覆盖菜单)+ 回尾(若用户正滚动回看)
             Spinner.pauseCurrent();
             layout.stopTurnTimer();

package/dist/ui/layout.js

@@ -82,7 +82,7 @@ const SCROLL_LOCK_MS = 400; // 锁时长:覆盖 OS 缓冲残留 + 常规滚轮
 let base = null;
 // 运行态实时 token 用量(agent core 流式推送,轮末 repl 清 undefined)。
 // composeModelLine 在 RUNNING 态把它画成 chip 放 context 进度条左侧;
-// 不主动触发重画——RUNNING 态 turnTimer 200ms 心跳重画自然取最新值。
+// 不主动触发重画——RUNNING 态 turnTimer 80ms 心跳重画自然取最新值。
 let liveUsage;
 let statusText = '';
 let spinnerFrame;
@@ -92,8 +92,8 @@ let turnTimer = null; // 走时刷新计时器(独立于 spinner):流式期间 s
  *  驱动 paintInput setRegion(fh) 动态撑高脚栏;drawStatusBar 据此画 1/2 行 plan,
  *  与 spinner/上线/输入/下线/model 行的 +1/+2/+3/+4/+5 偏移天然一致(contentBottom 自动重算)。 */
 let planRows = 1;
-let runningFrame = -1; // 运行态状态行 chip 心跳帧(♥/♡ 明灭);INPUT 态 -1 退回静态 ●
-const RUNNING_FRAMES = ['♥', '♡'];
+let runningFrame = -1; // 运行态状态行 chip 心跳帧(转圈帧 明灭);INPUT 态 -1 退回静态 ●
+const RUNNING_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 // 运行态用户打字时暂停流式物理写:流式每个 token 要 cup 到 contentRow 写入,IME 候选窗逐光标移动跟踪会跟过去;
 // 用户打字期间只喂缓冲、不物理写,光标留输入框;停手 USER_ACTIVE_PAUSE_MS 后 flush 重画缓冲内容。
 let userActiveUntil = 0; // 打字活跃截止时刻(Date.now()+PAUSE);0=未活跃
@@ -1332,7 +1332,7 @@ function twoColumn(leftStr, leftW, rightStr, rightW, cols) {
  *  示例:
  *    INPUT:     ● 空闲
  *    思考中:    ⠹ 思考中… 0.5s
- *    运行心跳:  ♥ 0.5s
+ *    运行心跳:  ⠋ 生成中 0.5s
  *    滚动回看:  ● 空闲                  历史 ↑3 (PgDn 回底)  */
 function composeSpinnerLine(status, cols) {
     const spinning = mode === 'running' && runningFrame >= 0;
@@ -1361,10 +1361,11 @@ function composeSpinnerLine(status, cols) {
         leadW = 1 + 1 + displayWidth(status.status) + (elapsed ? 1 + displayWidth(elapsed) : 0);
     }
     else if (spinning) {
-        // 运行态心跳帧(流式输出中):帧 + 走时
+        // 运行态心跳帧(流式输出中):帧 + 生成中 + 走时
+        const label = '生成中';
         const ePart = elapsed ? ` ${ui.dim}${elapsed}${ui.reset}` : '';
-        lead = `${ui.bold}${ui.accent}${RUNNING_FRAMES[runningFrame]}${ui.reset}${ePart}`;
-        leadW = 1 + (elapsed ? 1 + displayWidth(elapsed) : 0);
+        lead = `${ui.bold}${ui.accent}${RUNNING_FRAMES[runningFrame]}${ui.reset} ${ui.dim}${label}${ui.reset}${ePart}`;
+        leadW = 1 + 1 + displayWidth(label) + (elapsed ? 1 + displayWidth(elapsed) : 0);
     }
     else {
         // INPUT 态:● + 状态文字(无走时)
@@ -1539,9 +1540,9 @@ export function setStatus(status, frame) {
     drawStatusBar();
 }
 /**
- * 启走时刷新计时器:RUNNING 态每 200ms 重画状态行,使 composeStatus 重算 elapsed。
+ * 启走时刷新计时器:RUNNING 态每 80ms 重画状态行,使 composeStatus 重算 elapsed。
  * 必要性:spinner 在首 token 到达即 stop,思考/正文流式期间状态行不再经 spinner 刷新;
- * 若走时只挂 spinner onFrame,流式那几十秒会冻住。此计时器独立续刷,与 spinner 80ms 重叠幂等无妨。
+ * 若走时只挂 spinner onFrame,流式那几十秒会冻住。此计时器独立续刷,与 spinner 80ms 同速,重叠幂等无妨。
  * 非 TTY 不启(active=false 时 drawStatusBar 为 no-op)。
  */
 function startTurnTimer() {
@@ -1552,10 +1553,10 @@ function startTurnTimer() {
     turnTimer = setInterval(() => {
         runningFrame = (runningFrame + 1) % RUNNING_FRAMES.length; // 推进心跳帧,让前导符跳动
         drawStatusBar();
-    }, 200);
+    }, 80);
     turnTimer.unref();
 }
-/** 停走时计时器。enterInputMode / exitAltScreen 调;intervention 面板进入时也调(防 drawStatusBar 200ms 心跳把光标拉到 runningCaretPos,覆盖 paintInput 的正确光标位)。 */
+/** 停走时计时器。enterInputMode / exitAltScreen 调;intervention 面板进入时也调(防 drawStatusBar 80ms 心跳把光标拉到 runningCaretPos,覆盖 paintInput 的正确光标位)。 */
 export function stopTurnTimer() {
     if (turnTimer) {
         clearInterval(turnTimer);
@@ -1646,7 +1647,7 @@ export function clearLiveAtCursor() {
     frameCol = 0;
 }
 /** 推送 / 清空运行态实时 token 用量(agent core 流式推送;repl 轮末清 undefined)。
- *  不触发重画:RUNNING 态 turnTimer 200ms 心跳重画状态行,自然取到最新值。 */
+ *  不触发重画:RUNNING 态 turnTimer 80ms 心跳重画状态行,自然取到最新值。 */
 export function setLiveUsage(u) {
     liveUsage = u;
 }

package/package.json

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