mocode-ai 1.5.2 → 1.5.4

package/dist/agent/index.js

@@ -382,6 +382,8 @@ runtimeOrContext = defaultRuntime) {
         },
         onStepStart: () => spinner.start(t('agent.thinking')),
         onChatDone: () => spinner.stop(),
+        // 退避重试要在状态行可见:否则用户面对的是几十秒到几分钟的静止 spinner,与卡死无异。
+        onModelRetry: (r) => spinner.start(t('agent.retrying', { seconds: Math.max(1, Math.round(r.waitMs / 1000)), attempt: r.attempt })),
         // 流式实时用量 → 底栏 context 进度条左侧 chip;轮末由 repl 清空。
         onLiveUsage: (u) => layout.setLiveUsage(u),
         onTextEnd: () => {

package/dist/agent/model-turn.js

@@ -1,4 +1,20 @@
 import { estimatePromptTokens, estimateTokens, isContextLengthError, } from '../llm/index.js';
+/**
+ * 沿 cause 链(≤3 层)取第一个 errno,供 trace 取证。
+ * undici 把底层 errno 挂在 cause 上(`TypeError: fetch failed` → cause `read ECONNRESET`),
+ * openai SDK 再包一层 APIConnectionError 后,顶层 code 恒为 undefined;不留这一项,
+ * 事后只能看到一个 'Error',无法区分 DNS 失败 / 连接被拒 / TLS 握手失败。
+ */
+function traceCauseCode(err) {
+    let cur = err;
+    for (let depth = 0; depth <= 3 && cur && typeof cur === 'object'; depth++) {
+        const e = cur;
+        if (typeof e.code === 'string')
+            return e.code;
+        cur = e.cause;
+    }
+    return undefined;
+}
 /** Executes context preparation plus exactly one model step, including the single overflow retry path. */
 export async function runModelTurn(input) {
     const { opts, ctx, history, historyManager, runtimeContextState, scheduler, contextTrimmer, modelRunner, activeTools, runPolicy, step, cacheState, turnLifecycle, cancellationLifecycle, rebuildHistoryIndexes, } = input;
@@ -112,28 +128,44 @@ export async function runModelTurn(input) {
         onText,
         onToolCall,
         onProgress: reportLive,
-        onRetry: (retry) => emitTrace('model_retry', {
-            model: requestModel,
-            provider,
-            attempt: retry.attempt,
-            nextAttempt: retry.nextAttempt,
-            waitMs: retry.waitMs,
-            code: retry.code,
-        }),
+        onRetry: (retry) => {
+            emitTrace('model_retry', {
+                model: requestModel,
+                provider,
+                attempt: retry.attempt,
+                nextAttempt: retry.nextAttempt,
+                waitMs: retry.waitMs,
+                code: retry.code,
+            });
+            // 退避最长可到 30s、最坏累计数分钟。只写 trace 的话用户看到的就是「卡住不动」,
+            // 与「直接报错终止」一样不可解释 —— 所以同时转达给宿主做可见反馈。
+            hooks.onModelRetry?.(retry);
+        },
     };
     const runChatOnce = async () => {
         try {
             return await modelRunner.run({ history: requestHistory, handlers: chatHandlers, tools: activeTools }, signal);
         }
         catch (error) {
-            const errorValue = error && typeof error === 'object' ? error : undefined;
+            const errorValue = error && typeof error === 'object'
+                ? error
+                : undefined;
             emitTrace('model_end', {
                 model: requestModel,
                 provider,
                 status: signal?.aborted ? 'aborted' : 'error',
                 code: typeof errorValue?.status === 'number'
                     ? `HTTP_${errorValue.status}`
-                    : (errorValue?.code ?? errorValue?.name ?? 'MODEL_ERROR'),
+                    : // 构造器名优先于 `name`:SDK 的 APIError 家族 err.name 恒为 'Error'(无信息量),
+                        // 构造器名才分得出 APIConnectionError(建连失败)/ APIError(流内报错)。
+                        (errorValue?.code ??
+                            error?.constructor?.name ??
+                            errorValue?.name ??
+                            'MODEL_ERROR'),
+                // 取证用:错误文案与 cause 链上的 errno。没有这两项时,trace 只留一个 'Error',
+                // 事后无法判断到底是 DNS 失败、连接被拒还是 TLS 握手失败(实测踩过)。
+                message: typeof errorValue?.message === 'string' ? errorValue.message.slice(0, 300) : undefined,
+                causeCode: traceCauseCode(error),
                 durationMs: Date.now() - modelStartedAt,
             });
             throw error;

package/dist/context/token-calibration.js

@@ -2,11 +2,27 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
-const CACHE_VERSION = 1;
+// v2:引入 SUSPECT_* 可信区间。旧缓存里被口径不可比的 provider 砸到 MIN_CORRECTION
+// 下限、又被 clamp 住的条目(correction=0.5 且再不会有新样本去修正它)会永久打对折
+// 所有显示数字,只能整表作废——丢掉的是几十个样本,重学只要几步。
+const CACHE_VERSION = 2;
 const EWMA_ALPHA = 0.2;
 const MIN_CORRECTION = 0.5;
 const MAX_CORRECTION = 2;
 const MAX_ENTRIES = 64;
+/**
+ * 可信样本区间(actual / estimated)。超出即**不并入 EWMA**。
+ *
+ * 为什么需要这道闸:估算器的任务只是「别让请求溢出窗口」,它允许偏高;而 usage 是
+ * provider 报的账,两者本该同量级(本机 40+ 会话实测 est/actual 落在 0.33–1.66)。
+ * 一旦某个 gateway/model 的 usage 口径不可比(实测踩过:localhost 网关的 thinking 模型
+ * 报 20.8 chars/token,同机其它 provider 全是 1.3–3.3),ratio 会直接砸到 MIN_CORRECTION
+ * 下限并被 clamp 住——之后 correction 恒为 0.5,**每个乘以它的显示数字都被无谓地打对折**
+ * (压缩行 40% vs 底栏 80%,用户看到的两个数都不是真值)。这种样本学不出有用信息,
+ * 只会污染 UI;丢掉它,correction 保持上一次可用值(或 1)。
+ */
+const SUSPECT_MIN_RATIO = 0.3;
+const SUSPECT_MAX_RATIO = 3.5;
 let cache;
 const toolFingerprints = new WeakMap();
 function cachePath() {
@@ -75,7 +91,8 @@ export function getTokenCalibration(baseURL, model, tools) {
     const entry = readCache().entries[calibrationKey(baseURL, model, tools)];
     return validEntry(entry) ? { correction: entry.correction, samples: entry.samples } : { correction: 1, samples: 0 };
 }
-/** 用一次真实 prompt usage 更新 EWMA；只落比例和样本数，不保存任何消息内容。 */
+/** 用一次真实 prompt usage 更新 EWMA；只落比例和样本数，不保存任何消息内容。
+ *  样本与估算器差到 SUSPECT_* 区间之外时判为 provider 口径异常，直接丢弃(不改 correction)。 */
 export function updateTokenCalibration(baseURL, model, tools, estimatedTokens, actualTokens) {
     if (estimatedTokens <= 100 ||
         actualTokens <= 100 ||
@@ -83,6 +100,10 @@ export function updateTokenCalibration(baseURL, model, tools, estimatedTokens, a
         !Number.isFinite(actualTokens)) {
         return getTokenCalibration(baseURL, model, tools);
     }
+    const ratio = actualTokens / estimatedTokens;
+    if (ratio < SUSPECT_MIN_RATIO || ratio > SUSPECT_MAX_RATIO) {
+        return getTokenCalibration(baseURL, model, tools);
+    }
     const key = calibrationKey(baseURL, model, tools);
     const store = readCache();
     const previous = store.entries[key];

package/dist/i18n/index.js

@@ -186,10 +186,12 @@ const zhCN = {
     'status.measured': '实测',
     'status.estimated': '估算',
     'status.messages': '{count} 条消息',
+    'status.providerMeasured': 'provider 上一步实测 {tokens}:{pct}%',
     'agent.sending': '发送中…  (任意键 / Esc / Ctrl+C 撤回)',
     'agent.thinking': '思考中',
     'agent.generating': '生成 {tool}',
     'agent.executing': '执行 {tool}',
+    'agent.retrying': '连接异常，{seconds}s 后重试（第 {attempt} 次）',
     'agent.noReply': '(无回复)',
     'agent.maxSteps': '达到最大步数({count})，本轮停止。',
     'agent.aborted': '(已中断)',
@@ -515,10 +517,12 @@ const en = {
     'status.measured': 'measured',
     'status.estimated': 'estimated',
     'status.messages': '{count} messages',
+    'status.providerMeasured': 'provider measured {tokens} last step:{pct}%',
     'agent.sending': 'Sending…  (any key / Esc / Ctrl+C to recall)',
     'agent.thinking': 'Thinking',
     'agent.generating': 'Generating {tool}',
     'agent.executing': 'Running {tool}',
+    'agent.retrying': 'Connection lost, retrying in {seconds}s (attempt {attempt})',
     'agent.noReply': '(no reply)',
     'agent.maxSteps': 'Maximum steps reached ({count}); this turn has stopped.',
     'agent.aborted': '(aborted)',

package/dist/llm/index.js

@@ -107,7 +107,9 @@ export function isRetryableError(err, signal) {
     if (!err || typeof err !== 'object')
         return false;
     const e = err;
-    if (e.name === 'AbortError' || e.name === 'APIUserAbortError')
+    // SDK 的 APIError 家族不设 this.name(见下),判类别一律用构造器名。
+    const ctor = e.constructor?.name ?? '';
+    if (e.name === 'AbortError' || e.name === 'APIUserAbortError' || ctor === 'APIUserAbortError')
         return false;
     // OpenAI SDK APIError 走 status 分支(覆盖 4xx/5xx/429)
     const status = e.status;
@@ -118,23 +120,26 @@ export function isRetryableError(err, signal) {
             return true;
         return false;
     }
-    // Node 网络错 code(APIConnectionError 内部也会带一个)
-    const code = e.code;
-    if (code === 'ETIMEDOUT' ||
-        code === 'ECONNRESET' ||
-        code === 'ENOTFOUND' ||
-        code === 'EAI_AGAIN' ||
-        code === 'ECONNREFUSED' ||
-        code === 'EPIPE') {
+    // 证书 / 协议层不匹配是**永久性**错误,重试只会白等满退避(10 次≈两分钟)。
+    // 必须先于下面的宽兜底判定:fetch failed / cause 里的证书错文案都会被宽兜底捞走。
+    if (causeChainFrames(err).some((f) => (!!f.code && FATAL_TRANSPORT_CODE.test(f.code)) || (!!f.message && FATAL_TRANSPORT_MESSAGE.test(f.message))))
+        return false;
+    // Node 网络错 errno:顶层没有就沿 cause 链找(undici 把 errno 藏在 cause 里)。
+    if (causeChainFrames(err).some((f) => !!f.code && RETRYABLE_ERRNO.has(f.code)))
         return true;
-    }
-    // OpenAI SDK 的网络错类(无 status)
-    if (e.name === 'APIConnectionError' || e.name === 'APIConnectionTimeoutError')
+    // OpenAI SDK 的网络错类(无 status)。必须用**构造器名**:SDK 的 APIError 家族只做
+    // `super(message)`,从不设 this.name(`err.name` 恒为 'Error')—— 旧代码这里写
+    // `e.name === 'APIConnectionError'` 是永不命中的死分支,于是建连失败(DNS / 连接被拒 /
+    // TLS 握手 / 半路断流)一次即抛、整轮 run 直接终止(trace 里 model_end.code 只剩 'Error')。
+    if (ctor === 'APIConnectionError' || ctor === 'APIConnectionTimeoutError')
         return true;
-    // 兜底:错误信息里出现 timeout 字样(部分代理把错误折叠成普通 Error)
-    if (typeof e.message === 'string' && /\btime(d|ed)?\s*out\b|ETIMEDOUT/i.test(e.message)) {
+    // 兜底:文案。部分代理把错误折叠成普通 Error;SDK 的 APIConnectionError 默认文案就是
+    // 'Connection error.'(负载里没有任何细节,`code` 也为 undefined,只能靠文案兜)。
+    const msg = typeof e.message === 'string' ? e.message : '';
+    if (/\btime(d|ed)?\s*out\b|ETIMEDOUT/i.test(msg))
+        return true;
+    if (/^connection error\.?$/i.test(msg.trim()) || /\bfetch failed\b/i.test(msg))
         return true;
-    }
     return false;
 }
 /**
@@ -161,16 +166,54 @@ const STREAM_BREAK_CODES = new Set([
     'ERR_SOCKET_CONNECTION_TIMEOUT',
 ]);
 const STREAM_BREAK_MESSAGE = /premature close|other side closed|socket hang up|\bterminated\b|stream (?:closed|ended) (?:prematurely|unexpectedly)|econnreset|econnaborted/i;
-/** 沿 cause 链(≤3 层)找「连接被掐断」的信号;命中即认为响应流非正常结束。 */
-function hasStreamBreakSignal(err, depth = 0) {
-    if (!err || typeof err !== 'object' || depth > 3)
-        return false;
-    const e = err;
-    if (typeof e.code === 'string' && STREAM_BREAK_CODES.has(e.code))
-        return true;
-    if (typeof e.message === 'string' && STREAM_BREAK_MESSAGE.test(e.message))
-        return true;
-    return hasStreamBreakSignal(e.cause, depth + 1);
+/**
+ * 「连接层」可重试 errno。与 STREAM_BREAK_CODES 的区别:这些在**建连/发请求**阶段就失败
+ * (DNS 解析、拒绝连接、路由不可达、连接超时),压根没有响应流可言,但处置一样 —— 重试。
+ * 旧实现只在顶层 `err.code` 上查,而 undici 把 errno 埋在 cause 里,永远查不到。
+ */
+const RETRYABLE_ERRNO = new Set([
+    'ETIMEDOUT',
+    'ECONNRESET',
+    'ENOTFOUND',
+    'EAI_AGAIN',
+    'ECONNREFUSED',
+    'EPIPE',
+    'ECONNABORTED',
+    'ENETUNREACH',
+    'EHOSTUNREACH',
+    'ERR_SOCKET_CONNECTION_TIMEOUT',
+    'UND_ERR_CONNECT_TIMEOUT',
+    'UND_ERR_SOCKET',
+]);
+/** 证书 / TLS 协议不匹配:重试必然再错,判死以免白等退避。 */
+const FATAL_TRANSPORT_CODE = /^(?:ERR_SSL|ERR_TLS|ERR_OSSL|UNABLE_TO_VERIFY|DEPTH_ZERO|SELF_SIGNED|CERT_|EPROTO)/;
+const FATAL_TRANSPORT_MESSAGE = /certificate|self[- ]signed|\bEPROTO\b|wrong version number|unsupported protocol/i;
+/**
+ * 沿错误自身与 cause 链(≤3 层)收集每层的 code / message。
+ *
+ * 为什么必须看 cause:undici 把底层 errno 挂在 cause 上(`TypeError: fetch failed` →
+ * cause `Error: read ECONNRESET`,code 在 cause 里),openai SDK 又把那次 fetch 失败再包一层
+ * `APIConnectionError({ cause })`(`core.mjs` 的 catch 分支)。只看顶层 `err.code` / `err.message`
+ * 永远是 undefined / 'Connection error.' —— 这正是这类故障长期无法被识别、无法重试的根因。
+ */
+function causeChainFrames(err) {
+    const frames = [];
+    let cur = err;
+    for (let depth = 0; depth <= 3; depth++) {
+        if (!cur || typeof cur !== 'object')
+            break;
+        const e = cur;
+        frames.push({
+            code: typeof e.code === 'string' ? e.code : undefined,
+            message: typeof e.message === 'string' ? e.message : undefined,
+        });
+        cur = e.cause;
+    }
+    return frames;
+}
+/** 错误链(含 cause)上是否存在「连接被掐断」的信号。 */
+function hasStreamBreakSignal(err) {
+    return causeChainFrames(err).some((f) => (!!f.code && STREAM_BREAK_CODES.has(f.code)) || (!!f.message && STREAM_BREAK_MESSAGE.test(f.message)));
 }
 /**
  * 判定「服务端在响应流中途报错 / 流被中途掐断」——HTTP 层已建连并开始流式返回(状态码 200),
@@ -186,8 +229,9 @@ function hasStreamBreakSignal(err, depth = 0) {
  * 这三类都不沾 → 被当成「不可重试的客户端请求错」一次即抛,整轮 run 直接终止。但它们的真实语义
  * 是「服务端/链路在生成到一半时挂了」,属瞬时故障,重试是正确处置(已实测同一会话更大 prompt 可成功)。
  *
- * 只认 APIError 本身,不认子类:APIConnectionError / APIConnectionTimeoutError 已由
- * isRetryableError 的 name 分支覆盖,而 APIUserAbortError 是用户中断、绝不能重试。
+ * 只认 APIError 本身,不认子类:APIConnectionError / APIConnectionTimeoutError 是**建连阶段**
+ * 失败,归 isRetryableError 的构造器名分支(它有 10 次 HTTP 层预算,更合适);而 APIUserAbortError
+ * 是用户中断,绝不能重试。
  * 判据用构造器名而非 instanceof:同进程若存在 openai 的多份模块实例(ESM/CJS 混载),
  * instanceof 会失配。
  *
@@ -424,7 +468,9 @@ function retryErrorCode(error) {
     const value = error;
     if (typeof value.status === 'number')
         return `HTTP_${value.status}`;
-    return value.code ?? value.name ?? 'RETRYABLE_ERROR';
+    // 优先构造器名:SDK 的 APIError 家族 `err.name` 恒为 'Error'(无信息量),
+    // 构造器名才区分得出是 APIConnectionError(建连失败)还是流内 APIError。
+    return value.code ?? value.constructor?.name ?? value.name ?? 'RETRYABLE_ERROR';
 }
 /** Bind chat dispatch, retries and built-in providers to one explicit runtime. */
 export function createChatTransport(runtime) {

package/dist/repl/status-bar.js

@@ -23,8 +23,20 @@ export function renderContextBar(history) {
     const W = 10;
     const filled = Math.round(pct * W);
     const bar = '█'.repeat(filled) + '░'.repeat(W - filled);
-    const src = contextState.lastUsage ? t('status.measured') : t('status.estimated');
     const k = (n) => `${Math.round(n / 1000)}k`;
+    // 标签必须描述**这个数字**是什么:本条 bar 恒为「对话内容」估算(dialog-only,不含
+    // system prompt / 工具 schema),与底栏用量条、80% 压力线都不是同一个数。
+    // 旧实现只要 lastUsage 存在就打「实测」,而显示的仍是估算值 —— 标签与数字对不上,
+    // 用户拿它跟底栏对账只会更困惑。改为:数字照旧标「估算」,把 provider 真正测到的
+    // prompt 并列出来,两者差多少一眼可见(差值本身就是 provider 口径是否可信的证据)。
+    const src = t('status.estimated');
+    const measured = contextState.lastUsage?.promptTokens;
+    const measuredNote = measured && measured > 0
+        ? ` · ${t('status.providerMeasured', {
+            tokens: k(measured),
+            pct: Math.round(Math.min(1, measured / win) * 100),
+        })}`
+        : '';
     const pctCol = pct >= DEFAULT_BUDGET_POLICY.pressureTriggerRatio ? ui.yellow : ui.accent;
     const lifecycle = contextState.lifecycleStats;
     const archived = computePruneStats(history);
@@ -36,7 +48,7 @@ export function renderContextBar(history) {
         ? `\n  lifecycle · live ${lifecycle.live} · referenced ${lifecycle.referenced} · digested ${lifecycle.digested} · stubbed ${lifecycle.stubbed}`
         : '\n  lifecycle · no active snapshot (run a tool-enabled turn first)';
     const archiveLine = `\n  archived tool results · ${archived.stubbed}`;
-    return `${ui.gray}[${pctCol}${bar}${ui.reset}] ${Math.round(pct * 100)}%  ${k(est)}/${k(win)} tokens · ${t('status.messages', { count: history.length })} (${src})${ui.reset}${artifactLine}${lifecycleLine}${archiveLine}`;
+    return `${ui.gray}[${pctCol}${bar}${ui.reset}] ${Math.round(pct * 100)}%  ${k(est)}/${k(win)} tokens · ${t('status.messages', { count: history.length })} (${src})${measuredNote}${ui.reset}${artifactLine}${lifecycleLine}${archiveLine}`;
 }
 /** 状态行用量条(精简版,进底栏):[bar] pct% k/k。
  * 必须**用全 prompt 估算**(消息 + 工具 schema + 尾部 ephemeral 注入),与压缩触发器
@@ -45,6 +57,8 @@ export function renderContextBar(history) {
  * 触发器用 `Math.max(rawTotal, total) >= 0.8 * window`,bar 也照搬:校正后和校正前
  * 哪个大取哪个,确保不会因 correction<1 而低估。ephemeral 文本由 agent/core 每步写入
  * contextState.ephemeralText(避免在 bar 里再读一次 notes.md)。
+ * 压缩行(compact.ts 的 compactionLogLine)已统一到同一口径:数字取裸估算、后缀带窗口
+ * 百分比,两者可直接对账——「底栏 80% 而压缩行 40%」这类口径分裂不再出现。
  *
  * /context 命令仍是 dialog-only(见 renderContextBar):它的设计意图是"我说了多少"而非
  * "还剩多少空间",两条职责分开。 */

package/dist/session/compact.js

@@ -559,6 +559,26 @@ async function defaultSummarize(older, focus, signal, runtime = defaultCompactio
     }
 }
 // ── 对外:compactHistory / maybeCompact ───────────────────────────────────
+/**
+ * 用户可见的上下文占用口径:**裸估算**(不乘 correction)。
+ *
+ * 为什么必须裸估算:触发判定用的就是它——session/scheduler.ts 的 80% 压力线比
+ * `Math.max(report.rawTotal, report.total)`(context/budget.ts scheduleActions),
+ * repl 底栏用量条也取 `max(raw, corrected)`(repl/status-bar.ts)。压缩行若打印校正后的值,
+ * 同一时刻 TUI 上就同时存在三个都叫 token 的数字(provider 实测 / 校正后 / 触发用裸估),
+ * 用户无从判断哪条线会触发 —— 实测踩过:底栏 80%、压缩行 40%,看起来「没到线却压了」。
+ * correction 只服务内部保留区尺寸估算(见 correctTokenEstimate 调用点),不再外泄成占用读数。
+ */
+function rawPromptTokens(history, activeTools) {
+    return estimatePromptTokens(history, activeTools, 1);
+}
+/** 压缩行统一格式:`● 标签  205214 → 28614 tokens  (80% → 11%)`。
+ * 百分比与数字同源(裸估算 / 窗口),让「凭什么这时压」在行内自证,不必回头翻代码。 */
+function compactionLogLine(label, before, after, window) {
+    const pct = (n) => `${Math.round((n / Math.max(1, window)) * 100)}%`;
+    return (`  ${ui.bold}${ui.accent}●${ui.reset} ${ui.accent}${label}${ui.reset}  ` +
+        `${ui.dim}${before} → ${after} tokens  (${pct(before)} → ${pct(after)})${ui.reset}\n`);
+}
 /**
  * 压缩 history(原地)。手动 /compact 与自动 maybeCompact 都走这里。
  * 不检查阈值——调用方(maybeCompact)决定是否调;/compact 直接调以强制压缩。
@@ -566,8 +586,8 @@ async function defaultSummarize(older, focus, signal, runtime = defaultCompactio
 export async function compactHistory(history, opts) {
     const state = opts.contextState ?? contextState;
     const activeTools = opts.tools ?? chatTools;
-    const estimateBefore = estimatePromptTokens(history, activeTools, state.correction);
-    state.lastEstimate = estimateBefore;
+    const estimateBefore = rawPromptTokens(history, activeTools);
+    state.lastEstimate = estimatePromptTokens(history, activeTools, state.correction);
     // 调用前就已中断(用户在上一步末尾按的 Ctrl+C):一步都别做,直接冒泡。
     // 不做完再抛是为了保证 history 完全未被触碰——abortRestore 才还原得干净。
     if (opts.signal?.aborted) {
@@ -688,12 +708,12 @@ export async function compactHistory(history, opts) {
             const single = groups[0];
             const userOnly = single.tools.length === 0 && single.assistant?.role === 'user';
             if (!userOnly && microcompactGroup(single)) {
-                const estimateAfter = estimatePromptTokens(history, activeTools, state.correction);
-                state.lastEstimate = estimateAfter;
+                const estimateAfter = rawPromptTokens(history, activeTools);
+                state.lastEstimate = estimatePromptTokens(history, activeTools, state.correction);
                 state.lastUsage = undefined;
                 if (!layout.isLastContentRowBlank())
                     layout.contentWrite('\n');
-                layout.contentWrite(`  ${ui.bold}${ui.accent}●${ui.reset} ${ui.accent}强制微压缩(单组)${ui.reset}  ${ui.dim}${estimateBefore} → ${estimateAfter} tokens${ui.reset}\n`);
+                layout.contentWrite(compactionLogLine('强制微压缩(单组)', estimateBefore, estimateAfter, opts.window));
                 return {
                     compacted: true,
                     summarized: false,
@@ -780,14 +800,14 @@ export async function compactHistory(history, opts) {
         history.length = 0;
         history.push(...rebuilt);
         (opts.runtime?.rollbackStore ?? defaultRollbackStore).pruneAfterCompaction(history);
-        const estimateAfter = estimatePromptTokens(history, activeTools, state.correction);
-        state.lastEstimate = estimateAfter;
-        state.lastUsage = undefined; // 压缩后旧 usage 失效,/context 改用校正估算
+        const estimateAfter = rawPromptTokens(history, activeTools);
+        state.lastEstimate = estimatePromptTokens(history, activeTools, state.correction);
+        state.lastUsage = undefined; // 压缩后旧 usage 失效,/context 改用估算
         // 压缩行与上一个工具批次摘要行之间补空行分隔(compact 在 core step 循环顶部触发,
         // 上一步的 batch 可能尚未 flush,缓冲末行仍是 ● 工具摘要行 → 两行黏在一起)。
         if (!layout.isLastContentRowBlank())
             layout.contentWrite('\n');
-        layout.contentWrite(`  ${ui.bold}${ui.accent}●${ui.reset} ${ui.accent}压缩上下文${ui.reset}  ${ui.dim}${estimateBefore} → ${estimateAfter} tokens${ui.reset}\n`);
+        layout.contentWrite(compactionLogLine('压缩上下文', estimateBefore, estimateAfter, opts.window));
         // 抖动保护:压缩后仍超阈 → 提示 /clear,不死循环
         if (estimateAfter >= opts.threshold * opts.window) {
             layout.contentWrite(`  ${ui.yellow}●${ui.reset} ${ui.yellow}压缩后仍超阈,可能存在超大单条;建议 /clear。${ui.reset}\n`);
@@ -811,13 +831,13 @@ export async function compactHistory(history, opts) {
         if (microcompactGroup(g))
             microcompactDone = true;
     }
-    const estimateAfter = estimatePromptTokens(history, activeTools, state.correction);
-    state.lastEstimate = estimateAfter;
+    const estimateAfter = rawPromptTokens(history, activeTools);
+    state.lastEstimate = estimatePromptTokens(history, activeTools, state.correction);
     state.lastUsage = undefined; // token 数已变,旧 usage 失效
     if (microcompactDone) {
         if (!layout.isLastContentRowBlank())
             layout.contentWrite('\n');
-        layout.contentWrite(`  ${ui.bold}${ui.accent}●${ui.reset} ${ui.accent}微压缩旧工具结果${ui.reset}  ${ui.dim}${estimateBefore} → ${estimateAfter} tokens${ui.reset}\n`);
+        layout.contentWrite(compactionLogLine('微压缩旧工具结果', estimateBefore, estimateAfter, opts.window));
         return {
             compacted: true,
             summarized: false,

package/package.json

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