mocode-ai 1.1.7 → 1.1.8

package/dist/tools/registry.js

@@ -2,7 +2,6 @@ import { builtinTools } from './builtins/index.js';
 import { beginPathMutation, beginWorkspaceMutation, endPathMutation, endWorkspaceMutation, getCurrentTurnMutationState, } from '../rollback/index.js';
 import { enforceSandbox } from '../sandbox/index.js';
 import { resolveResourceLockRequests, toolResourceLockManager } from './resource-lock.js';
-import { executeWithToolRetry } from './retry.js';
 import { validateToolArguments } from './validation.js';
 import { t } from '../i18n/index.js';
 import { isToolErrorOutput } from './result.js';
@@ -40,7 +39,6 @@ function rebuildTools() {
 const DEFAULT_CAPABILITIES = Object.freeze({
     effect: 'unknown',
     concurrency: 'serial',
-    retry: 'never',
 });
 export function findTool(name) {
     return tools.find((tool) => tool.name === name);
@@ -132,8 +130,8 @@ function executionErrorOutcome(name, error, startedAt, changedFiles) {
         durationMs: Date.now() - startedAt,
     };
 }
-/** One complete attempt: acquire/release locks and capture rollback independently. */
-async function executeToolAttempt(tool, args, signal, opts, notifyLockAcquired) {
+/** Execute one tool call while holding its declared locks and capturing rollback state. */
+async function executeToolOnce(tool, args, signal, opts) {
     const startedAt = Date.now();
     const capabilities = getToolCapabilities(tool);
     let mutationVersionBefore;
@@ -141,8 +139,7 @@ async function executeToolAttempt(tool, args, signal, opts, notifyLockAcquired)
     try {
         const requests = resolveResourceLockRequests(capabilities, args);
         return await toolResourceLockManager.withLocks(requests, signal, async () => {
-            if (notifyLockAcquired)
-                opts?.onLockAcquired?.(args);
+            opts?.onLockAcquired?.(args);
             const mutationBefore = getCurrentTurnMutationState();
             mutationVersionBefore = mutationBefore.version;
             // Transactional tools own their full write-set capture inside ChangeSet commit.
@@ -156,7 +153,7 @@ async function executeToolAttempt(tool, args, signal, opts, notifyLockAcquired)
                 : null;
             let raw;
             try {
-                raw = await tool.execute(args, { signal, dropContext: opts?.dropContext });
+                raw = await tool.execute(args, { signal });
             }
             finally {
                 if (pathCapture)
@@ -190,17 +187,6 @@ async function executeToolAttempt(tool, args, signal, opts, notifyLockAcquired)
         return executionErrorOutcome(tool.name, error, startedAt, changedFiles);
     }
 }
-function stableJson(value) {
-    if (Array.isArray(value))
-        return `[${value.map(stableJson).join(',')}]`;
-    if (value && typeof value === 'object') {
-        return `{${Object.entries(value)
-            .sort(([left], [right]) => left.localeCompare(right))
-            .map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`)
-            .join(',')}}`;
-    }
-    return JSON.stringify(value) ?? 'null';
-}
 /**
  * 结构化工具调度入口。永不抛错；旧字符串工具在此归一化为 ToolOutcome。
  * 权限仍由 Agent 在展示工具头之前预检，保持现有交互时序。
@@ -226,21 +212,11 @@ export async function executeToolOutcome(name, argsRaw, signal, opts) {
         return terminalOutcome('error', validation.code, `错误:工具 ${name} 参数无效: ${validation.message}`, startedAt);
     }
     const args = parsed;
-    const fingerprint = `${name}\x00${stableJson(args)}`;
     const sandboxError = enforceSandbox(name, args);
     if (sandboxError) {
         return terminalOutcome('denied', 'SANDBOX_DENIED', sandboxError, startedAt);
     }
-    const capabilities = getToolCapabilities(tool);
-    try {
-        return await executeWithToolRetry(capabilities, fingerprint, signal, (attempt) => executeToolAttempt(tool, args, signal, opts, attempt === 1), opts?.onRetry);
-    }
-    catch (error) {
-        if (signal?.aborted || (error instanceof Error && error.name === 'AbortError')) {
-            return terminalOutcome('aborted', 'ABORTED', t('command.interrupted'), startedAt);
-        }
-        return executionErrorOutcome(name, error, startedAt, []);
-    }
+    return executeToolOnce(tool, args, signal, opts);
 }
 /** 字符串兼容入口：现有调用方、TUI 和 LLM history 无需同步迁移。 */
 export async function executeTool(name, argsRaw, signal, opts) {

package/dist/ui/layout.js

@@ -75,6 +75,10 @@ let scrollOffset = 0; // 滚动回看距尾行数(0=尾,跟随新内容);>0 时
 let scrollLockUntil = 0; // 发消息轮首滚动锁(绝对时间戳 ms,0=未锁):吸收 stdin 残留滚轮事件,防 resetScroll 回尾后被重新滚上去
 const SCROLL_LOCK_MS = 400; // 锁时长:覆盖 OS 缓冲残留 + 常规滚轮惯性;LLM TTFB 多 >200ms,不影响轮中后段滚动
 let base = null;
+// 运行态实时 token 用量(agent core 流式推送,轮末 repl 清 undefined)。
+// composeModelLine 在 RUNNING 态把它画成 chip 放 context 进度条左侧;
+// 不主动触发重画——RUNNING 态 turnTimer 200ms 心跳重画自然取最新值。
+let liveUsage;
 let statusText = '';
 let spinnerFrame;
 let turnStart = null; // RUNNING 态起点(Date.now());INPUT 态为 null。composeStatus 据此拼走时。
@@ -1394,14 +1398,18 @@ function composeModelLine(status, cols) {
         + hintW
         + ((hintPart && tokChip) ? sepHT.length : 0)
         + tokW;
-    // 右段:ctx + sep + cwd,右端对齐。cwd 按预算截断,极窄(<6)隐藏。
+    // 右段:实时用量 chip(仅 RUNNING)+ ctx + sep + cwd,右端对齐。cwd 按预算截断,极窄(<6)隐藏。
+    // 实时 chip 放 context 进度条左侧:本轮累计 ↑prompt ↓completion,流式实时增长。
     // 任一 chip 极宽时收紧 cwd(toolbar 列挤压场景),先从 cwd 砍、再隐藏 cwd、再按 hint→chip 顺序省。
+    const liveChip = mode === 'running' && liveUsage ? formatLiveUsageChip(liveUsage) : '';
+    const liveW = displayWidth(stripAnsi(liveChip));
+    const liveSepW = liveChip ? STATUS_SEP_W : 0;
     const minGap = 2;
-    let cwdBudget = cols - leftW - minGap - ctxW - STATUS_SEP_W - 1;
+    let cwdBudget = cols - leftW - minGap - liveW - liveSepW - ctxW - STATUS_SEP_W - 1;
     let cwd = cwdBudget >= 6 ? truncateDisplay(status.cwd, cwdBudget) : '';
     let cwdW = displayWidth(cwd);
-    let rightStr = `${ctx}${STATUS_SEP}${ui.dim}${cwd}${ui.reset}`;
-    let rightW = ctxW + STATUS_SEP_W + cwdW;
+    let rightStr = `${liveChip}${liveChip ? STATUS_SEP : ''}${ctx}${STATUS_SEP}${ui.dim}${cwd}${ui.reset}`;
+    let rightW = liveW + liveSepW + ctxW + STATUS_SEP_W + cwdW;
     // 极窄:逐步降级——先藏 hint,再藏 token chip,只剩 modeTag 与右段挤。
     // 这样 80 列宽终端下 hint 和 chip 都能稳住,只 <50 列才退化到只剩 modeTag。
     if (leftW + minGap + rightW > cols) {
@@ -1430,11 +1438,21 @@ function formatTurnTokenChip(usage) {
     const text = n < 1000 ? `${n}` : `${(n / 1000).toFixed(n >= 10000 ? 0 : 1)}k`;
     const cached = usage.cachedTokens ?? 0;
     const cacheTag = cached > 0
-        ? ` ↻${cached < 1000 ? cached : `${(cached / 1000).toFixed(cached >= 10000 ? 0 : 1)}k`}`
+        ? ` ↻ ${cached < 1000 ? cached : `${(cached / 1000).toFixed(cached >= 10000 ? 0 : 1)}k`}`
         : '';
     // chip 用 mid 灰(降优先级)— 模式仍是主色
     return `${ui.dim}${text} tokens${cacheTag}${ui.reset}`;
 }
+/** 运行态实时用量 chip(放 context 进度条左侧):↑计费prompt(裸-cached,与轮末摘要 (↑…) 同口径)
+ *  ↓completion,cache 命中带 ↻ 标记;缩写与轮末摘要 / 左侧 turn chip 同款。
+ *  流式期为估算值,每步末尾 usage chunk 到达后换实测;dim 灰降优先级,不与进度条阈值警示抢色。 */
+function formatLiveUsageChip(u) {
+    const fmt = (n) => (n < 1000 ? `${n}` : `${(n / 1000).toFixed(n >= 10000 ? 0 : 1)}k`);
+    const cached = u.cachedTokens ?? 0;
+    const billable = Math.max(0, u.promptTokens - cached);
+    const cacheTag = cached > 0 ? ` ↻ ${fmt(cached)}` : '';
+    return `${ui.dim}↑ ${fmt(billable)} ↓ ${fmt(u.completionTokens)}${cacheTag}${ui.reset}`;
+}
 /** spinner 行上方的「虚拟空行」(contentBottom+1)。
  *  - 有活跃 plan:显「plan: <summary> ▸ N. step」整行左对齐(yellow + dim)
  *  - 无活跃 plan:空(保留原分隔视觉,避免内容贴输入区)
@@ -1589,6 +1607,11 @@ export function clearLiveAtCursor() {
     frameRow = 0;
     frameCol = 0;
 }
+/** 推送 / 清空运行态实时 token 用量(agent core 流式推送;repl 轮末清 undefined)。
+ *  不触发重画:RUNNING 态 turnTimer 200ms 心跳重画状态行,自然取到最新值。 */
+export function setLiveUsage(u) {
+    liveUsage = u;
+}
 /** 更新状态行基线(模型 / context / cwd / 模式标识 / 活跃 plan chip / 本轮 token chip)。repl 在轮次边界与切模式时调。 */
 export function setStatusBase(b) {
     base = b;

package/dist/ui/render.js

@@ -318,6 +318,17 @@ export function summarizeToolCall(name, argsRaw) {
             return s('path') || truncateDisplay(argsRaw, 80);
         case 'run_command':
             return truncateDisplay(s('command') || argsRaw, 100);
+        case 'dev_server': {
+            const action = s('action');
+            const detail = s('command') || s('id') || s('readyUrl');
+            return truncateDisplay(detail ? `${action}  ·  ${detail}` : action || argsRaw, 100);
+        }
+        case 'browser': {
+            // 刻意不显示 fill 的 value:可能是密码等敏感输入。
+            const action = s('action');
+            const detail = s('url') || s('selector') || s('key') || s('sessionId');
+            return truncateDisplay(detail ? `${action}  ·  ${detail}` : action || argsRaw, 100);
+        }
         case 'glob':
             return s('pattern') || argsRaw;
         case 'grep': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocode-ai",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 16 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {
@@ -33,9 +33,9 @@
     "dotenv": "^16.0.0",
     "fast-glob": "^3.0.0",
     "openai": "^4.0.0",
+    "playwright": "1.62.1",
     "ws": "8.21.0"
   },
-  "optionalDependencies": {},
   "devDependencies": {
     "@types/node": "^22.0.0",
     "@types/ws": "8.5.13",

package/dist/agent/middleware/checklist.js

@@ -1,59 +0,0 @@
-// PROMPT-02: PreCompletionChecklistMiddleware.
-//
-// 在 agent 宣告完成(no tool calls + 有 candidate 正文)的那一刻,向 history
-// 推一条 user 消息,让模型再走一轮对 5 项 checklist 做显式确认 —— 这是
-// "硬关卡",与 PROMPT-01 的 4 阶段"软纪律"叠加。
-//
-// 关键约束:
-// - 纯函数(handler / buildUserMessage) → 易测、易 opt-out。
-// - 5 项 checklist 是稳定的字符串数组,fixture 可直接断言关键词。
-// - 复用 PROMPT-01 核心文本中的 "verification is a hard prerequisite" 锚点
-//   风格(不另起炉灶),但用单数第一人称直白的 checklist 措辞。
-// - 与 thrash-tracker 风格正交:trash 是 hint(LLM 仍可继续 retry),checklist
-//   是 gate(LLM 必须覆盖才能 done)。
-// - opt-out 显式:plan 模式 / 调用方传 `preCompletionChecklist: false`。
-/** 5 项 checklist 内容(稳定,fixture 直接断言)。措辞对齐 LangChain 实证。 */
-export const CHECKLIST_ITEMS = [
-    'Did I actually run a command/test/compile, or did I just re-read my own code?',
-    'Does the output match the original spec, not "what I thought I wrote"?',
-    'Did I exercise the boundary I claim to have covered (not just the happy path)?',
-    'Does the existing test suite still pass?',
-    'If I cannot verify, did I tell the user explicitly instead of pretending to be done?',
-];
-/**
- * 拼出 checklist user 消息。固定 5 项 + 硬规则;以 `[checklist]` 起头
- * 便于 LLM 识别为强制二次确认(也便于 eval fixture 关键字定位)。
- */
-export function buildChecklistUserMessage(modelFamily) {
-    const opener = modelFamily === 'anthropic'
-        ? 'Verification gate — you have not actually run a command that exercises the change against the spec. Before declaring done, answer each item below explicitly:'
-        : modelFamily === 'openai'
-            ? 'MANDATORY pre-completion checklist. You MUST address every item below before your final reply:'
-            : 'Pre-completion checklist — answer each item explicitly before declaring done:';
-    const items = CHECKLIST_ITEMS.map((item, i) => `${i + 1}. ${item}`).join('\n');
-    return `[checklist] ${opener}
-
-${items}
-
-Hard rule: "I read the code and it looks right" is not a completion signal. If you cannot run a verification, say so explicitly in your final reply. Do not paraphrase this checklist back as the answer — provide the actual evidence (which command, which output, which spec line it satisfied).
-
-Bonus (ASK-01): Before declaring done, also answer: am I guessing any fact the user did not state? If yes, surface the guess to the user in your final reply or call \`ask_human\` (within the per-turn budget) — never silently guess on a non-reversible choice.`;
-}
-/** 默认 trigger 条件:有 mutation + 没工具调用 + 验证未通过或没跑过 + 非 plan。 */
-export const defaultChecklistHandler = (ctx) => {
-    if (ctx.mode === 'plan')
-        return false;
-    if (!ctx.hadMutation)
-        return false;
-    // 已经通过验证:放行,不再二次确认(避免噪声)。
-    if (ctx.lastValidationStatus === 'passed')
-        return false;
-    return true;
-};
-export function createPreCompletionChecklistMiddleware() {
-    return {
-        handler: defaultChecklistHandler,
-        buildUserMessage: buildChecklistUserMessage,
-        items: CHECKLIST_ITEMS,
-    };
-}

package/dist/session/drop.d.ts

@@ -1,19 +0,0 @@
-import type { ChatMessage } from '../llm/index.js';
-import { estimateTokens } from '../llm/index.js';
-import type { DropContextFilter, DropContextResult } from '../tools/types.js';
-/**
- * 剔除历史里命中的旧 tool 结果(原地修改 history)。
- *
- * 筛选(各维度 AND 组合):
- *  - toolNames:只剔除这些工具名的结果(空 = 不限)
- *  - contains:只剔除内容包含所有这些词(AND、大小写不敏感)的结果(空 = 不限)
- *
- * 保护:history[0](system)+ 当前轮(最后一个 user 及其之后)永不剔除。
- * 已是存根的 tool 消息(含「已剔除」标记)不重复剔除(幂等)。
- *
- * 永不抛错;无匹配返 dropped=0。
- */
-export declare function dropContextFromHistory(history: ChatMessage[], filter: DropContextFilter): DropContextResult;
-/** 给 drop_context 工具结果格式化人类可读摘要(回灌给 agent)。 */
-export declare function formatDropResult(r: DropContextResult): string;
-export { estimateTokens };

package/dist/session/drop.js

@@ -1,93 +0,0 @@
-// 运行中上下文剔除(drop_context 工具的核心):把历史里无关的 tool 结果替换为存根。
-//
-// 与 compact 的区别:compact 是阈值触发的整体压缩(微截 + 摘要),drop_context 是 agent 主动、
-// 精准剔除"已判定无关"的具体 tool 结果——agent 检索到大量无关信息后主动调用,释放上下文。
-//
-// 不变量(对齐 compact.ts):
-//  - 永不动 history[0](system prompt)。
-//  - 永不动当前轮:从末尾向前找到最后一个 user 消息,该 user 及其之后的 tool 结果一律保留
-//    (agent 本轮还在用,踢了会丢失正在进行的上下文)。
-//  - tool_call_id 配对:只改 tool 消息的 content,不删消息、不动 tool_calls 数组结构、不改 id。
-//  - 原地修改 history(同 compact:length=0;push 重建,repl 持有同一引用)。
-//  - 永不抛错(对齐「调度器永不抛错」契约);无匹配 / 无可剔除 → 返 dropped=0。
-import { messageTokens, estimateTokens, } from '../llm/index.js';
-import { lastUserIndex, toText, toolNameOf } from '../context/utils.js';
-/**
- * 剔除历史里命中的旧 tool 结果(原地修改 history)。
- *
- * 筛选(各维度 AND 组合):
- *  - toolNames:只剔除这些工具名的结果(空 = 不限)
- *  - contains:只剔除内容包含所有这些词(AND、大小写不敏感)的结果(空 = 不限)
- *
- * 保护:history[0](system)+ 当前轮(最后一个 user 及其之后)永不剔除。
- * 已是存根的 tool 消息(含「已剔除」标记)不重复剔除(幂等)。
- *
- * 永不抛错;无匹配返 dropped=0。
- */
-export function dropContextFromHistory(history, filter) {
-    const toolNames = filter.toolNames && filter.toolNames.length > 0
-        ? new Set(filter.toolNames)
-        : null;
-    const contains = filter.contains && filter.contains.length > 0
-        ? filter.contains.map((s) => s.toLowerCase())
-        : null;
-    // 当前轮保护区:最后一个 user 及其之后一律保留(agent 还在用)。
-    const guard = lastUserIndex(history);
-    // guard <= 0 表示无 user 或 user 就是 history[0](不会):整段历史都可剔除(除 history[0])。
-    const protectedFrom = guard > 0 ? guard : 0; // < protectedFrom 的才可剔除(即 [1, protectedFrom)
-    const items = [];
-    let freedTokens = 0;
-    const STUB_PREFIX = '⌦[已剔除:与当前任务无关]';
-    for (let i = 1; i < protectedFrom; i++) {
-        const m = history[i];
-        if (m.role !== 'tool')
-            continue;
-        const content = toText(m.content);
-        // 幂等:已是存根(含标记)不重复剔除。
-        if (content.startsWith(STUB_PREFIX))
-            continue;
-        // 维度 1:工具名
-        const tname = toolNameOf(history, i);
-        if (toolNames && (!tname || !toolNames.has(tname)))
-            continue;
-        // 维度 2:内容关键词(AND)
-        if (contains) {
-            const lower = content.toLowerCase();
-            if (!contains.every((kw) => lower.includes(kw)))
-                continue;
-        }
-        // 命中 → 替换为存根(保 tool_call_id 不动,只改 content)
-        const before = messageTokens(m);
-        const id = m.tool_call_id ?? '';
-        const stub = `${STUB_PREFIX} 原 ${tname ?? 'tool'} 结果(${content.length} 字符,约 ${before} tokens)${id ? ` · id …${id.slice(-6)}` : ''}⌫`;
-        m.content = stub;
-        const after = messageTokens(m);
-        freedTokens += Math.max(0, before - after);
-        items.push({
-            toolName: tname ?? 'tool',
-            toolCallId: id.slice(-6),
-        });
-    }
-    return {
-        dropped: items.length,
-        freedTokens,
-        items,
-    };
-}
-/** 给 drop_context 工具结果格式化人类可读摘要(回灌给 agent)。 */
-export function formatDropResult(r) {
-    if (r.dropped === 0) {
-        return '未剔除任何工具结果(无匹配的旧 tool 消息,或均在当前轮保护区内不可剔除)。';
-    }
-    const lines = [
-        `已剔除 ${r.dropped} 条无关工具结果,释放约 ${r.freedTokens} tokens。`,
-        '被剔除项(已替换为存根,tool_call_id 配对不变):',
-    ];
-    for (const it of r.items) {
-        lines.push(`  - ${it.toolName} (id …${it.toolCallId})`);
-    }
-    lines.push('这些结果在后续上下文中仅保留存根标记,不再占用篇幅。');
-    return lines.join('\n');
-}
-// 供 drop_context 工具估算用(避免直接 import llm 的公开 API 造成耦合,这里重导出)。
-export { estimateTokens };

package/dist/tools/builtins/drop-context.d.ts

@@ -1,18 +0,0 @@
-import type { Tool } from '../types.js';
-/**
- * 运行中上下文剔除工具:agent 检索到大量无关信息后,主动把历史里无关的 tool 结果替换为存根,
- * 释放上下文空间(保 tool_call_id 配对不变量,只改 content)。
- *
- * 与 compact 的区别:compact 是阈值触发的整体压缩(微截 + 摘要);drop_context 是 agent 主动、
- * 精准剔除"已判定无关"的具体 tool 结果。
- *
- * 保护:history[0](system)与当前轮(最后一个 user 及其之后)永不剔除——agent 还在用。
- * 已是存根的不重复剔除(幂等)。永不抛错。
- *
- * 筛选(各维度 AND 组合,全部可选;不传 = 剔除所有可剔除的旧 tool 结果):
- *  - toolNames:只剔除这些工具名的结果(如 ["grep","read_file"])
- *  - contains:只剔除内容包含所有这些词(AND、大小写不敏感)的结果
- *
- * plan 模式不禁用:纯上下文管理,无文件 / 命令副作用。
- */
-export declare const dropContextTool: Tool;

package/dist/tools/builtins/drop-context.js

@@ -1,68 +0,0 @@
-// ---------- drop_context ----------
-/**
- * 运行中上下文剔除工具:agent 检索到大量无关信息后,主动把历史里无关的 tool 结果替换为存根,
- * 释放上下文空间(保 tool_call_id 配对不变量,只改 content)。
- *
- * 与 compact 的区别:compact 是阈值触发的整体压缩(微截 + 摘要);drop_context 是 agent 主动、
- * 精准剔除"已判定无关"的具体 tool 结果。
- *
- * 保护:history[0](system)与当前轮(最后一个 user 及其之后)永不剔除——agent 还在用。
- * 已是存根的不重复剔除(幂等)。永不抛错。
- *
- * 筛选(各维度 AND 组合,全部可选;不传 = 剔除所有可剔除的旧 tool 结果):
- *  - toolNames:只剔除这些工具名的结果(如 ["grep","read_file"])
- *  - contains:只剔除内容包含所有这些词(AND、大小写不敏感)的结果
- *
- * plan 模式不禁用:纯上下文管理,无文件 / 命令副作用。
- */
-export const dropContextTool = {
-    name: 'drop_context',
-    description: [
-        'Drop (stub-replace) irrelevant OLDER tool results from history to free context.',
-        'COST-AWARE: ~300-token round-trip; only call if freed tokens clearly exceed it — i.e. MULTIPLE bulky results (e.g. a wide grep/read sweep of mostly-irrelevant hits), not a single small one or near done.',
-        'Never dropped: system prompt and the CURRENT turn (last user message onward). Idempotent. Filters AND-combine; omit both = drop all droppable. Returns dropped count, freed tokens, tool names.',
-    ].join(' '),
-    parameters: {
-        type: 'object',
-        properties: {
-            toolNames: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'Only drop results from these tool names (e.g. ["grep","read_file"]). Empty/omitted = no tool-name filter.',
-            },
-            contains: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'Only drop results whose content contains ALL of these keywords (AND, case-insensitive). Empty/omitted = no content filter.',
-            },
-        },
-        required: [],
-    },
-    async execute(args, ctx) {
-        const dropContext = ctx?.dropContext;
-        if (!dropContext) {
-            // 无注入(理论上不会:runAgentCore 总注入)。降级:不改 history,告知 agent。
-            return '错误:上下文剔除回调不可用(未由 agent 循环注入),无法剔除。';
-        }
-        const filter = {};
-        if (Array.isArray(args.toolNames)) {
-            filter.toolNames = args.toolNames
-                .filter((v) => typeof v === 'string' && v.length > 0)
-                .map((v) => String(v));
-        }
-        if (Array.isArray(args.contains)) {
-            filter.contains = args.contains
-                .filter((v) => typeof v === 'string' && v.length > 0)
-                .map((v) => String(v));
-        }
-        const result = dropContext(filter);
-        return result.dropped === 0
-            ? '未剔除任何工具结果(无匹配的旧 tool 消息,或均在当前轮保护区内不可剔除)。'
-            : [
-                `已剔除 ${result.dropped} 条无关工具结果,释放约 ${result.freedTokens} tokens。`,
-                '被剔除项(已替换为存根,tool_call_id 配对不变):',
-                ...result.items.map((it) => `  - ${it.toolName} (id …${it.toolCallId})`),
-                '这些结果在后续上下文中仅保留存根标记,不再占用篇幅。',
-            ].join('\n');
-    },
-};

package/dist/verification/diagnostics.js

@@ -1,108 +0,0 @@
-import { createRequire } from 'node:module';
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-const SUPPORTED_EXTENSIONS = new Set([
-    '.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs',
-]);
-async function loadTypeScript(root) {
-    const candidates = [];
-    try {
-        candidates.push(createRequire(path.join(root, 'package.json')).resolve('typescript'));
-    }
-    catch {
-        // Target project may not depend on TypeScript; fall back to mocode's installation.
-    }
-    try {
-        candidates.push(createRequire(import.meta.url).resolve('typescript'));
-    }
-    catch {
-        // A production install may intentionally omit the optional parser.
-    }
-    for (const candidate of [...new Set(candidates)]) {
-        try {
-            const loaded = await import(pathToFileURL(candidate).href);
-            return loaded.default ?? loaded;
-        }
-        catch {
-            // Try the next resolution root.
-        }
-    }
-    return null;
-}
-function severity(category, ts) {
-    if (category === ts.DiagnosticCategory.Error)
-        return 'error';
-    if (category === ts.DiagnosticCategory.Warning)
-        return 'warning';
-    return 'info';
-}
-/** Parse only changed TS/JS files; package-wide semantic checking remains V3. */
-export async function runChangedFileDiagnostics(root, changedFiles, inputFingerprint) {
-    const startedAt = Date.now();
-    const files = [...new Set(changedFiles)]
-        .map((file) => path.resolve(process.cwd(), file))
-        .filter((file) => SUPPORTED_EXTENSIONS.has(path.extname(file).toLowerCase()));
-    if (files.length === 0) {
-        return {
-            level: 'V1', status: 'skipped', adapter: 'typescript-parser', diagnostics: [],
-            output: 'No changed TypeScript or JavaScript files.', durationMs: Date.now() - startedAt,
-            skipReason: 'unsupported_files', inputFingerprint,
-        };
-    }
-    const ts = await loadTypeScript(root);
-    if (!ts) {
-        return {
-            level: 'V1', status: 'skipped', adapter: 'typescript-parser', diagnostics: [],
-            output: 'TypeScript parser is unavailable.', durationMs: Date.now() - startedAt,
-            skipReason: 'typescript_unavailable', inputFingerprint,
-        };
-    }
-    const diagnostics = [];
-    for (const file of files) {
-        let source;
-        try {
-            source = await readFile(file, 'utf8');
-        }
-        catch (error) {
-            diagnostics.push({
-                level: 'V1', source: 'typescript', severity: 'error', code: 'READ_FAILED',
-                file: path.relative(root, file), message: error instanceof Error ? error.message : String(error),
-            });
-            continue;
-        }
-        const result = ts.transpileModule(source, {
-            fileName: file,
-            reportDiagnostics: true,
-            compilerOptions: {
-                allowJs: true,
-                jsx: ts.JsxEmit.Preserve,
-                module: ts.ModuleKind.ESNext,
-                target: ts.ScriptTarget.Latest,
-            },
-        });
-        for (const item of result.diagnostics ?? []) {
-            const location = item.file && item.start !== undefined
-                ? item.file.getLineAndCharacterOfPosition(item.start)
-                : undefined;
-            diagnostics.push({
-                level: 'V1',
-                source: 'typescript',
-                severity: severity(item.category, ts),
-                code: item.code,
-                file: item.file ? path.relative(root, item.file.fileName) : path.relative(root, file),
-                line: location ? location.line + 1 : undefined,
-                column: location ? location.character + 1 : undefined,
-                message: ts.flattenDiagnosticMessageText(item.messageText, '\n'),
-            });
-        }
-    }
-    const failed = diagnostics.some((item) => item.severity === 'error');
-    const output = diagnostics.length === 0
-        ? `Parsed ${files.length} changed TypeScript/JavaScript file(s).`
-        : diagnostics.map((item) => `${item.file ?? '<unknown>'}:${item.line ?? 0}:${item.column ?? 0} TS${item.code ?? ''} ${item.message}`).join('\n');
-    return {
-        level: 'V1', status: failed ? 'failed' : 'passed', adapter: 'typescript-parser',
-        diagnostics, output, durationMs: Date.now() - startedAt, inputFingerprint,
-    };
-}

package/dist/verification/fingerprint.js

@@ -1,54 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readFileSync, statSync } from 'node:fs';
-import path from 'node:path';
-function sha256(value) {
-    return createHash('sha256').update(value).digest('hex');
-}
-function normalizeText(value, root) {
-    const normalizedRoot = path.resolve(root).replace(/\\/g, '/');
-    return value
-        .replace(/\u001b\[[0-9;]*m/g, '')
-        .replace(/\\/g, '/')
-        .replaceAll(normalizedRoot, '<root>')
-        .replace(/\r\n?/g, '\n')
-        .trim();
-}
-/** Fingerprint the relevant on-disk inputs, so rewriting identical content can reuse validation. */
-export function fingerprintFiles(root, files) {
-    const entries = [...new Set(files)].sort().map((file) => {
-        const absolute = path.resolve(process.cwd(), file);
-        const display = path.relative(root, absolute).replace(/\\/g, '/');
-        try {
-            const stat = statSync(absolute);
-            if (!stat.isFile())
-                return `${display}\0<${stat.isDirectory() ? 'directory' : 'other'}>`;
-            return `${display}\0${sha256(readFileSync(absolute))}`;
-        }
-        catch {
-            return `${display}\0<missing>`;
-        }
-    });
-    return sha256(entries.join('\n'));
-}
-export function fingerprintValidation(input) {
-    const diagnostics = [...input.diagnostics]
-        .map((item) => ({
-        source: item.source,
-        severity: item.severity,
-        code: item.code ?? '',
-        file: item.file ? normalizeText(item.file, input.root) : '',
-        line: item.line ?? 0,
-        column: item.column ?? 0,
-        message: normalizeText(item.message, input.root),
-        packageName: item.packageName ?? '',
-    }))
-        .sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
-    return sha256(JSON.stringify({
-        level: input.level ?? '',
-        status: input.status,
-        adapter: input.adapter ?? '',
-        command: input.command ? normalizeText(input.command, input.root) : '',
-        diagnostics,
-        output: diagnostics.length === 0 ? normalizeText(input.output ?? '', input.root) : '',
-    }));
-}