mingdao-harness 0.1.67 → 0.1.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mingdao-harness",
-  "version": "0.1.67",
+  "version": "0.1.68",
   "description": "MingDao Harness —— 开源智能体框架（Agent Harness）。零依赖、开箱即用，针对 DeepSeek-V4 系列优化，开放主流模型接入。",
   "type": "module",
   "bin": {
@@ -53,7 +53,8 @@
     "prepublishOnly": "node test/smoke.js && node test/e2e-local.js && node test/e2e-schedule.js",
     "desktop": "npm --prefix desktop start",
     "desktop:dist": "node scripts/sync-versions.mjs && npm --prefix desktop run dist:dir",
-    "desktop:sync": "node scripts/sync-versions.mjs"
+    "desktop:sync": "node scripts/sync-versions.mjs",
+    "bench": "node test/bench/bench-tokenizer.mjs && node test/bench/bench-routing.mjs && node test/bench/bench-compaction.mjs"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",

package/src/agent.js

@@ -2,7 +2,7 @@
 // → PostToolUse 钩子 → 结果回填 → 循环，直到模型给出纯文本回复。
 // 附带：子代理（task 工具）、todo 清单状态、undo 备份仓、Ctrl+C 中断。
 
-import { trimMessages, clampText } from './context.js';
+import { trimMessages, clampText, messageTokens } from './context.js';
 import { compactConversation } from './compact.js';
 import { toolSchemas, dispatch } from './tools/index.js';
 import { modelPreset } from './models.js';
@@ -11,7 +11,8 @@ import { createHooks } from './hooks.js';
 import { createIO, style, C } from './ui.js';
 import { subagentModel } from './routing.js';
 import { writeAudit, redactSecrets } from './audit.js';
-import { checkCostGuard } from './cost-guard.js';
+import { checkCostGuard, costGuardConfig, todayCost } from './cost-guard.js';
+import { estimateCost } from './pricing.js';
 
 const MAX_STEPS = 24;
 const SUBAGENT_MAX_STEPS = 12;
@@ -119,6 +120,8 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
     try {
     while (steps < stepLimit) {
       steps += 1;
+      // 同回合只读工具去重（Hermes C4）：相同 name+args 的只读调用只执行一次，结果复用回填
+      const turnToolCache = new Map();
       // 自动压缩（P3-1）：预算不足、静默裁剪即将丢弃早期段落时，先用 executor 模型
       // 把被裁段落压成摘要注入，替代「失忆」；失败/不值得时回退普通裁剪。
       if (cfg.autoCompact !== false) {
@@ -151,6 +154,39 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       }
       const trimmed = trimMessages(messages, budget, count);
 
+      // reasoning 回填防护（MiniMax P0-2）：推理链只在 UI 流式展示、不回传消息（本就不回填）；
+      // 防御性保证——任何携带 reasoning_content 的消息发送前裁剪：>4000 字仅留概括，>1000 字截尾 500。
+      let sanitized = trimmed;
+      for (const m of sanitized) {
+        const rc = m.reasoning_content;
+        if (typeof rc === 'string' && rc.length > 4000) {
+          sanitized = sanitized.map((x) => (x === m ? { ...x, reasoning_content: `[思考过程已省略（原 ${rc.length} 字）]` } : x));
+        } else if (typeof rc === 'string' && rc.length > 1000) {
+          sanitized = sanitized.map((x) => (x === m ? { ...x, reasoning_content: rc.slice(-500) + ' …[思考过程已截断]' } : x));
+        }
+      }
+
+      // 护栏前置预估（Kimi P2-E）：发送前按本轮最坏成本估算（trimmed prompt × 未命中输入价
+      // + maxOutput × 输出价，峰谷按当前时段）；「今日已用 + 最坏成本」超上限时发送前拦截，
+      // 而不是等 200K 上下文的贵请求发出后才 block。
+      if (cfg.costGuard) {
+        const g = costGuardConfig();
+        if (g && Number(g.dailyLimitYuan) > 0) {
+          let promptTokens = 0;
+          for (const m of sanitized) promptTokens += messageTokens(m, count);
+          const worst = estimateCost(modelName, promptTokens, maxOutput, null, new Date());
+          const used = todayCost();
+          if (used + worst >= Number(g.dailyLimitYuan)) {
+            stripOrphanCalls();
+            return {
+              text: null, reasoning: '', usage, steps, finish, truncated: false, aborted: false,
+              note: `⛔ 护栏前置拦截：本轮最坏成本 ≈¥${worst.toFixed(4)}，今日已用 ≈¥${used.toFixed(4)}，合计将超过上限 ¥${Number(g.dailyLimitYuan).toFixed(2)}——请求未发出。可调高 config.costGuard.dailyLimitYuan 或改用更小模型。`,
+              durationMs: Date.now() - startedAt, perf: perf(),
+            };
+          }
+        }
+      }
+
       // 费用护栏（A2）：每轮开始前按今日实际费用检查；block 时暂停本轮并明确告知
       if (cfg.costGuard) {
         const guard = checkCostGuard();
@@ -186,7 +222,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       try {
         res = await provider.chat({
           model: modelName,
-          messages: trimmed,
+          messages: sanitized,
           tools: [...toolSchemas(), ...mcpSchemas()],
           temperature,
           maxTokens: maxOutput,
@@ -299,14 +335,25 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
         }
 
         // 执行单个工具（渲染「执行中」→ dispatch → 捕获异常转错误结果）
+        // 审计 Hermes C4：同回合相同参数的只读工具（read/ls/glob/grep/skill）合并执行一次，
+        // 后续相同调用直接复用结果（仍逐个回填 tool 消息以保持 tool_call_id 配对）
         async function runTool(prep) {
           io.renderToolStart?.(prep.name, prep.args);
+          const dedupKey = !prep.isMcp && READONLY_TOOLS_SET.has(prep.name) ? prep.name + ':' + JSON.stringify(prep.args || {}) : null;
+          if (dedupKey && turnToolCache.has(dedupKey)) {
+            prep.cached = true;
+            return turnToolCache.get(dedupKey);
+          }
           try {
+            let result;
             if (prep.isMcp) {
               if (!mcp) throw new Error('MCP 工具未启用');
-              return await mcp.call(prep.name, prep.args);
+              result = await mcp.call(prep.name, prep.args);
+            } else {
+              result = await dispatch(prep.name, prep.args, ctx);
             }
-            return await dispatch(prep.name, prep.args, ctx);
+            if (dedupKey) turnToolCache.set(dedupKey, result);
+            return result;
           } catch (err) {
             return JSON.stringify({ ok: false, error: String(err?.message || err) });
           }
@@ -344,7 +391,8 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
             });
           }
           const text = typeof result === 'string' ? result : JSON.stringify(result); // 紧凑 JSON（评估 B3）：嵌套结果省 10-20% 回填 token，且下轮按 prompt 重复计费
-          messages.push({ role: 'tool', tool_call_id: prep.tc.id, content: clampText(text) });
+          const prefix = prep.cached ? '（与同回合相同调用结果一致，已复用）\n' : '';
+          messages.push({ role: 'tool', tool_call_id: prep.tc.id, content: prefix + clampText(text) });
         }
 
         let i = 0;

package/src/compact.js

@@ -99,16 +99,51 @@ export async function compactConversation({ messages, budget, count, provider, e
     .join('\n')
     .slice(0, INPUT_MAX_CHARS);
 
+  // —— 增量压缩（Kimi P2-D）：已压缩过的会话只压「旧摘要之后的新增段」，与旧摘要合并（摘要的摘要），
+  // 不再反复把早期内容送进摘要输入——第 N 次压缩输入从 O(历史) 降为 O(增量)。 ——
+  const sumIdx = messages.findIndex(
+    (m) => m.role === 'user' && typeof m.content === 'string' && m.content.includes('<conversation_summary>')
+  );
+  let incremental = false;
   let summary = null;
   let usage = null;
-  try {
-    const r = await summarizeConversation(provider, executorModel, convoText);
-    summary = r.text;
-    usage = r.usage;
-  } catch {
-    return null; // 摘要失败：退回普通裁剪
+  if (sumIdx > 0 && sumIdx + 1 < boundary) {
+    incremental = true;
+    const m = /<conversation_summary>\n([\s\S]*?)\n<\/conversation_summary>/.exec(String(messages[sumIdx].content));
+    const oldSummary = (m && m[1]) || '';
+    const newText = messages
+      .slice(sumIdx + 1, boundary)
+      .map((msg) => {
+        if (msg.role === 'tool') {
+          return `工具结果(${msg.tool_call_id ?? ''}): ${clampText(String(msg.content ?? ''), TOOL_OUTPUT_CAP)}`;
+        }
+        const head = msg.role === 'user' ? '用户' : msg.role === 'assistant' ? 'MingDao' : String(msg.role);
+        return `${head}: ${String(msg.content ?? '')}`;
+      })
+      .join('\n')
+      .slice(0, INPUT_MAX_CHARS);
+    try {
+      const r = await summarizeConversation(
+        provider,
+        executorModel,
+        `【既有摘要】\n${oldSummary.slice(0, SUMMARY_MAX_CHARS)}\n\n【新增对话记录】\n${newText}`
+      );
+      summary = r.text;
+      usage = r.usage;
+    } catch {
+      return null;
+    }
+    if (!summary) return null;
+  } else {
+    try {
+      const r = await summarizeConversation(provider, executorModel, convoText);
+      summary = r.text;
+      usage = r.usage;
+    } catch {
+      return null; // 摘要失败：退回普通裁剪
+    }
+    if (!summary) return null;
   }
-  if (!summary) return null;
 
   // 组装：system + 摘要(user) + 保留段（清洗保留段头部因裁剪而孤立的 tool 消息）
   const kept = cleanToolPairing(messages.slice(boundary));
@@ -123,5 +158,5 @@ export async function compactConversation({ messages, budget, count, provider, e
     },
     ...kept,
   ];
-  return { messages: next, droppedCount, droppedTokens, summary, usage };
+  return { messages: next, droppedCount: incremental ? boundary - (sumIdx + 1) : droppedCount, droppedTokens, summary, usage, incremental };
 }

package/src/routing.js

@@ -19,7 +19,7 @@ export function routingConfig(cfg) {
 }
 
 const PLAN_HINTS =
-  /设计|架构|重构|审查|规划|分析|方案|评估|优化|排查|疑难|设计模式|选型|技术债|roadmap|review|design|refactor|plan|architecture|方案设计|评审/;
+  /设计|架构|重构|审查|规划|分析|方案|评估|优化|排查|疑难|报错|怎么修|修复|设计模式|选型|技术债|roadmap|review|design|refactor|plan|architecture|方案设计|评审/;
 
 // 生成类任务（游戏/网页/文档等）需要大输出（planner 32K vs executor 8K），即使短句也路由 planner
 const GENERATION_HINTS =
@@ -28,7 +28,11 @@ const GENERATION_HINTS =
 export function heuristicRoute(text, rc) {
   const s = String(text ?? '');
   if (GENERATION_HINTS.test(s)) return rc.planner; // 生成类：大输出优先
-  if (s.length >= 40 && PLAN_HINTS.test(s)) return rc.planner;
+  if (PLAN_HINTS.test(s)) {
+    // 规划类关键词优先（审计：此前要求 length>=40，导致「设计一个缓存方案」这类
+    // 13 字短句被误路由到 flash 硬扛——关键词强度优先于文本长度）
+    return s.length >= 40 || /设计|规划|分析|评估|审查|架构|重构|方案|优化|报错|修复/.test(s) ? rc.planner : null;
+  }
   if (s.length <= 60) return rc.executor;
   return null; // 需要分类器
 }

package/src/tools/fs-tools.js

@@ -70,6 +70,13 @@ export function undo(args, ctx) {
   }
 }
 
+const READ_CACHE_MAX = 200; // 会话级 read 缓存条数上限（超出清最旧，防止无界增长）
+const readCache = new Map(); // 绝对路径 → { mtimeMs, size, lines }
+
+export function invalidateReadCache(p) {
+  readCache.delete(p);
+}
+
 export function read(args, ctx) {
   try {
     const p = resolvePath(ctx.cwd, args.path ?? '');
@@ -82,9 +89,24 @@ export function read(args, ctx) {
         error: `"${p}" 大小 ${(st.size / 1024 / 1024).toFixed(1)}MB，超过 ${MAX_FILE_BYTES / 1024 / 1024}MB 上限。请用 grep 搜索或 bash 分块查看。`,
       };
     }
+    // 重复读取去重（审计 MiniMax P2-2）：同一文件 mtime+size 未变且非强制重读时，
+    // 返回「内容未变化」标记（省下整段重复内容回填的 prompt token）；force=true 强制重读。
+    // 注意：带 offset/limit 的切片读取不能走缓存标记（必须返回所请求的切片）。
+    const wantsSlice = args.offset !== undefined || args.limit !== undefined;
+    const cached = readCache.get(p);
+    if (!args.force && !wantsSlice && cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size) {
+      return { ok: true, output: `[内容与上次读取一致（未变化，共 ${cached.lines} 行）——如需强制重读请传 force:true]`, totalLines: cached.lines, cached: true };
+    }
     const buf = fs.readFileSync(p);
     if (isProbablyBinary(buf)) return { ok: false, error: `"${p}" 疑似二进制文件，无法按文本读取。` };
     const lines = buf.toString('utf8').split('\n');
+    if (!wantsSlice) {
+      if (readCache.size >= READ_CACHE_MAX) {
+        const first = readCache.keys().next().value;
+        if (first !== undefined) readCache.delete(first);
+      }
+      readCache.set(p, { mtimeMs: st.mtimeMs, size: st.size, lines: lines.length });
+    }
     const offset = Math.max(1, Number(args.offset) || 1);
     const limit = Math.max(1, Number(args.limit) || 400);
     // 审计质量项：offset 超出文件行数时明确提示，而非返回空内容让模型误以为文件为空
@@ -125,6 +147,7 @@ export function write(args, ctx) {
     }
     fs.mkdirSync(path.dirname(p), { recursive: true });
     fs.writeFileSync(p, content);
+    invalidateReadCache(p);
     return { ok: true, output: `已写入 ${p}（${Buffer.byteLength(content)} 字节）。` };
   } catch (err) {
     return { ok: false, error: `写入失败：${err?.message || err}` };
@@ -163,6 +186,7 @@ export function edit(args, ctx) {
     const next = replaceAll ? text.split(oldString).join(newString) : text.replace(oldString, newString);
     backup(ctx, p);
     fs.writeFileSync(p, next);
+    invalidateReadCache(p);
     const idx = text.indexOf(oldString);
     const lineStart = text.slice(0, idx).split('\n').length - 1;
     const before = regionAround(text, lineStart, oldString.split('\n').length);

package/src/web/index.html

@@ -40,18 +40,18 @@ header select{flex:none}
 @media (max-width:860px){main{padding:14px 0 8px}#chat{padding:0 10px}#envBadge{display:none!important}#sessionSearch{max-width:110px}#modelSel{max-width:110px}#permSel{max-width:120px}#sessions{max-width:110px}#wsSel{max-width:96px}header{gap:6px;padding:8px 8px}header .logo span{display:none}}
 #sessionSearch:focus{outline:none;border-color:var(--accent2)}
 #tasksPanel{position:fixed;right:0;top:52px;bottom:0;width:280px;background:var(--bg2);border-left:1px solid var(--border);z-index:40;display:flex;flex-direction:column}
-/* 输入框上方工作状态条（审计：长任务静默硬伤——实时显示执行步数/耗时与后台任务数） */
-#workStatus{display:flex;align-items:center;gap:10px;padding:6px 14px;background:var(--panel);border-top:1px solid var(--border);font-size:12.5px;color:var(--dim);flex:none}
+/* 输入框上方工作状态条（审计：长任务静默硬伤——实时显示执行步数/耗时与后台任务数）。
+   与输入框同宽对齐（复用 #composer 的居中容器），不再横贯整个聊天窗口 */
+#workStatus{max-width:860px;margin:0 auto 4px;display:flex;align-items:center;gap:10px;padding:6px 14px;background:var(--panel);border:1px solid var(--border);border-radius:12px;font-size:12.5px;color:var(--dim);flex:none}
 #workStatus .ws-busy{color:var(--accent2);display:flex;align-items:center;gap:8px;flex:1;min-width:0}
 #workStatus .ws-bg{cursor:pointer;color:var(--warn);white-space:nowrap}
 #workStatus .ws-bg:hover{color:var(--text)}
-#workStatus .ws-stop{cursor:pointer;color:var(--err);font-weight:600;border:1px solid var(--err);border-radius:6px;padding:1px 10px;white-space:nowrap}
 /* 消息顶部轨迹行（DeepSeek-Harness 式：每轮可回溯步骤与子代理） */
 .msg-meta{display:flex;gap:8px;align-items:center;font-size:11.5px;color:var(--faint);padding:0 2px 4px}
 .trajBtn{cursor:pointer;background:var(--bg3);border:1px solid var(--border);color:var(--dim);border-radius:20px;padding:2px 10px;font-size:11.5px}
 .trajBtn:hover{color:var(--text);border-color:var(--accent2)}
-/* 轨迹面板（与任务面板互斥展示） */
-#trajPanel{position:fixed;right:0;top:52px;bottom:0;width:330px;background:var(--bg2);border-left:1px solid var(--border);z-index:40;display:flex;flex-direction:column}
+/* 轨迹面板（与任务面板互斥展示）：置于聊天窗口左侧（DSH 式侧栏） */
+#trajPanel{position:fixed;left:0;top:52px;bottom:0;width:330px;background:var(--bg2);border-right:1px solid var(--border);z-index:40;display:flex;flex-direction:column;box-shadow:4px 0 24px rgba(0,0,0,.35)}
 .tj-head{padding:12px 14px;font-size:14px;font-weight:600;border-bottom:1px solid var(--border);color:var(--accent2);display:flex;align-items:center;gap:8px}
 .tj-head button{margin-left:auto}
 #tjList{flex:1;overflow-y:auto;padding:8px}
@@ -775,10 +775,11 @@ async function send(){
     await handleEvents(resp.body, ev=>{
       if(ev.taskId) taskId=ev.taskId;
       if(ev.type==='ask') disarm(); else arm(); // 有活动→重置；权限等待→暂停计时
-      if(ev.type==='progress'){ const p=ev.seconds||0; if(think.parentNode) think.textContent='💭 正在工作 '+Math.floor(p/60)+' 分 '+Math.round(p%60)+' 秒 · 执行 '+ev.steps+' 步…'; renderWorkStatus(); }
+      if(ev.type==='progress'){ const p=ev.seconds||0; showThink(); think.textContent='💭 正在工作 '+Math.floor(p/60)+' 分 '+Math.round(p%60)+' 秒 · 第 '+msg._steps+' 回合 · 已执行 '+ev.steps+' 步…'; renderWorkStatus(); }
       if(ev.type==='text'){ onActivity(); raw+=ev.delta; update(); }
       else if(ev.type==='reasoning'){ if(!reason){ reason=addReasoning(msg); reason.dataset.full=''; } if(!reason.parentElement.open) reason.parentElement.open=true; reason.parentElement.querySelector('summary').classList.add('live'); reason.dataset.full+=ev.delta; const full=reason.dataset.full; reason.textContent=(full.length>9000?full.slice(-9000)+'\n…（思考内容较长，仅显示末尾；已 '+full.length+' 字符）':full); reason.scrollTop=reason.scrollHeight; scroll(); }
-      else if(ev.type==='turnStart'){ stepsCount+=1; curSteps+=1; msg._steps=curSteps; msg._traj.push({kind:'turn', t:Date.now()}); showThink(); renderWorkStatus(); scroll(); }
+      else if(ev.type==='turnStart'){ stepsCount+=1; curSteps+=1; msg._steps=curSteps; msg._traj.push({kind:'turn', t:Date.now()}); showThink(); think.textContent='💭 第 '+msg._steps+' 回合：模型推理中…'; renderWorkStatus(); scroll(); }
+      else if(ev.type==='turnEnd'){ showThink(); think.textContent='⏸ 第 '+msg._steps+' 回合完成（累计 '+(ev.toolSteps||0)+' 工具步）· 进入下一回合…'; renderWorkStatus(); }
       else if(ev.type==='toolStart'){ stepsCount+=1; curSteps+=1; msg._steps=curSteps; msg._traj.push({kind:'tool', seq:ev.seq, name:ev.name, args:ev.args, t:Date.now(), done:false}); onActivity(); update(); renderToolStartEvent(ev); renderWorkStatus(); }
       else if(ev.type==='code'){ onActivity(); const pre=document.createElement('pre'); pre.innerHTML='<code>'+highlight(ev.code,ev.lang)+'</code>'; insertBeforeActiveMsg(pre); scroll(); }
       else if(ev.type==='tool'){ onActivity(); update(); const pending=runningTools.get(ev.seq); if(pending){ pending.remove(); runningTools.delete(ev.seq); } const tj=msg._traj.find(x=>x.kind==='tool'&&x.seq===ev.seq); if(tj){ tj.done=true; tj.result=ev.result; tj.durationMs=ev.durationMs; tj.card=pending||null; } renderToolEvent(ev); }
@@ -801,13 +802,12 @@ function renderWorkStatus(){
   let html='';
   if(generating){
     const secs=curWorkT0?Math.round((Date.now()-curWorkT0)/1000):0;
-    html='<span class="ws-busy"><span class="spinner"></span>任务执行中：第 '+curSteps+' 步 · 已 '+Math.floor(secs/60)+' 分 '+Math.round(secs%60)+' 秒 — 完成后总结与交付物显示在本轮消息底部</span><span class="ws-stop">■ 停止</span>';
+    html='<span class="ws-busy"><span class="spinner"></span>任务执行中：第 '+curSteps+' 步 · 已 '+Math.floor(secs/60)+' 分 '+Math.round(secs%60)+' 秒 — 完成后总结与交付物显示在本轮消息底部（停止请用输入框右侧「■ 停止」按钮）</span>';
   } else if(bgRunning>0){
     html='<span class="ws-bg">🛠 '+bgRunning+' 个后台任务运行中 — 点击查看</span>';
   }
   el.style.display=html?'flex':'none';
   el.innerHTML=html;
-  const stop=el.querySelector('.ws-stop'); if(stop) stop.onclick=()=>abort();
   const bg=el.querySelector('.ws-bg'); if(bg) bg.onclick=()=>{ const tp=$('#tasksPanel'); tp.style.display = tp.style.display==='none'?'flex':'none'; if(tp.style.display==='flex'){ $('#trajPanel').style.display='none'; updateTasksPanel(); } };
 }
 // 轨迹元行：任务完成后附在本轮消息顶部（步数/子代理数，点击打开轨迹面板）

package/src/web/server.js

@@ -240,7 +240,7 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken
       try {
         send({ type: 'progress', seconds: Math.round((Date.now() - entry.startedAt) / 1000), steps: io?.stats?.().toolCount || 0 });
       } catch {}
-    }, 8000);
+    }, 5000);
     const userMessage = String(body.message ?? '').trim();
     entry.message = (userMessage || '[附件]').slice(0, 40);
     const visionSupported = Boolean(modelPreset(modelName)?.supportsVision || cfg.customModels?.[modelName]?.vision);

package/src/web/web-io.js

@@ -29,16 +29,21 @@ export function createWebIO({ send, askHandler, setAbortHandler }) {
       send({ type: 'banner', title, lines });
     },
     // 每轮生成开始/结束：前端据此显示持续的「正在思考…」动态指示
+    // 审计（阶段切换静默）：turnStart 带累计工具步数；stopSpinner 在回合真正结束时
+    // 发 turnEnd——客户端据此显示「第 N 回合完成，进入下一回合…」，阶段边界不再静默
     beginTurn() {},
     endTurn() {},
     startSpinner() {
       if (!io._turnActive) {
         io._turnActive = true;
-        send({ type: 'turnStart' });
+        send({ type: 'turnStart', toolSteps: io._toolCount });
       }
     },
     stopSpinner() {
-      io._turnActive = false;
+      if (io._turnActive) {
+        io._turnActive = false;
+        send({ type: 'turnEnd', toolSteps: io._toolCount });
+      }
     },
     writeText(t) {
       send({ type: 'text', delta: String(t) });