mingdao-harness 0.1.67 → 0.1.69

package/docs/QUALITY-REVIEW-0.1.68.md

@@ -0,0 +1,122 @@
+# MingDao-Harness v0.1.68 全面质量评估与分期优化方案（2026-08-28）
+
+四路独立只读审计（核心引擎 / CLI 与后台任务 / Web 与桌面壳 / 测试与质量基础设施）交叉完成，覆盖全部 56+ 源文件、12,023 行源码。本文档为评估结论与分期方案，**待方案敲定后再实施**。
+
+## 一、总评
+
+| 区域 | 评分 | 一句话结论 |
+|---|---|---|
+| 核心引擎 | **7.5/10** | 防御意识强（fail-closed、护栏、mtime 缓存），有 1 个高危计费缺陷与若干跨模块口径不一致 |
+| CLI 与后台任务 | **6.0/10** | 安全基线好（无命令注入、路径穿越基本防住），有 1 个确定性 bug 与成体系的并发写隐患 |
+| Web 与桌面壳 | **6.5/10** | 鉴权/转义/SSE 清理扎实；短板在 SSRF 目标校验、并发上限竞争、server.js 巨石 |
+| 测试与质量基础设施 | **6.9/10** | 4 套离线 e2e + 三平台 CI 优秀；缺覆盖率/运行时汇总/CHANGELOG，tsconfig 只覆盖 22/52 文件 |
+| **综合** | **≈6.8/10** | 功能成熟度高、安全基线好；主要债务集中在**结构（巨石文件）、并发正确性、工程化度量**三类 |
+
+体检指标：源码 12,023 行 / 最大单体 server.js 1267、cli.js 1166、index.html 1342；空 catch 83 处（多为刻意降级，需逐处甄别）；console.log 177 处；无 CHANGELOG；测试 ~445 组 ok()/738 条断言、全部离线、三平台 CI（Node 18/20/22 + Win + Mac）。
+
+## 二、问题总清单（合并去重，按严重度）
+
+### 🔴 高（必须修）
+
+| # | 区域 | 位置 | 问题 | 修复 | 工时 |
+|---|---|---|---|---|---|
+| H1 | 计费 | pricing.js:185-201 | 根级 `pricing.overrides.{input,output}` 只并入 offpeak 不传播 peak：高峰时段自定义价格按内置 peak 计价，费用护栏/前置预估口径失真且无信号 | overrides 传播到 peak（或文档化并加日志警告） | 0.5h |
+| H2 | 调度 | schedule.js:399-414 | **确定性 bug**：every 任务执行中 `pause` 会被 runSleeper 主循环无条件覆盖回 `pending`，暂停失效 | 读 cur2 后先检查 `paused/failed` 再落状态 | 0.3h |
+| H3 | 并发 | 全局（schedule/tasks/session/sync/session-index/sync-server 等 8 处） | 跨进程「读-改-写」无锁 + 共享固定 `.tmp` 名 → 丢更新/半写入 | 每文件锁（O_EXCL lockfile）+ tmp 名加 pid+随机后缀 | 1.5–2 人日 |
+| H4 | 数据安全 | config.js:59 / credentials.js:29 / update.js:75 / sync.js:315,325 / audit.js:42 | 关键状态非原子直写（与项目自身 tmp+rename 口径分裂）；credentials 含全部密钥，崩溃写一半即损坏 | 统一原子写工具函数（tmp+rename，密钥文件 0o600） | 0.5h |
+| H5 | 结构 | web/server.js:447-1210 | 30+ 路由单函数巨石，鉴权/业务/清理混排，难维护难测 | 拆 `src/web/routes/*.js` 按域聚合，SSE 独立文件 | 20–24h |
+
+### 🟠 中（应当修）
+
+| # | 区域 | 位置 | 问题 | 修复 | 工时 |
+|---|---|---|---|---|---|
+| M1 | 安全 | server.js:684-733,1122 | SSRF：自定义模型/sync 的 baseUrl 只验 http(s) 不验目标，可指向回环/云元数据/内网 | host 校验拒绝 loopback/私网/链路本地 + 超时/重定向限制 | 4h |
+| M2 | 并发 | server.js:812-836 | MAX_CONCURRENT 检查在 readBody 前，占位即删 → 并发瞬时超限 + 多份 40MB 缓冲 | inflight 计数绑定请求生命周期（进入++/finally--） | 3h |
+| M3 | 并发 | server.js:306,360,388 + session.js:36-48 | 会话文件 append 与 rewrite（compact）交错丢消息 | 按文件进程内 async mutex 串行化 | 4h |
+| M4 | 桌面 | server.js:1234-1266 + desktop/main.js | `runWebServer` 在 listen 成功前 resolve，端口被占黑屏反复 reload 无恢复 | Promise 包装 listen；桌面对 EADDRINUSE 重试或提示退出 | 3h |
+| M5 | 同步 | sync-server.js:109-123,228-267,451-457 | 限流表超限整表 clear（可被攻击重置全员限额）；devices/meta 读改写无锁；代理后 IP 桶共享 | 淘汰最旧而非 clear；按 ip+username+路由建桶；meta 互斥合并写；`server.maxConnections` | 4h |
+| M6 | 同步 | commands/sync.js:49-52 | `sync login` 密码走命令行参数（ps/history 泄露） | 一律隐藏输入/stdin | 0.3h |
+| M7 | 压缩 | cli.js:160-182 vs compact.js | 两份近似压缩实现已分叉：手动 /compact 无 `<conversation_summary>` 标记，自动增量压缩识别不了 → 重复压缩/格式漂移 | /compact 统一走 compactConversation（或注入同款标记） | 0.5h |
+| M8 | 口径 | memory.js:156,34 | journal 用 UTC 日期、appendMemory 硬编码 Asia/Shanghai，与 pricing.timezone 口径不一致 | 统一用 beijingParts()/配置时区 | 0.3h |
+| M9 | 内存 | fs-tools.js:26-36 | undo 备份无上限（每文件 10 份完整 Buffer，文件数不限） | 按文件数/总字节双上限 LRU 淘汰 | 0.5h |
+| M10 | 性能 | context.js:73-96 / cost-guard.js | 语义回收循环每次全量重算 totalOf（≤500×n）；todayCost 每步整文件解析 stats | 增量求和；stats 行级缓存/索引 | 0.5h |
+| M11 | 误杀 | schedule.js:150,165 | 用陈旧 PID `process.kill`，PID 复用会误杀无关进程 | kill 前校验 cmdline/nonce（同 daemonAlive）；终态清 pid | 0.2h |
+| M12 | 进程 | tasks.js:57-88 等 | worker/daemon spawn 无 `child.on('error')`，ENOENT/ARG_MAX 崩溃；worker 被 SIGTERM 时 MCP 子进程可能孤儿 | 补 error 监听 + 终态；确认 MCP 进程组归属 | 0.3h |
+| M13 | 结构 | cli.js:300-316 + 全文件 | 命令分发用「模块名≠命令名」字符串拼接 map；mcpFacade/offpeak/参数解析多处重复；死导入 | 显式命令→{module,handler} 映射；抽共享函数；删死代码 | 1 人日 |
+| M14 | UI | index.html:6,584-593,891-913 | CSP `unsafe-inline`；工具图标 map 三处重复；refreshCostBadge 与 refreshStatusBar 每 15s 双拉同接口 | JS 外置后收紧 CSP；图标表抽常量；合并一次拉取 | 6–8h（随 JS 外置） |
+
+### 🟡 低（顺手修）
+
+| # | 位置 | 问题 | 工时 |
+|---|---|---|---|
+| L1 | server.js:875-884 + index.html | 主「■ 停止」发 `{}` 中断所有任务（应记本任务 taskId） | 1h |
+| L2 | web-io.js:70-77 | `_activeTools` 被拒/中止条目泄漏（无界增长 + seq 错配） | 1h |
+| L3 | server.js:217-254 | pruneTasks 惰性 + built.error 早退漏清理；finished 即删 | 0.5h |
+| L4 | server.js:1011-1029 | fs-browse 可枚举任意绝对路径（限定基目录 + 不回传绝对路径） | 2h |
+| L5 | server.js:70-105 | 所有 POST 统一 40MB 整包内存（非 chat 接口降为 1MB） | 2h |
+| L6 | server.js:1249-1250 | 「0.0.0.0 无 token」告警文案与 trustedHost 行为不符 | 0.5h |
+| L7 | server.js:199,888-899 | draftText 单一全局槽多客户端互相覆盖 | 1h |
+| L8 | desktop/main.js:28-40 + server.js:203-215 | appLog/srvlog 两文件、O(n) 全量重写、512KB 断行截断 | 2h |
+| L9 | desktop/main.js:221-228 | 渲染崩溃只 reload 一次，无计数护栏/提示 | 1.5h |
+| L10 | autostart.js:40-58 | 端口硬编码 3820、登录 PATH 不可靠 | 0.3h |
+| L11 | schedule.js:41-43,102 | parseAt 非法日期回滚不校验；addSchedule 条件冗余 | 0.2h |
+| L12 | cli.js 8 处 / schedule.js:413 | 关键路径静默吞错（至少 MINGDAO_DEBUG 打 stderr） | 0.2h |
+| L13 | notify.js:19-30 | 转义启发式（spawn argv 已低风险，可结构化化） | 0.2h |
+
+### 🔵 工程化（测试/基础设施审计）
+
+| # | 项 | 问题 | 工时 |
+|---|---|---|---|
+| E1 | bench 未入 CI | 3 份基准不在 ci.yml；且 bench 有 Windows `new URL().pathname` 跨平台 bug | 1h |
+| E2 | 失败即中止 | smoke 首败即停、无全量坏点清单 → 迁 node:test 或逐段 try/catch 汇总 | 6–8h |
+| E3 | 无覆盖率 | 无 V8/c8 度量与门禁；mcp-presets/index 公共 API/credentials/permissions/config 边界用例缺失 | 10–12h |
+| E4 | tsconfig 覆盖不全 | 只覆盖 22/52 src 文件且 strict:false（漏 sync-server/web/credentials 等安全关键区） | 6–8h |
+| E5 | CHANGELOG 缺失 | 0.1.0→0.1.68 无变更日志；prepublishOnly 未跑 e2e-web/bench；发布流程人工 | 3–4h |
+
+## 三、分期实施方案
+
+> 原则：每期可独立发布、可回滚；高危与确定性 bug 一律放最前；结构重构后置并配足回归护栏（现有 94 项测试 + bench 全绿才准合入）。
+
+### Phase 1 —「质量加固」v0.1.69（≈2–3 天）✅ 已实施（2026-08-28）
+目标：修掉全部高严重度与低成本中危，零结构变动。实施项：H1 计费 overrides peak 传播（+回归断言）、H2 调度 pause 失效（postRunStatus 纯函数化 + 7 项 e2e）、H3/H4 原子写地基（新增 src/atomic-write.js：pid+随机 tmp、O_EXCL 文件锁+陈旧回收；config/credentials/update/sync/session/session-index/sync-server 全部原子化；schedule/tasks 读改写加锁）、M7 /compact 并入 compactConversation（force 模式）、M8 记忆日期统一配置时区、M9 undo 备份全局上限、M10 trim 增量求和 + todayCost mtime 缓存、M11 kill 前 PID 归属校验、M12 spawn error 监听、L1 主停止按钮带 taskId、L2 _activeTools 拒绝清理、L3 pruneTasks 年龄+数量双阈值、L6 告警文案、L2/L3/L11/L12 小修。
+- H1 计费 overrides peak 传播 + 测试断言
+- H2 调度 pause 失效 bug + e2e 回归
+- H3 并发地基：统一原子写工具（锁 + pid 随机 tmp）——先落 H4 的 5 个文件，再铺 schedule/tasks/session
+- M7 压缩双实现合并（/compact 走 compactConversation，保留用户提示文案）
+- M8 时区口径统一；M9 undo 上限；M10 性能小修；M11 PID 校验；M12 spawn error 监听
+- L1/L2/L3/L6/L11/L12/L13 顺手修
+- 验收：94 组测试 + 38 组 bench 全绿、tsc 0 错误、三平台 CI 过
+
+### Phase 2 —「结构治理」v0.2.0（≈4–6 天）
+目标：拆巨石、补安全短板，为后续演进铺路。
+- H5 server.js 拆 `src/web/routes/*.js`（chat/sessions/config/sync/schedule/skills/workspace/fs-browse 等）+ 共享中间件
+- M13 cli.js 命令分发重构 + REPL/worker 拆分 + 重复逻辑抽取
+- M14 index.html JS 外置 `app.js` + CSP 收紧（去 unsafe-inline）+ 图标表/双拉取去重
+- M1 SSRF 目标校验；M2 inflight 并发；M3 会话文件互斥；M4 listen Promise + 桌面端口重试
+- M5 sync-server 限流与 meta 互斥；M6 密码不再走参数
+- L4/L5/L7/L8/L9/L10
+- 验收：同上全绿 + 新增 API 契约测试（routes 拆分后每个域至少 3 条断言）+ 桌面端口占用重试实测
+
+### Phase 3 —「工程化纵深」v0.2.1（≈3–5 天）
+目标：把"质量"变成可度量、可持续的门禁。
+- E1 bench 入 CI + Windows 兼容；E2 node:test 迁移（或分段汇总）；E3 覆盖率接入 + 阈值门禁 + 安全关键模块补测；E4 tsconfig 全覆盖 + 收紧 strict
+- E5 CHANGELOG + preversion/postversion 自动化 + prepublishOnly 补 e2e-web/bench + 发布清单文档化
+- 遗留项：sync-server 独立安全测试（限流/认证/并发）、fs-browse 基目录、D3 崩溃护栏（若 Phase 2 未含）
+- 验收：CI 输出覆盖率报告；`npm run bench` 全绿；tsc strict 0 错误；CHANGELOG 自动生成首版
+
+### Phase 4 —「能力演进」v0.3.x（可选，按需启动）
+从《六份评估综合分析》（docs/EVALUATION-SYNTHESIS.md）与审计收敛出的长期项：
+- 跨平台沙箱补位（Windows Job Object / macOS seatbelt）
+- 记忆语义检索（node:sqlite + 简单相似度，保持零依赖）
+- WebUI 看板扩展（费用二级分账、按小时/天折线）
+- 评测基准扩充（压缩质量集、路由 100 条标注集、tokenizer V4 词表对拍）
+
+## 四、明确不做（保持零依赖与轻量定位）
+
+- 不引入 TypeScript 全量迁移 / 构建工具链 / 前端框架 / i18n 框架 / OpenTelemetry
+- 不引入 better-sqlite3 等外部数据库驱动（如需 SQLite 用 Node 22+ 内置 node:sqlite 且保持 Node≥18 回退路径）
+- 不做 A/B 双模型对比路由（与省钱目标矛盾）
+
+## 五、交付物与验收口径
+
+每期合入前必须满足：`npm test`（smoke 51 组）+ 三套 e2e（21/16/6）+ `npm run bench`（38 断言）+ `tsc` 全绿；涉及 Web/桌面改动额外要求 e2e-web 全绿与打包抽查。每期发布按既有流水线（npm → 桌面 CI → 官网 feed → 镜像 Release 正文），桌面版统一官网分发。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mingdao-harness",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "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/atomic-write.js

@@ -0,0 +1,74 @@
+// 原子写与跨进程互斥（质检 H3/H4：并发写地基）。
+// 背景：守护进程、CLI、web 服务器同时写 ~/.mingdao 下同一批文件，
+// 此前 read-modify-write 无锁 + 多进程共享固定 `target + '.tmp'` 临时名，
+// 存在丢更新与"rename 到对方半截文件"的成体系隐患；config/credentials 等关键文件更是直写。
+// 本模块提供两个原语：
+//   1. atomicWriteFileSync —— tmp 名含 pid+随机后缀（跨进程绝不共名），写完 rename 原子替换；
+//   2. withFileLockSync —— O_EXCL lockfile 互斥（带超时与陈旧锁回收），包裹读-改-写序列。
+// 零依赖：仅 node:fs / node:path / node:crypto / Atomics.wait。
+
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+export function atomicWriteFileSync(target, data, options = {}) {
+  const dir = path.dirname(target);
+  const tmp = path.join(dir, `.${path.basename(target)}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`);
+  try {
+    fs.writeFileSync(tmp, data, options);
+    fs.renameSync(tmp, target);
+  } catch (err) {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {}
+    throw err;
+  }
+}
+
+export function atomicWriteJsonSync(target, value, { mode = 0o600 } = {}) {
+  atomicWriteFileSync(target, JSON.stringify(value, null, 2) + '\n', { mode });
+}
+
+// 极简互斥锁：O_EXCL 创建 lockfile；持锁期间执行 fn（同步）；异常/完成释放。
+// 进程崩溃遗留的陈旧锁（> staleMs 未更新）自动回收，避免永久卡死。
+const sleepBuf = new Int32Array(new SharedArrayBuffer(4));
+const sleepMs = (ms) => Atomics.wait(sleepBuf, 0, 0, ms);
+
+export function withFileLockSync(lockPath, fn, { timeoutMs = 5000, staleMs = 15000 } = {}) {
+  fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+  const t0 = Date.now();
+  for (;;) {
+    try {
+      const fd = fs.openSync(lockPath, 'wx'); // 独占创建
+      try {
+        fs.writeSync(fd, JSON.stringify({ pid: process.pid, at: Date.now() }));
+      } finally {
+        fs.closeSync(fd);
+      }
+      try {
+        return fn();
+      } finally {
+        try {
+          fs.unlinkSync(lockPath);
+        } catch {}
+      }
+    } catch (err) {
+      if (err.code !== 'EEXIST') throw err;
+      try {
+        const st = fs.statSync(lockPath);
+        if (Date.now() - st.mtimeMs > staleMs) {
+          try {
+            fs.unlinkSync(lockPath);
+          } catch {}
+          continue; // 回收陈旧锁后立即重试
+        }
+      } catch {
+        continue; // 锁文件刚被释放
+      }
+      if (Date.now() - t0 > timeoutMs) {
+        throw new Error(`获取文件锁超时（${lockPath}），可能存在其他进程长时间占用`);
+      }
+      sleepMs(25);
+    }
+  }
+}

package/src/cli.js

@@ -8,15 +8,11 @@ import path from 'node:path';
 import readline from 'node:readline';
 import { loadConfig, saveConfig, runWizard, ensureHome, mingdaoHome } from './config.js';
 import { modelPreset, PROVIDERS } from './models.js';
-import {
-  loadCredentials,
-  setStoredKey,
-  removeStoredKey,
-  maskKey,
-  credentialsPath,
-  getStoredKey,
-} from './credentials.js';
+import { maskKey, getStoredKey } from './credentials.js';
 import { createProvider, resolveProviderConfig, helperProvider } from './providers/index.js';
+import { compactConversation } from './compact.js';
+import { makeTokenCounter } from './tokenizer.js';
+import { messageTokens } from './context.js';
 import { startMcpServers } from './mcp.js';
 import { startTask, listTasks, patchTask, killTask, formatTaskRow } from './tasks.js';
 import { enableAutostart, disableAutostart, autostartStatus, autostartPath } from './autostart.js';
@@ -157,30 +153,6 @@ async function generatePlan(provider, modelName, task) {
   return res.text || null;
 }
 
-async function compactContext(provider, modelName, messages) {
-  const mid = messages.slice(1, -2);
-  const res = await provider.chat({
-    model: modelName,
-    messages: [
-      {
-        role: 'system',
-        content:
-          '你是上下文压缩器。把以下对话历史压缩成要点摘要（中文 ≤600 字）：保留未完成任务、关键决策、文件改动、用户偏好；省略已完成的中间过程。',
-      },
-      {
-        role: 'user',
-        content: mid
-          .map((m) => `${m.role}: ${m.content ?? JSON.stringify(m.tool_calls ?? '')}`)
-          .join('\n'),
-      },
-    ],
-    tools: [],
-    temperature: 0.2,
-    maxTokens: 2048,
-  });
-  return res.text || '';
-}
-
 // —— 后台任务 worker：独立进程执行一轮任务并写状态文件 ——
 async function runWorkerTask(id, question, { permission, model, offpeak }) {
   const home = ensureHome();
@@ -643,9 +615,12 @@ async function main() {
         stdio: 'ignore',
         env: process.env,
       });
+      child.on('error', (err) => io.print(style(`[WebUI 自启失败] ${err?.message || err}（可手动运行 mingdao web ${cfg.web?.port || 3820}）`, C.red)));
       child.unref();
       io.print(style(`🌐 WebUI 后台启动中：http://127.0.0.1:${cfg.web?.port || 3820}（关闭自动启动：mingdao web --no-autostart）`, C.dim));
-    } catch {}
+    } catch (err) {
+      io.print(style(`[WebUI 自启失败] ${err?.message || err}`, C.red)); // 质检 L6：不再静默吞掉
+    }
   }
 
   let session = null;
@@ -818,18 +793,33 @@ async function main() {
           continue;
         }
         io.startSpinner('正在压缩上下文…');
-        let summary = '';
+        let compacted = null;
         try {
-          summary = await compactContext(provider, modelName, messages);
+          const count = makeTokenCounter(modelName);
+          let total = 0;
+          for (const m of messages) total += messageTokens(m, count);
+          const budget = Math.max(1000, Math.round(total * 0.5)); // 手动触发：保留约 30% 尾部
+          compacted = await compactConversation({
+            messages,
+            budget,
+            count,
+            provider,
+            executorModel: modelName,
+            triggerRatio: 0,
+            force: true, // 手动意图明确：跳过最小裁剪门槛
+          });
         } catch (err) {
           io.print(style('[压缩失败] ' + (err?.message || err), C.red));
         }
         io.stopSpinner();
-        if (!summary) continue;
-        messages = [{ role: 'system', content: systemPrompt }, { role: 'user', content: '[此前对话摘要]\n' + summary }];
+        if (!compacted?.messages) {
+          io.print(style('未能压缩（被裁段落不足或摘要失败）。', C.dim));
+          continue;
+        }
+        messages = compacted.messages;
         appendMessages(session.file, [{ role: 'system', content: '── /compact 压缩点 ──' }, ...messages.slice(1)]);
         persisted = messages.length;
-        io.print(style('✓ 已压缩上下文（完整历史保留在会话文件中）。', C.green));
+        io.print(style(`✓ 已压缩上下文：${compacted.droppedCount} 条早期消息 → 摘要（回收约 ${compacted.droppedTokens} tokens）`, C.green));
       } else if (cmd === '/init') {
         const target = path.join(workingDir, 'AGENTS.md');
         if (fs.existsSync(target) && arg !== 'force') {

package/src/compact.js

@@ -54,7 +54,7 @@ export async function summarizeConversation(provider, model, convoText) {
   return { text: text.slice(0, SUMMARY_MAX_CHARS), usage };
 }
 
-export async function compactConversation({ messages, budget, count, provider, executorModel, triggerRatio }) {
+export async function compactConversation({ messages, budget, count, provider, executorModel, triggerRatio, force = false }) {
   if (!messages.length) return null;
   // 各消息 token 与总量；低于触发线（默认预算 80%）无需压缩
   const sizes = [];
@@ -77,10 +77,10 @@ export async function compactConversation({ messages, budget, count, provider, e
     keepTokens += sizes[i];
   }
   const droppedCount = boundary - 1; // 不含 system
-  if (droppedCount < MIN_DROP_MESSAGES) return null;
+  if (!force && droppedCount < MIN_DROP_MESSAGES) return null;
   let droppedTokens = 0;
   for (let i = 1; i < boundary; i++) droppedTokens += sizes[i];
-  if (droppedTokens < MIN_DROP_TOKENS) return null;
+  if (!force && droppedTokens < MIN_DROP_TOKENS) return null;
 
   // 被裁段落 → 文本（工具结果截断；tool_calls 带名称标注）
   const convoText = messages
@@ -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/config.js

@@ -6,6 +6,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { PROVIDERS, modelPreset, providerPreset } from './models.js';
 import { setStoredKey, resolveApiKey, maskKey } from './credentials.js';
+import { atomicWriteFileSync } from './atomic-write.js';
 
 export function mingdaoHome() {
   return process.env.MINGDAO_HOME || path.join(os.homedir(), '.mingdao');
@@ -56,7 +57,7 @@ export function ensureMinimalConfig() {
 export function saveConfig(cfg) {
   ensureHome();
   const p = configPath();
-  fs.writeFileSync(p, JSON.stringify(cfg, null, 2) + '\n', { mode: 0o600 });
+  atomicWriteFileSync(p, JSON.stringify(cfg, null, 2) + '\n', { mode: 0o600 }); // 质检 H4：原子写（tmp+rename）
   try {
     fs.chmodSync(p, 0o600);
   } catch {}

package/src/context.js

@@ -70,20 +70,28 @@ export function trimMessages(messages, budget, count = approxTokens) {
   // 最老 tool 消息 → 单行摘要；老 assistant 长文 → 前 200 字；逐条向新推进直到回到 80% 线。
   // 相比直接丢弃，被修改的只有前端旧消息——其后未被触碰的近期尾部字节保持不变，
   // 下一轮前缀缓存从首个未修改消息起继续命中（直接丢弃反而让整段前缀失配）。
-  if (totalOf(system) + totalOf(rest) > budget * 0.8) {
+  // 质检 M10：维护增量 total（替换消息后按新旧 token 差调整），不再每步全量重算（原 ≤500×n）。
+  const sysTokens = totalOf(system);
+  let total = sysTokens + totalOf(rest);
+  if (total > budget * 0.8) {
     const out = [...rest];
     for (let i = 0; i < out.length && i < 500; i++) {
-      if (totalOf(system) + totalOf(out) <= budget * 0.8) break;
+      if (total <= budget * 0.8) break;
       const m = out[i];
       const c = typeof m.content === 'string' ? m.content : JSON.stringify(m?.content ?? '');
+      let next = null;
       if (m.role === 'tool' && c.length > 40) {
-        out[i] = { ...m, content: `[工具 ${m.tool_call_id || ''} 结果摘要：${c.slice(0, 40).replace(/\n/g, ' ')}…（已回收，原 ${c.length} 字）]` };
+        next = { ...m, content: `[工具 ${m.tool_call_id || ''} 结果摘要：${c.slice(0, 40).replace(/\n/g, ' ')}…（已回收，原 ${c.length} 字）]` };
       } else if (m.role === 'assistant' && c.length > 200) {
-        out[i] = { ...m, content: c.slice(0, 200) + ` …[已回收，原 ${c.length} 字]` };
+        next = { ...m, content: c.slice(0, 200) + ` …[已回收，原 ${c.length} 字]` };
+      }
+      if (next) {
+        total += messageTokens(next, count) - messageTokens(m, count);
+        out[i] = next;
       }
     }
     // 回收后仍超预算 → 从尾部保留（必要时继续丢弃最老，清洗 tool 配对）
-    let total = totalOf(system);
+    total = sysTokens;
     const tail = [];
     for (let i = out.length - 1; i >= 0; i--) {
       const t = messageTokens(out[i], count);

package/src/cost-guard.js

@@ -3,7 +3,8 @@
 // 按北京时间自然日累计 cache-stats 实际费用（含 batch 半价与缓存折扣后的真实口径）。
 // Agent 每轮开始前检查：超 warn 线提醒、超 limit 且 action=block 时暂停执行。
 
-import { listCacheStats } from './cachestats.js';
+import fs from 'node:fs';
+import { listCacheStats, cacheStatsFile } from './cachestats.js';
 import { beijingDayStart } from './pricing.js';
 import { loadConfig } from './config.js';
 
@@ -11,14 +12,27 @@ export function costGuardConfig() {
   return loadConfig()?.costGuard || null;
 }
 
-// 今日（北京时间 0 点起）累计实际费用
+// 今日（北京时间 0 点起）累计实际费用。
+// 质检 M10：按 cache-stats 文件 mtime 缓存统计结果——文件未变直接复用，
+// 避免 Agent 每步对整文件（可能数千行）重复解析与累加。
+let todayCache = { mtime: -1, size: -1, start: 0, sum: 0 };
 export function todayCost() {
   const start = beijingDayStart().getTime();
-  let sum = 0;
-  for (const e of listCacheStats(100000)) {
-    if (e.at >= start) sum += Number(e.cost) || 0;
+  try {
+    const file = cacheStatsFile();
+    const st = fs.statSync(file);
+    if (st.mtimeMs === todayCache.mtime && st.size === todayCache.size && todayCache.start === start) {
+      return todayCache.sum;
+    }
+    let sum = 0;
+    for (const e of listCacheStats(100000)) {
+      if (e.at >= start) sum += Number(e.cost) || 0;
+    }
+    todayCache = { mtime: st.mtimeMs, size: st.size, start, sum };
+    return sum;
+  } catch {
+    return 0;
   }
-  return sum;
 }
 
 export function costGuardStatus() {

package/src/credentials.js

@@ -9,6 +9,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { mingdaoHome, ensureHome } from './config.js';
+import { atomicWriteFileSync } from './atomic-write.js';
 
 export function credentialsPath() {
   return path.join(mingdaoHome(), 'credentials.json');
@@ -26,7 +27,7 @@ export function loadCredentials() {
 export function saveCredentials(creds) {
   ensureHome();
   const p = credentialsPath();
-  fs.writeFileSync(p, JSON.stringify(creds, null, 2) + '\n', { mode: 0o600 });
+  atomicWriteFileSync(p, JSON.stringify(creds, null, 2) + '\n', { mode: 0o600 }); // 质检 H4：密钥文件原子写
   // mode 只在创建时生效：对已存在但权限过宽的文件强制收权
   try {
     fs.chmodSync(p, 0o600);