mingdao-harness 0.2.5 → 0.2.7

package/docs/EVALUATION-ROUND2.md

@@ -0,0 +1,58 @@
+# 六方技术评估 · 第二轮甄别与迭代方案（v0.2.5 → v0.2.6）
+
+> 2026-09-02。对 CodeBuddy / MiniMax / Kimi / OfficeACE / workbuddy / CodeArts Agent 六家对
+> MingDao Harness v0.2.5 的评估报告逐条对照真实代码甄别（每份报告均由独立子代理核实：
+> 文件+行号证据、区分「真实缺陷」与「过时/误判/空泛套话」）。已修复项随本轮提交 `20693ee`。
+
+## 一、本轮已修复（按严重度）
+
+### 崩溃类（0.2.2 教训：打包期无声、运行期爆炸）
+1. **域路由 400/403 双写崩溃【最高】**：C1 拆分后 `json()` 无返回值，`return json(...)` 被编排器视为「未处理」→ 兜底 404 对已结束响应二次写入 → Node 18 未捕获 write-after-end 整服务崩溃（CI ubuntu-18 腿连续红灯的真因，报告们误归因于 Windows）。修复：`json()` 返回 truthy。
+2. **reasoning_content 工具轮未完整回传**：DeepSeek thinking_mode 官方要求带 tool_calls 的 assistant 消息在后续请求中原样回传 reasoning_content，否则 400——多轮工具会话真实 API 必崩（mock 测试看不见）。修复：回填完整 reasoning；裁剪逻辑只对纯文本回复生效。
+3. **降级模型零校验**：`downgradeModel` 填错/跨服务商 → provider.chat 必然 400 终止回合。修复：校验同服务商，失败按 block 处理并给修复指引。
+4. **reasoning_effort 无门控**：全局配置发给不支持 reasoning 的模型 → 400。修复：仅 `supportsReasoning` 模型发送；`/think off` 改为显式 `thinking:{type:'disabled'}`（此前 off 无效，pro 默认思考开启）。
+
+### 安全类
+5. **SSRF 域名 DNS 重绑定绕过**：校验不解析域名。修复：`validateRemoteUrl` 对域名做 `dns.lookup` 全量 A/AAAA 复检；IPv6 字面量去括号归一（`[::1]`/`[::ffff:127.0.0.1]` 此前直接放行）。
+6. **readBody limit 形同虚设**：1MB 注释 vs 实际 40MB 全接口。修复：limit 参数生效 + 超限返回真 413（排水保留连接）+ 契约断言；chat 保留 40MB（附件 base64）。
+7. **project 级技能无指纹校验**：仓库投毒可直通提示词注入。修复：project 级同样校验 `.source.json` 指纹（无指纹的旧仓库不受影响）。
+8. **Windows fs-browse 白名单过宽**：家目录覆盖整个用户配置树（AppData）。修复：win32 收紧为 桌面/文档/下载 + 启动/工作目录 + 显式授权；路径比较大小写归一。
+
+### 省钱与正确性类
+9. **护栏在途费用失明**：长回合内统计文件不变，可烧穿日限。修复：回合内累计 usage 保守估算并入检查/前置拦截。
+10. **语义回收缺陷**：>80% 即回收（能塞下也截断丢内容）；回收窗口与被丢弃前缀不相交（白做）。修复：仅真超预算触发 + 按丢弃边界回收 + 只接受变短替换。
+11. **工具 Schema 会话内多次变化破坏前缀缓存**（三家共识）：每轮剥描述 + 只读阶段翻转 + MCP 晚到 → 前缀反复失配。**列入 v0.2.6 计划**（需要在线基准裁决收益，见下）。
+12. **英文任务只读死锁/误路由**：写意图与生成意图正则纯中文，英文会话整回合只读、生成任务落 8192 输出。修复：双语正则 + 路由标注集英文子集（113 条）。
+13. 杂项：PID 归属 `null`（无法校验）不再盲杀；SSE 尾字节并入 buf 统一行解析；原子写陈旧锁回收 TOCTOU 比对；tokenCache 整体清空改 LRU；`todayCost` 读失败返回 null + 一次性告警（不再静默归零）。
+
+### 质量基础设施
+14. CI 补跑 `api-contracts`（此前漏掉）；`run-all` spawn 加 error 监听 + Windows `npm.cmd`；e2e-web 越界用例改用系统目录（Windows %TEMP% 在家目录内的假阴性）。
+
+## 二、下一迭代（v0.2.6）方案
+
+**A. 前缀缓存稳定性（省钱核心，唯一需要「先测量再动手」的项）**
+- A1：会话内工具 Schema 两态冻结——回合首轮定档后恒定（不再逐轮剥描述/MCP 晚到突变），回合间才更新；
+- A2：MCP 预热：启动时 await 连接（带超时，超时本会话冻结工具集）；
+- A3：新建 `test/bench/bench-cost.mjs`——mock 模型费用对照（schema 收益、前缀命中、护栏拦截），把「48%/1/30/半价」营销数字变成可回归断言；
+- A4：`trimMessages` 前沿对齐（P1-1：轮重写头部消息导致前缀整体失配）——在 A3 基准下裁决是否采纳。
+
+**B. 会话与索引扩展**
+- B1：session-index 按会话名分片（>1000 会话时避免全量 JSON.parse）；
+- B2：常量单源化（MAX_CONCURRENT=8 实测值、200KB/5MB 附件上限去重，防 app.js/attachments.js/fs-tools.js 漂移）。
+
+**C. 桌面与 WebUI**
+- C1：面板推开布局（已随本次提交：轨迹/子代理/任务面板以 body class 推开内容区，≤560px 退化为全宽面板；附件行不再被遮挡）；
+- C2：app.js（88KB）原生 ES Modules 零构建拆分（可选，收益=可维护性）。
+
+**D. 文档与门禁**
+- D1：docs/QA-REPORT.md 断言数（14→60+）、CONFIG.md 补 `costGuard.action:'downgrade'`；
+- D2：CI 类型门禁统一为 tsconfig.full.json（现仍跑弱版 tsconfig.json 双轨）。
+
+**E. 缓做/不采纳（已甄别）**
+- sync-server 非 loopback 无 TLS 拒启（需 `--insecure` 逃生门，改行为需用户确认）；87 处空 catch 加 debug 开关（收益低，优先关键路径）；WebUI SPA 拆分；i18n；SQLite（需 Node≥22.5，破坏 18/20 兼容矩阵）；报告中的 roadmap 型空泛项（收益数字无测量依据）。
+
+## 三、验收门槛（防 0.2.2 式回归）
+1. 6 套测试全绿 + api-contracts 每域契约 + 新增 bench-cost 断言；
+2. strict 棘轮 0/0 不回升；覆盖率 ≥60% 门禁；
+3. **每次发版前 CI 打包冒烟（xvfb 真实运行打包产物主进程）**——已固化，不可省略；
+4. 新增「Node 18 兼容」意识：CI 已有 ubuntu-18 腿（本次双写崩溃即由它抓住），任何路由改动必须过该腿。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mingdao-harness",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "MingDao Harness —— 开源智能体框架（Agent Harness）。零依赖、开箱即用，针对 DeepSeek-V4 系列优化，开放主流模型接入。",
   "type": "module",
   "bin": {
@@ -54,7 +54,7 @@
     "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",
-    "bench": "node test/bench/bench-tokenizer.mjs && node test/bench/bench-routing.mjs && node test/bench/bench-compaction.mjs",
+    "bench": "node test/bench/bench-tokenizer.mjs && node test/bench/bench-routing.mjs && node test/bench/bench-compaction.mjs && node test/bench/bench-cost.mjs",
     "coverage": "node test/run-all.mjs --coverage && node scripts/coverage-report.mjs",
     "typecheck:strict": "node scripts/strict-ratchet.mjs",
     "preversion": "node test/smoke.js && node test/e2e-local.js && npm run bench",

package/skills/release-checklist/SKILL.md

@@ -11,13 +11,14 @@ description: 准备发布新版本、打包交付前使用
 2. **版本**：版本号统一（package.json / 配置 / 文档互相一致），遵循语义化版本。
 3. **变更说明**：changelog 用用户语言描述新增/修复/破坏性变更。
 4. **构建验证**：实际构建/打包一次，并在干净环境验证产物可安装可运行。
-5. **桌面版打包冒烟（0.2.2 事故护栏，发版必经）**：主进程模块求值必须真实跑通打包产物——
+5. **发布前自检（常设步骤，2026-09-02 起）**：不依赖外部评估报告，纯代码审查主动找 bug——重点覆盖本次改动的调用链、锁/并发、权限/安全、跨平台与「打包期无声、运行期爆炸」类边界；每一条发现必须给出**文件+行号证据并按严重度排序**（高危优先修，不可带着已知高危发布）。历史战例：v0.2.6 自检一次捞出 6 条（含外部六份评估全漏的 `schedule stop` 双守护进程 bug）与 2 条自改回归。
+6. **桌面版打包冒烟（0.2.2 事故护栏，发版必经）**：主进程模块求值必须真实跑通打包产物——
    - CI 已内置：desktop.yml 在 Linux 腿用 xvfb 运行 `dist/linux-unpacked/mingdao --no-sandbox`（`MINGDAO_DESKTOP_SMOKE=1`），模块求值通过输出 `MINGDAO_DESKTOP_SMOKE_OK` 并退出 0，否则 workflow 失败；
    - 本地有显示器时可加验：`cd desktop && MINGDAO_DESKTOP_SMOKE=1 dist/linux-unpacked/mingdao --no-sandbox`（AppImage 加 `--appimage-extract-and-run`）；
    - 教训：0.2.2 三平台启动即崩（main.js 顶层调用 createLogWriter 漏导入），打包期不报错、运行期才炸——静态护栏（test/smoke.js「桌面主进程静态护栏」组）与打包冒烟双保险。
-6. **敏感信息**：密钥、token、内网地址、个人信息不得进入仓库与产物（`grep -rE 'sk-[A-Za-z0-9]{20,}' .`）。
-7. **回滚方案**：明确如何回退到上一版本（旧包/旧 tag 可恢复）。
-8. **发布后冒烟**：发布完成后立即做一次端到端验证。
+7. **敏感信息**：密钥、token、内网地址、个人信息不得进入仓库与产物（`grep -rE 'sk-[A-Za-z0-9]{20,}' .`）。
+8. **回滚方案**：明确如何回退到上一版本（旧包/旧 tag 可恢复）。
+9. **发布后冒烟**：发布完成后立即做一次端到端验证。
 
 ## 桌面版发布流水线（官网分发 + 镜像 + 转运附件回收）
 

package/src/agent.js

@@ -13,6 +13,7 @@ import { subagentModel } from './routing.js';
 import { writeAudit, redactSecrets } from './audit.js';
 import { checkCostGuard, costGuardConfig, todayCost } from './cost-guard.js';
 import { estimateCost } from './pricing.js';
+import { resolveProviderConfig } from './providers/index.js';
 
 const MAX_STEPS = 24;
 const SUBAGENT_MAX_STEPS = 12;
@@ -45,15 +46,18 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
   // 省钱 B1（按需挂载）：回合起始为「只读阶段」时只发只读工具（read/ls/glob/grep/skill/todo）
   // + 已用过的工具；检测到写意图（用户消息或模型明说需要写/改/建）后注入全量工具。
   const READONLY_TIER_SET = new Set(['read', 'ls', 'glob', 'grep', 'skill', 'todo']);
-  const WRITE_INTENT_RE = /写|建|创|改|修|删|装|加|添|增|补|换|移|部署|执行|运行|实现|重构|生成|迁移|安装|更新|升级|发布|调整|优化|修复|提交|推送|打包|编译|测试/;
+  // 中英双语写意图（CodeArts 报告：纯中文正则让英文会话整回合只读死锁）
+  const WRITE_INTENT_RE = /写|建|创|改|修|删|装|加|添|增|补|换|移|部署|执行|运行|实现|重构|生成|迁移|安装|更新|升级|发布|调整|优化|修复|提交|推送|打包|编译|测试|implement|fix|create|modify|update|delete|deploy|build|make|generate|install|write|refactor|migrate|test|run|commit|push|remove|add|change|patch/i;
   const hasWriteIntent = (/** @type {any} */ text) => WRITE_INTENT_RE.test(String(text || ''));
-  const toolsFor = (/** @type {boolean} */ readOnlyPhase) => {
-    const schemas = buildToolSchemas(usedToolNames, mcpSchemas());
+  // A1（前缀稳定）：剥描述集合按「回合冻结快照」——回合内恒定（至多两态：只读档/全量档），
+  // 新使用的工具只在下一回合才进入剥描述集合；回合边界本身就有新 user 消息，schema 变化免费。
+  const toolsFor = (/** @type {boolean} */ readOnlyPhase, /** @type {Set<string>} */ strippedSet) => {
+    const schemas = buildToolSchemas(strippedSet, mcpSchemas());
     if (!readOnlyPhase) return schemas;
     return schemas.filter((/** @type {any} */ t) => {
       const n = t?.function?.name;
       if (!n) return true;
-      if (READONLY_TIER_SET.has(n) || usedToolNames.has(n)) return true;
+      if (READONLY_TIER_SET.has(n) || strippedSet.has(n)) return true;
       if (n.startsWith('mcp__')) return mcp ? mcp.isReadonly(n) : false;
       return false;
     });
@@ -142,6 +146,13 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
     // activeModel 是本回合实际使用的模型（分账/记录归属它），downgraded 保证只提示一次。
     let activeModel = modelName;
     let downgraded = false;
+    // 护栏在途费用（MiniMax P0）：本回合已累计 usage 的保守估算（无缓存折扣），
+    // 护栏检查/前置拦截时并入今日已用——否则长回合内统计文件不变，可烧穿日限。
+    const inFlightCost = () => estimateCost(activeModel, usage.prompt_tokens, usage.completion_tokens, null, new Date());
+    const usedTodayWithInflight = () => {
+      const today = todayCost();
+      return today == null ? null : today + inFlightCost();
+    };
     // 省钱 B1：本回合只读阶段判定——最新用户消息无写意图则先只发只读工具，
     // 模型明确表达写意图后（下一轮）注入全量。cfg.schemaTier=false 可关。
     let readOnlyPhase = true;
@@ -151,6 +162,8 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
     } else {
       readOnlyPhase = false;
     }
+    // A1：本回合的剥描述冻结快照（会话级 usedToolNames 的副本）——回合内 schema 字节不变
+    const turnStrippedSet = new Set(usedToolNames);
     // 整个回合注册一次 SIGINT：思考、工具执行、权限询问期间都能中断
     const offSigint = io.onSigint ? io.onSigint(() => { aborted = true; currentAc?.abort(); }) : () => {};
     const ctx = makeCtx();
@@ -197,14 +210,16 @@ 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。
+      // reasoning 回填防护（Kimi P0 修正）：带 tool_calls 的 assistant 消息必须「完整」回传
+      // reasoning_content（DeepSeek thinking_mode 官方要求：后续请求含 tools 时缺/截断即 400，
+      // 多轮工具会话必崩）；仅纯文本回复的 reasoning 可裁剪（不回传也不影响）。
       let sanitized = trimmed;
       for (const m of sanitized) {
         const rc = m.reasoning_content;
-        if (typeof rc === 'string' && rc.length > 4000) {
+        if (typeof rc !== 'string' || (Array.isArray(m.tool_calls) && m.tool_calls.length)) continue;
+        if (rc.length > 4000) {
           sanitized = sanitized.map((/** @type {any} */ x) => (x === m ? { ...x, reasoning_content: `[思考过程已省略（原 ${rc.length} 字）]` } : x));
-        } else if (typeof rc === 'string' && rc.length > 1000) {
+        } else if (rc.length > 1000) {
           sanitized = sanitized.map((/** @type {any} */ x) => (x === m ? { ...x, reasoning_content: rc.slice(-500) + ' …[思考过程已截断]' } : x));
         }
       }
@@ -219,8 +234,10 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           let promptTokens = 0;
           for (const m of sanitized) promptTokens += messageTokens(m, count);
           const worst = estimateCost(activeModel, promptTokens, maxOutput, null, new Date());
-          const used = todayCost();
-          if (used + worst >= Number(g.dailyLimitYuan)) {
+          const used = usedTodayWithInflight(); // 含本回合在途费用（防长回合烧穿）
+          if (used == null) {
+            // todayCost 读取失败：无法判断，跳过前置拦截（护栏主检查同样跳过并告警）
+          } else if (used + worst >= Number(g.dailyLimitYuan)) {
             stripOrphanCalls();
             return {
               text: null, reasoning: '', usage, steps, finish, truncated: false, aborted: false,
@@ -253,15 +270,29 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           }
           if (guard.downgrade && !downgraded) {
             if (guard.downgradeModel !== activeModel) {
-              activeModel = guard.downgradeModel;
-              downgraded = true;
-              io.print(style(guard.message, C.yellow));
+              // MiniMax P0：降级目标零校验会崩溃——必须与当前模型同服务商且已有 Key，
+              // 否则 provider.chat 必然 400；校验失败按 block 处理并给修复指引。
+              const curPc = resolveProviderConfig(cfg, activeModel);
+              const dgPc = resolveProviderConfig(cfg, guard.downgradeModel);
+              // Key 归属服务商（provider 级），同服务商即天然共享同一 Key，无需再查 apiKey
+              if (dgPc && dgPc.name === curPc.name) {
+                activeModel = guard.downgradeModel;
+                downgraded = true;
+                io.print(style(guard.message, C.yellow));
+              } else {
+                stripOrphanCalls();
+                return {
+                  text: null, reasoning: '', usage, steps, finish, truncated: false, aborted: false,
+                  note: `费用护栏想降级到 ${guard.downgradeModel}，但它与当前服务商不一致或缺少 API Key——已暂停执行。请把 config.costGuard.downgradeModel 改为与当前模型同服务商（当前：${curPc.name}）的模型名，或调高 dailyLimitYuan。`,
+                  durationMs: Date.now() - startedAt, perf: perf(),
+                };
+              }
             } else {
               // 已经是降级目标模型：无法再降，按 block 处理
               stripOrphanCalls();
               return {
                 text: null, reasoning: '', usage, steps, finish, truncated: false, aborted: false,
-                note: `今日费用已达上限（实际 ¥${String(todayCost().toFixed(4))}），且已在最便宜模型上执行，已暂停——调整 config.costGuard 或明天自动恢复。`,
+                note: `今日费用已达上限（实际 ¥${String((todayCost() ?? 0).toFixed(4))}），且已在最便宜模型上执行，已暂停——调整 config.costGuard 或明天自动恢复。`,
                 durationMs: Date.now() - startedAt, perf: perf(),
               };
             }
@@ -284,10 +315,11 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
         res = await provider.chat({
           model: activeModel,
           messages: sanitized,
-          tools: toolsFor(readOnlyPhase),
+          tools: toolsFor(readOnlyPhase, turnStrippedSet),
           temperature,
           maxTokens: maxOutput,
-          reasoningEffort,
+          // MiniMax P0：仅当 activeModel 声明支持 reasoning 才发送（否则 400 终止回合）；'off' 显式禁用例外
+          reasoningEffort: modelPreset(activeModel)?.supportsReasoning || reasoningEffort === 'off' ? reasoningEffort : undefined,
           signal: ac.signal,
           onDelta(/** @type {any} */ d) {
             io.stopSpinner();
@@ -328,7 +360,13 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
 
       if (res.toolCalls?.length) {
         io.endTurn();
-        const assistantMsg = { role: 'assistant', content: res.text || null, tool_calls: res.toolCalls };
+        const assistantMsg = {
+          role: 'assistant',
+          content: res.text || null,
+          tool_calls: res.toolCalls,
+          // Kimi P0：带工具调用的消息必须携带完整 reasoning_content（否则下一轮 400）
+          ...(res.toolCalls?.length && res.reasoning ? { reasoning_content: res.reasoning } : {}),
+        };
         messages.push(assistantMsg);
 
         // 只读工具并行（P2-8）：同一 response 里的连续 read/ls/glob/grep 无相互依赖，

package/src/atomic-write.js

@@ -57,10 +57,16 @@ export function withFileLockSync(/** @type {string} */ lockPath, /** @type {() =
       try {
         const st = fs.statSync(lockPath);
         if (Date.now() - st.mtimeMs > staleMs) {
+          // TOCTOU 防护（OfficeACE 报告）：unlink 前读锁内容并二次 stat 比对，
+          // 防两个进程同时判定陈旧、后者误删前者刚创建的新锁（互斥失效）
           try {
-            fs.unlinkSync(lockPath);
+            const before = fs.readFileSync(lockPath, 'utf8');
+            const st2 = fs.statSync(lockPath);
+            if (st2.mtimeMs === st.mtimeMs && before === fs.readFileSync(lockPath, 'utf8')) {
+              fs.unlinkSync(lockPath);
+            }
           } catch {}
-          continue; // 回收陈旧锁后立即重试
+          continue; // 无论是否回收成功都重试一次（若锁刚被他人更新则继续等待）
         }
       } catch {
         continue; // 锁文件刚被释放

package/src/cli.js

@@ -257,8 +257,16 @@ async function main() {
     const { readTask } = await import('./tasks.js');
     const handled = new Set();
     const supervising = new Set(); // 本 daemon 正在监督的任务（防崩溃恢复误判正在执行的任务）
+    const nonce = String(opts.prompt[1] || '');
     try {
       for (;;) {
+        // 守护进程租约自检（2026-09-03，防双 daemon）：pidfile 不再等于「我的 pid nonce」
+        // 即视为已被 stop 或已被新 daemon 取代——立即退出，绝不与新 daemon 并跑重复执行任务
+        try {
+          if (fs.readFileSync(daemonPidFile(home0), 'utf8').trim() !== `${process.pid} ${nonce}`) break;
+        } catch {
+          break; // pidfile 被删 = 已被 stop
+        }
         const jobs = listSchedules(home0);
         if (!jobs.some((j) => j.status === 'pending' || j.status === 'running')) break;
         for (const j of jobs) {
@@ -295,8 +303,12 @@ async function main() {
         await new Promise((r) => setTimeout(r, 2000));
       }
     } finally {
+      // 只删除「仍指向自己」的 pidfile：租约被改写/被新 daemon 取代而退出时，
+      // 绝不误删新 daemon 的 pidfile（否则新 daemon 下一次租约检查会连锁退出，双守护全灭）
       try {
-        fs.rmSync(daemonPidFile(home0), { force: true });
+        if (fs.readFileSync(daemonPidFile(home0), 'utf8').trim() === `${process.pid} ${nonce}`) {
+          fs.rmSync(daemonPidFile(home0), { force: true });
+        }
       } catch {}
     }
     return;
@@ -368,15 +380,22 @@ async function main() {
     },
   };
   if (cfg.mcpServers && Object.keys(cfg.mcpServers).length) {
-    startMcpServers(cfg.mcpServers, workingDir)
-      .then((mgr) => {
-        mcpManager = mgr;
-        const ready = mgr.status().filter((s) => s.ok).length;
-        if (io && !opts.prompt.length) {
-          io.print(style(`✓ MCP 就绪：${ready}/${mgr.status().length} 个服务器，共 ${mgr.toolSchemas().length} 个工具`, C.dim));
-        }
-      })
-      .catch(() => {});
+    // A2：预热——await 连接（6s 超时）；超时本会话冻结工具集（不再中途注入，保护前缀缓存）。
+    // 超时后输家 promise 仍在跑：迟到就绪的 manager 立即 stop，防 detached 子进程成孤儿（自查 #2）
+    const mcpStartP = startMcpServers(cfg.mcpServers, workingDir).catch(() => null);
+    mcpManager = await Promise.race([
+      mcpStartP,
+      new Promise((/** @type {any} */ r) => setTimeout(() => r(null), 6000)),
+    ]);
+    if (!mcpManager) mcpStartP.then((/** @type {any} */ m) => { if (m) m.stop(); });
+    if (mcpManager) {
+      const ready = mcpManager.status().filter((/** @type {any} */ s) => s.ok).length;
+      if (io && !opts.prompt.length) {
+        io.print(style(`✓ MCP 就绪：${ready}/${mcpManager.status().length} 个服务器，共 ${mcpManager.toolSchemas().length} 个工具`, C.dim));
+      }
+    } else if (io && !opts.prompt.length) {
+      io.print(style('⚠ MCP 连接超时（6s）：本会话不注入 MCP 工具（重启 mingdao 可重试）', C.dim));
+    }
   }
   const sessionRef = { name: null }; // 会话名在下方 REPL 初始化中回填（审计归因用）
   // 会话文件与落盘游标共享槽：REPL（commands/repl.js）创建会话/更新游标后回填，

package/src/commands/repl.js

@@ -322,7 +322,7 @@ export async function runRepl(ctx) {
           io.print(`用法：/think low|high|max|off（当前：${cfg.reasoningEffort || '跟随模型默认 high'}）`);
           continue;
         }
-        if (arg === 'off') cfg.reasoningEffort = undefined;
+        if (arg === 'off') cfg.reasoningEffort = 'off'; // 显式禁用（provider 转 thinking:{type:'disabled'}）
         else if (vals.includes(arg)) cfg.reasoningEffort = arg;
         else { io.print(style('无效取值：low|high|max|off', C.red)); continue; }
         agent = createAgent({
@@ -579,7 +579,7 @@ export async function runRepl(ctx) {
         if (guard) {
           io.print(
             style(
-              `费用护栏：今日 ¥${guard.cost.toFixed(4)} / 上限 ¥${guard.limit.toFixed(2)}${guard.overLimit ? '（已达上限' + (guard.action === 'block' ? '，执行已暂停' : '，仅提醒') + '）' : ''}`,
+              `费用护栏：今日 ¥${(guard.cost ?? 0).toFixed(4)} / 上限 ¥${guard.limit.toFixed(2)}${guard.overLimit ? '（已达上限' + (guard.action === 'block' ? '，执行已暂停' : '，仅提醒') + '）' : ''}`,
               guard.overLimit ? C.yellow : C.dim
             )
           );

package/src/context.js

@@ -66,19 +66,31 @@ export function trimMessages(/** @type {any} */ messages, /** @type {any} */ bud
   const system = hasSystem ? [messages[0]] : [];
   const rest = hasSystem ? messages.slice(1) : messages;
   const totalOf = (/** @type {any} */ arr) => arr.reduce((/** @type {any} */ s, /** @type {any} */ m) => s + messageTokens(m, count), 0);
-  // —— 轻量语义回收（Hermes B1）：预算 >80% 时先对最老消息做无模型压缩 ——
-  // 最老 tool 消息 → 单行摘要；老 assistant 长文 → 前 200 字；逐条向新推进直到回到 80% 线。
-  // 相比直接丢弃，被修改的只有前端旧消息——其后未被触碰的近期尾部字节保持不变，
-  // 下一轮前缀缓存从首个未修改消息起继续命中（直接丢弃反而让整段前缀失配）。
-  // 质检 M10：维护增量 total（替换消息后按新旧 token 差调整），不再每步全量重算（原 ≤500×n）。
+  // —— 轻量语义回收（Hermes B1 + workbuddy P0-1 修正）——
+  // 只在「真的超预算」时回收（此前 >80% 即动手，能塞下的会话也被白白截断丢内容）；
+  // 回收边界 = 按尾部保留规则确定将被丢弃的前缀（此前固定扫前 500 条，超长会话时回收全白做）；
+  // 替换仅当摘要确实更短才接受（防短消息被摘要撑长）。
   const sysTokens = totalOf(system);
   let total = sysTokens + totalOf(rest);
-  if (total > budget * 0.8) {
+  if (total > budget) {
     const out = [...rest];
-    for (let i = 0; i < out.length && i < 500; i++) {
-      if (total <= budget * 0.8) break;
+    // 丢弃边界：从后往前贪心，确定尾部保留起点 s（s 之前的消息将被丢弃，只对它们回收）
+    let s = out.length;
+    {
+      let acc = sysTokens;
+      for (let i = out.length - 1; i >= 0; i--) {
+        const t = messageTokens(out[i], count);
+        if (acc + t > budget) { s = i + 1; break; }
+        acc += t;
+      }
+    }
+    for (let i = 0; i < s && i < 500; i++) {
+      if (total <= budget) break;
       const m = out[i];
       const c = typeof m.content === 'string' ? m.content : JSON.stringify(m?.content ?? '');
+      // 幂等守卫（A4）：已回收过的内容跳过——否则「截断标记」把长度再次顶过阈值，逐轮嵌套重截，
+      // 被保留消息字节逐轮漂移（前缀缓存连尾部都失配）
+      if (c.includes('已回收')) continue;
       let next = null;
       if (m.role === 'tool' && c.length > 40) {
         next = { ...m, content: `[工具 ${m.tool_call_id || ''} 结果摘要：${c.slice(0, 40).replace(/\n/g, ' ')}…（已回收，原 ${c.length} 字）]` };
@@ -86,8 +98,12 @@ export function trimMessages(/** @type {any} */ messages, /** @type {any} */ bud
         next = { ...m, content: c.slice(0, 200) + ` …[已回收，原 ${c.length} 字]` };
       }
       if (next) {
-        total += messageTokens(next, count) - messageTokens(m, count);
-        out[i] = next;
+        const oldT = messageTokens(m, count);
+        const newT = messageTokens(next, count);
+        if (newT < oldT) {
+          total += newT - oldT;
+          out[i] = next;
+        }
       }
     }
     // 回收后仍超预算 → 从尾部保留（必要时继续丢弃最老，清洗 tool 配对）

package/src/cost-guard.js

@@ -32,9 +32,15 @@ export function todayCost() {
     todayCache = { mtime: st.mtimeMs, size: st.size, start, sum };
     return sum;
   } catch {
-    return 0;
+    // MiniMax P0：统计文件损坏/不可读时返回 null（护栏全部失效）而不是静默 0——并一次性告警
+    if (!todayCostWarned) {
+      todayCostWarned = true;
+      console.warn('[MingDao] 费用统计读取失败：今日费用护栏暂时无法判断（修复 cache-stats.jsonl 或重启后恢复）。');
+    }
+    return null;
   }
 }
+let todayCostWarned = false;
 
 export function costGuardStatus() {
   const g = costGuardConfig();
@@ -49,8 +55,9 @@ export function costGuardStatus() {
     warnAt,
     action,
     downgradeModel: String(g.downgradeModel || 'deepseek-v4-flash'),
-    overWarn: limit > 0 && cost >= warnAt,
-    overLimit: limit > 0 && cost >= limit,
+    degraded: cost === null, // 统计不可读：护栏降级为「无法判断」
+    overWarn: cost !== null && limit > 0 && cost >= warnAt,
+    overLimit: cost !== null && limit > 0 && cost >= limit,
   };
 }
 
@@ -58,10 +65,11 @@ export function costGuardStatus() {
 export function checkCostGuard() {
   const st = costGuardStatus();
   if (!st) return null;
+  if (st.degraded) return null; // 统计不可读：不误拦也不放水（已告警），按无法判断处理
   if (st.overLimit && st.action === 'block') {
     return {
       blocked: true,
-      message: `今日费用已达上限 ¥${st.limit.toFixed(2)}（实际 ¥${st.cost.toFixed(4)}），已暂停执行——调整 config.costGuard 或明天自动恢复。`,
+      message: `今日费用已达上限 ¥${st.limit.toFixed(2)}（实际 ¥${(st.cost ?? 0).toFixed(4)}），已暂停执行——调整 config.costGuard 或明天自动恢复。`,
     };
   }
   if (st.overLimit && st.action === 'downgrade') {
@@ -69,13 +77,13 @@ export function checkCostGuard() {
       blocked: false,
       downgrade: true,
       downgradeModel: st.downgradeModel,
-      message: `⚠ 费用护栏：今日已用 ¥${st.cost.toFixed(4)} 超上限 ¥${st.limit.toFixed(2)}——已自动降级到便宜模型 ${st.downgradeModel} 继续执行（config.costGuard.action 可改回 warn/block）。`,
+      message: `⚠ 费用护栏：今日已用 ¥${(st.cost ?? 0).toFixed(4)} 超上限 ¥${st.limit.toFixed(2)}——已自动降级到便宜模型 ${st.downgradeModel} 继续执行（config.costGuard.action 可改回 warn/block）。`,
     };
   }
   if (st.overWarn) {
     return {
       blocked: false,
-      message: `⚠ 费用护栏：今日已用 ¥${st.cost.toFixed(4)} / 上限 ¥${st.limit.toFixed(2)}${st.action !== 'warn' ? `（${st.action === 'block' ? '到达即暂停' : '到达自动降级 ' + st.downgradeModel}）` : '（仅提醒）'}。`,
+      message: `⚠ 费用护栏：今日已用 ¥${(st.cost ?? 0).toFixed(4)} / 上限 ¥${st.limit.toFixed(2)}${st.action !== 'warn' ? `（${st.action === 'block' ? '到达即暂停' : '到达自动降级 ' + st.downgradeModel}）` : '（仅提醒）'}。`,
     };
   }
   return null;

package/src/log-writer.js

@@ -9,7 +9,9 @@ export function createLogWriter(/** @type {string} */ file, { maxBytes = 512 * 1
     try {
       fs.mkdirSync(path.dirname(file), { recursive: true });
       const line = new Date().toISOString() + ' ' + String(msg) + '\n';
-      fs.appendFileSync(file, line);
+      // 自查 #5：日志可能含工具参数等敏感信息——创建与轮转一律 600（多用户机器防同机读取）
+      if (!fs.existsSync(file)) fs.appendFileSync(file, line, { mode: 0o600 });
+      else fs.appendFileSync(file, line);
       const st = fs.statSync(file);
       if (st.size > maxBytes) {
         const raw = fs.readFileSync(file, 'utf8');
@@ -17,8 +19,9 @@ export function createLogWriter(/** @type {string} */ file, { maxBytes = 512 * 1
         const nl = raw.indexOf('\n', cut);
         const keep = nl === -1 ? raw.slice(cut) : raw.slice(nl + 1); // 行对齐保留尾部
         const tmp = file + '.' + process.pid + '.' + crypto.randomBytes(3).toString('hex') + '.tmp';
-        fs.writeFileSync(tmp, keep);
+        fs.writeFileSync(tmp, keep, { mode: 0o600 }); // 轮转重建保持 600
         fs.renameSync(tmp, file);
+        try { fs.chmodSync(file, 0o600); } catch {} // rename 后兜底收权（历史 644 日志迁移）
       }
     } catch {
       // 日志失败绝不抛错（best-effort）

package/src/pricing.js

@@ -42,9 +42,18 @@ export function pricingDataStale() { return externalPricing().stale; }
 export async function refreshPricingFromSource(cfg) {
   const src = String(cfg?.pricing?.source || '').trim();
   if (!src) return { ok: false, lines: ['未配置 pricing.source（config.json 的 pricing.source 填官方价格 JSON 地址后重试）'] };
+  // 自查 #4：与 sync/自定义模型同类的第三外联入口——协议白名单 + 响应大小上限（防误配/恶意源灌内存）
+  try {
+    const u = new URL(src);
+    if (u.protocol !== 'http:' && u.protocol !== 'https:') return { ok: false, lines: ['价格源仅支持 http/https 地址'] };
+  } catch {
+    return { ok: false, lines: ['价格源必须是合法的 http(s) URL'] };
+  }
   const res = await fetch(src, { signal: AbortSignal.timeout(15000) });
   if (!res.ok) return { ok: false, lines: ['价格源请求失败：HTTP ' + res.status] };
-  const d = await res.json();
+  const buf = await res.arrayBuffer();
+  if (buf.byteLength > 512 * 1024) return { ok: false, lines: ['价格源响应超过 512KB 上限，已拒绝'] };
+  const d = JSON.parse(Buffer.from(buf).toString('utf8'));
   const models = d && typeof d === 'object' && !Array.isArray(d) ? /** @type {any} */ (d).models : null;
   if (!models || typeof models !== 'object' || Array.isArray(models)) {
     return { ok: false, lines: ['价格源格式不符：应为 {"models": {"模型名": {"input":…,"output":…,"cacheHit":…,"peak":{…}}}}'] };

package/src/prompts.js

@@ -14,7 +14,7 @@ const BASE = `你是 MingDao Harness，一个由 MingDao Harness 驱动的 AI
 2. 精准修改：优先用 edit 做小步精确替换；新建文件用 write；保持改动最小化；改错可用 undo 撤销。
 3. 大内容分批写：单个 write 的参数总长控制在 6000 字符以内；大文件先写核心骨架，再分多次 write/edit 逐步补充——单次输出超限会被截断并导致参数解析失败。
 4. 任务管理：多步骤任务先建 todo 清单并逐项更新；与技能（skill）相关的任务先加载对应 SKILL.md。
-5. 委托与专注：独立、可并行的子问题（调研、复核、独立实现）用 task 委托子代理，把结果拿回来继续主线。
+5. 委托与专注：把「互不依赖、可并行」的子问题（同时调研多个方向、复核多份文件、独立实现多模块）用 task 委托子代理；多个只读调研子代理应在同一轮一起派发（readOnly=true，自动并行，效率最高）；依赖当前对话细节的小改动自己做，不要委托。子代理返回后拿结果继续主线。
 6. 命令谨慎：执行 bash 前想清楚影响；命令失败时阅读错误输出并修复，同一问题最多重试 3 次。
 7. 回答风格：使用用户的语言（默认中文），简洁直接，先结论后说明。
 8. 诚实可靠：不编造不存在的文件、行号、API 或执行结果。

package/src/providers/openai-compatible.js

@@ -16,7 +16,8 @@ export async function chat(/** @type {any} */ { baseUrl, apiKey, model, messages
   }
   if (maxTokens) payload.max_tokens = maxTokens;
   if (responseFormat) payload.response_format = responseFormat;
-  if (reasoningEffort) payload.reasoning_effort = reasoningEffort; // 思考强度（官方 thinking_mode）
+  if (reasoningEffort === 'off') payload.thinking = { type: 'disabled' }; // /think off：显式关闭思考（官方 thinking_mode）
+  else if (reasoningEffort) payload.reasoning_effort = reasoningEffort; // 思考强度（官方 thinking_mode）
   payload.stream = true;
   // 流式响应默认不带 usage，显式请求以便展示 token/费用统计
   // （部分网关不支持该字段，可在 config.json 设 "includeUsage": false 关闭）
@@ -153,8 +154,9 @@ export async function parseStream(/** @type {any} */ body, /** @type {any} */ on
       if (handleLine(line)) break;
     }
   }
-  // 收尾：残行（网关最后一帧不带换行）与多字节字符冲刷
-  content += decoder.decode();
+  // 收尾：残行（网关最后一帧不带换行）与多字节字符冲刷——decode 残余并入 buf 统一走行解析，
+  // 不再直接拼进 content（此前尾字节绕过 doneFlag/行解析，流中途截断时正文混入杂质）
+  buf += decoder.decode();
   if (buf.trim()) handleLine(buf); // [DONE] 后残留 usage 尾帧仍吸收（正文/推理已被 doneFlag 拦截）
 
   const toolCalls = [...calls.entries()]

package/src/routing.js

@@ -19,11 +19,11 @@ export function routingConfig(/** @type {any} */ cfg) {
 }
 
 const PLAN_HINTS =
-  /设计|架构|重构|审查|规划|分析|方案|评估|优化|排查|疑难|报错|怎么修|修复|设计模式|选型|技术债|roadmap|review|design|refactor|plan|architecture|方案设计|评审/;
+  /设计|架构|重构|审查|规划|分析|方案|评估|优化|排查|疑难|报错|怎么修|修复|设计模式|选型|技术债|roadmap|review|design|refactor|plan|architecture|方案设计|评审|fix|analyze|analyse|evaluate|audit|optimize|bug|issue|error|performance/i;
 
 // 生成类任务（游戏/网页/文档等）需要大输出（planner 32K vs executor 8K），即使短句也路由 planner
 const GENERATION_HINTS =
-  /(生成|制作|编写|创建|写|开发|实现|做).{0,30}(游戏|网页|页面|网站|应用|程序|文档|报告|简历|PPT|演示|完整|详细|小工具)|网页版|游戏/;
+  /(生成|制作|编写|创建|写|开发|实现|做|make|build|create|generate|write|implement|develop).{0,30}(游戏|网页|页面|网站|应用|程序|文档|报告|简历|PPT|演示|完整|详细|小工具|game|website|page|site|app|program|document|report|resume|ppt|tool)|网页版|游戏|webpage|website/i;
 
 export function heuristicRoute(/** @type {any} */ text, /** @type {any} */ rc) {
   const s = String(text ?? '');
@@ -31,7 +31,7 @@ export function heuristicRoute(/** @type {any} */ text, /** @type {any} */ rc) {
   if (PLAN_HINTS.test(s)) {
     // 规划类关键词优先（审计：此前要求 length>=40，导致「设计一个缓存方案」这类
     // 13 字短句被误路由到 flash 硬扛——关键词强度优先于文本长度）
-    return s.length >= 40 || /设计|规划|分析|评估|审查|架构|重构|方案|优化|报错|修复/.test(s) ? rc.planner : null;
+    return s.length >= 40 || /设计|规划|分析|评估|审查|架构|重构|方案|优化|报错|修复|fix|analy|review|design|plan|optimiz|refactor|evaluat|audit|error|bug/i.test(s) ? rc.planner : null;
   }
   if (s.length <= 60) return rc.executor;
   return null; // 需要分类器

package/src/schedule.js

@@ -164,7 +164,7 @@ export function removeSchedule(/** @type {any} */ home, /** @type {any} */ id) {
     if (!job) return false;
     if (job.pid) {
       const owned = pidOwnedBy(job.pid, id); // 质检 M11：cmdline 含调度 id 才 kill
-      if (owned !== false) {
+      if (owned === true) { // 非 Linux/无法校验（null）不盲杀（CodeBuddy 报告：PID 复用误杀风险）
         try {
           process.kill(job.pid, 'SIGTERM');
         } catch {}
@@ -186,7 +186,7 @@ export function pauseSchedule(/** @type {any} */ home, /** @type {any} */ id) {
     if (!job) return false;
     if (job.pid) {
       const owned = pidOwnedBy(job.pid, id); // 质检 M11：cmdline 含调度 id 才 kill
-      if (owned !== false) {
+      if (owned === true) { // 非 Linux/无法校验（null）不盲杀（CodeBuddy 报告：PID 复用误杀风险）
         try {
           process.kill(job.pid, 'SIGTERM');
         } catch {}
@@ -293,7 +293,9 @@ export function daemonAlive(/** @type {any} */ home) {
 }
 export function stopDaemon(/** @type {any} */ home) {
   try {
-    const pid = Number(fs.readFileSync(daemonPidFile(home), 'utf8'));
+    // pidfile 格式 "<pid> <nonce>"——必须取首段（此前整串 Number()=NaN，SIGTERM 永远不发，
+    // 只删 pidfile → 孤儿 daemon 继续跑，新 daemon 再被拉起 → 双守护重复执行任务）
+    const pid = Number(String(fs.readFileSync(daemonPidFile(home), 'utf8')).trim().split(/\s+/)[0]);
     if (pid) {
       try {
         process.kill(pid, 'SIGTERM');

package/src/skills.js

@@ -94,8 +94,10 @@ export function listSkills(/** @type {any} */ workingDir) {
         continue;
       }
       seen.add(e.name); // 优先级：user > project > builtin，先出现的生效
-      // P3-3：用户级技能指纹不符 → 拒绝加载（绝不静默执行被篡改的提示词）
-      if (source === 'user' && isTampered(path.join(dir, e.name))) continue;
+      // P3-3：技能指纹不符 → 拒绝加载（绝不静默执行被篡改的提示词）。
+      // project 级（.mingdao/skills/）同样校验（CodeBuddy 报告：仓库投毒可直通提示词注入）；
+      // 无 .source.json 指纹的旧仓库/手写技能不受影响（isTampered 返回 false）。
+      if ((source === 'user' || source === 'project') && isTampered(path.join(dir, e.name))) continue;
       out.push({
         name: e.name,
         dir: path.join(dir, e.name),

package/src/tasks.js

@@ -115,7 +115,7 @@ function killTaskInner(/** @type {any} */ home, /** @type {any} */ id) {
     try {
       owned = fs.readFileSync(`/proc/${t.pid}/cmdline`, 'utf8').includes(id);
     } catch {}
-    if (owned !== false) {
+    if (owned === true) { // 非 Linux/无法校验（null）不盲杀（CodeBuddy 报告：PID 复用误杀风险）
       try {
         // worker 是 detached 进程（自成进程组）：优先杀整组，避免工具子进程成孤儿
         process.kill(-t.pid, 'SIGTERM');

package/src/tokenizer.js

@@ -290,7 +290,7 @@ export function countTokens(text, modelName) {
   const hit = byModel.get(s);
   if (hit !== undefined) return hit;
   const n = countDeepseek(s);
-  if (byModel.size >= TOKEN_CACHE_MAX_ENTRIES) byModel.clear();
+  if (byModel.size >= TOKEN_CACHE_MAX_ENTRIES) byModel.delete(byModel.keys().next().value); // LRU：删最旧（Map 迭代序）
   byModel.set(s, n);
   return n;
 }

package/src/tools/index.js

@@ -83,9 +83,9 @@ const SKILL_SCHEMA = {
 const TASK_SCHEMA = {
   type: 'object',
   properties: {
-    description: { type: 'string', description: '子任务一句话描述。' },
-    prompt: { type: 'string', description: '子代理的完整任务说明。' },
-    readOnly: { type: 'boolean', description: '只读调研任务，可并行。' },
+    description: { type: 'string', description: '子任务一句话描述（用于进度展示）。' },
+    prompt: { type: 'string', description: '子代理的完整任务说明（全新上下文，需自带全部必要背景）。' },
+    readOnly: { type: 'boolean', description: '只读调研任务（不写文件不执行命令）。多个 readOnly 子任务同一轮派发会并行执行，效率最高。' },
   },
   required: ['prompt'],
 };
@@ -185,7 +185,7 @@ const TOOLS = [
     type: 'function',
     function: {
       name: 'task',
-      description: '把独立子任务委托给新上下文子代理并返回汇报；readOnly 只读任务可并行。',
+      description: '把独立、可并行的子任务委托给全新上下文子代理并返回汇报。适合：多方向调研/复核/独立实现等互不依赖的任务（多个只读调研子任务应同一轮一起派发，自动并行，效率最高）；不适合：依赖当前对话细节的小改动。',
       parameters: TASK_SCHEMA,
     },
   },

package/src/web/app.js

@@ -101,6 +101,7 @@ $('#dirPickNone').onclick = () => { const cb = pickerCb; pickerCb = null; $('#di
 $('#dirPickCancel').onclick = () => { pickerCb = null; $('#dirModal').style.display = 'none'; };
 const chatEl = $('#chat'), input = $('#input'), sendBtn = $('#sendBtn');
 let activeAiMsg=null, bgRunning=0, curSteps=0, curWorkT0=0, curTools=0, curTasks=0; // 本轮进度（活动条/状态条/轨迹共用）
+let bgTasks=[]; // 后台任务列表快照（chip tooltip 详情用，updateTasksPanel 每 2s 刷新）
 let curPhase='模型推理中'; // 阶段语义（服务端 progress 事件下发）
 const sessionSubs=[]; // 本会话全部子代理（task 工具）条目：{seq, question, result, msg}
 // 回到底部悬浮按钮：滚动容器为 main；上滚超过 300px 时出现，点击平滑回底
@@ -421,13 +422,17 @@ 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)+' 秒 · '+curTools+' 工具步</span>';
+    html='<span class="ws-busy"><span class="spinner"></span><span class="ws-phase">'+esc(curPhase)+'</span><span>⏳ 第 '+curSteps+' 步 · '+Math.floor(secs/60)+' 分 '+Math.round(secs%60)+' 秒 · '+curTools+' 工具步'+(curTasks>0?' · '+curTasks+' 个子代理':'')+'</span></span>';
   } else if(bgRunning>0){
-    html='<span class="ws-bg">🛠 '+bgRunning+' 个后台任务运行中（下载/定时任务等）— 点击查看，完成后会自动提示</span>';
+    // 后台任务 chip（非顶部，位于输入框上方）：计数 + 最新任务 + 悬浮详情 tooltip，点击打开详情面板
+    const running=bgTasks.filter((/** @type {any} */ t)=>t.status==='running');
+    const latest=running.length?running[running.length-1]:null;
+    const tip=bgTasks.map((/** @type {any} */ t)=>(t.kind==='schedule'?'⏰':'🛠')+' '+String(t.message||t.id||'').slice(0,40)+' · '+t.status).join('\n');
+    html='<span class="ws-bg" title="'+esc(String(tip)).replace(/"/g,'&quot;')+'">🛠 '+bgRunning+' 个后台任务运行中'+(latest?' · '+esc(String(latest.message||'').slice(0,22)):'')+' — 点击查看详情</span>';
   }
   el.style.display=html?'flex':'none';
   el.innerHTML=html;
-  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'; $('#subPanel').style.display='none'; updateTasksPanel(); } };
+  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'; $('#subPanel').style.display='none'; updateTasksPanel(); } syncPanelLayout(); };
 }
 // 顶部常驻活动条（静默完美解决层）：生成期间始终可见，滚动不影响
 function renderLiveBar(){
@@ -483,6 +488,15 @@ function openTraj(msg){
   $('#trajPanel').style.display='flex';
   $('#tasksPanel').style.display='none'; // 仅任务面板（右侧）与轨迹互斥；子代理面板可与轨迹同显
   $('#trajRailBtn').classList.add('on');
+  syncPanelLayout();
+}
+// 面板布局同步（2026-09-02）：轨迹/子代理/任务面板打开时以 body class 推开内容区，
+// 聊天文本与附件行不再被固定面板遮挡；面板宽度随屏宽自动收窄（CSS 媒体查询）。
+function syncPanelLayout(){
+  const open=(id)=>document.getElementById(id)?.style.display==='flex';
+  document.body.classList.toggle('traj-open', open('trajPanel'));
+  document.body.classList.toggle('sub-open', open('subPanel'));
+  document.body.classList.toggle('tasks-open', open('tasksPanel'));
 }
 function resultText(r){
   if(r==null||r===undefined) return '';
@@ -492,13 +506,14 @@ function resultText(r){
   return JSON.stringify(r);
 }
 function truncText(t,n){ t=String(t||''); return t.length>n?t.slice(0,n)+'\n…（截断，共 '+t.length+' 字）':t; }
-$('#tjClose').onclick=()=>{ $('#trajPanel').style.display='none'; $('#trajRailBtn').classList.remove('on'); };
+$('#tjClose').onclick=()=>{ $('#trajPanel').style.display='none'; $('#trajRailBtn').classList.remove('on'); syncPanelLayout(); };
 $('#trajRailBtn').onclick=()=>{
   const p=$('#trajPanel');
   const willShow=p.style.display==='none';
   if(willShow){ const m=lastMsgWithTraj(); if(!m){ uiAlert('本轮还没有可展示的轨迹（先发起一个任务）'); return; } openTraj(m); }
   else p.style.display='none';
   $('#trajRailBtn').classList.toggle('on', willShow);
+  syncPanelLayout();
 };
 function lastMsgWithTraj(){
   const msgs=[...document.querySelectorAll('#chat .msg-ai')].reverse();
@@ -528,9 +543,10 @@ const toggleSubPanel=()=>{
   p.style.display=willShow?'flex':'none';
   $('#subRailBtn').classList.toggle('on', willShow);
   if(willShow){ $('#tasksPanel').style.display='none'; renderSubPanel(); } // 轨迹（左侧）可与子代理（右侧）同显
+  syncPanelLayout();
 };
 $('#subRailBtn').onclick=toggleSubPanel;
-$('#sbClose').onclick=()=>{ $('#subPanel').style.display='none'; $('#subRailBtn').classList.remove('on'); };
+$('#sbClose').onclick=()=>{ $('#subPanel').style.display='none'; $('#subRailBtn').classList.remove('on'); syncPanelLayout(); };
 // —— 任务面板（多会话并行） ——
 function setBtn(){
   sendBtn.textContent = generating ? '■ 停止' : '发送';
@@ -542,6 +558,7 @@ async function updateTasksPanel(){
   const j=await r.json(); const list=$('#tpList'); list.innerHTML='';
   // 质检（等待状态静默）：后台任务（worker/调度）并入计数与面板；状态转换时在聊天区弹可见横幅
   bgRunning=(Number(j.running)||0)+(Number(j.bgRunning)||0);
+  bgTasks=j.background||[];
   for(const t of (j.background||[])){
     const prev=lastBgStatus.get(t.id);
     if(prev && prev.status==='running' && t.status!=='running'){
@@ -580,7 +597,7 @@ async function refreshCostBadge(){
   const bd=j.breakdown||{}; const gd=j.guard||null;
   let t='今日 ≈¥'+(bd.today||0).toFixed(4);
   if(bd.rate!=null) t+=' · 命中 '+(bd.rate*100).toFixed(0)+'%';
-  if(gd&&gd.limit>0) t+=' · 护栏 '+(gd.cost/gd.limit*100).toFixed(0)+'%';
+  if(gd&&gd.limit>0&&gd.cost!=null) t+=' · 护栏 '+(gd.cost/gd.limit*100).toFixed(0)+'%';
   $('#costBadge').textContent=t;
 }
 refreshCostBadge(); setInterval(refreshCostBadge, 15000);
@@ -597,8 +614,8 @@ async function refreshStatusBar(){
   $('#statusBar').textContent = s.turns+' 轮 · '+s.steps+' 步 | LLM '+fmtDur(s.llmMs)+' · 工具调用 '+fmtDur(s.toolMs)+' | 首 token 平均 '+ft+' · '+tps+' | 缓存命中 '+rate+' | 输入 '+fmtTok(s.prompt)+' tok · 输出 '+fmtTok(s.completion)+' tok';
 }
 refreshStatusBar(); setInterval(refreshStatusBar, 15000);
-$('#tasksBtn').onclick=()=>{ const p=$('#tasksPanel'); p.style.display = p.style.display==='none'?'flex':'none'; if(p.style.display==='flex'){ $('#subPanel').style.display='none'; $('#trajPanel').style.display='none'; $('#trajRailBtn').classList.remove('on'); $('#subRailBtn').classList.remove('on'); updateTasksPanel(); } };
-$('#tpClose').onclick=()=>{ $('#tasksPanel').style.display='none'; };
+$('#tasksBtn').onclick=()=>{ const p=$('#tasksPanel'); p.style.display = p.style.display==='none'?'flex':'none'; if(p.style.display==='flex'){ $('#subPanel').style.display='none'; $('#trajPanel').style.display='none'; $('#trajRailBtn').classList.remove('on'); $('#subRailBtn').classList.remove('on'); updateTasksPanel(); } syncPanelLayout(); };
+$('#tpClose').onclick=()=>{ $('#tasksPanel').style.display='none'; syncPanelLayout(); };
 
 async function refreshSessions(q){ const u=q?'/api/sessions?q='+encodeURIComponent(q):'/api/sessions'; const r=await fetch(u).catch(()=>null); if(!r)return; const j=await r.json(); const sel=$('#sessions'); sel.innerHTML='<option value="">历史会话</option>'; for(const s of j.sessions){ const o=document.createElement('option'); o.value=s.file; o.textContent=s.label; sel.appendChild(o); } if(currentSession&&!q) sel.value=currentSession; }
 let searchTimer=null;

package/src/web/index.html

@@ -25,7 +25,27 @@
 *::-webkit-scrollbar-thumb:hover{background:#545557;border:2px solid transparent;background-clip:content-box}
 *::-webkit-scrollbar-track{background:transparent}
 html,body{height:100%}
-body{margin:0;background:var(--bg);color:var(--text);font:15px/1.65 -apple-system,"Segoe UI","PingFang SC","Microsoft YaHei",sans-serif;display:flex;flex-direction:column;overflow-x:hidden}
+body{margin:0;background:var(--bg);color:var(--text);font:15px/1.65 -apple-system,"Segoe UI","PingFang SC","Microsoft YaHei",sans-serif;display:flex;flex-direction:column;overflow-x:hidden;transition:padding .16s ease}
+/* 面板推开布局（2026-09-02）：轨迹/子代理/任务面板打开时推开内容区，聊天文本与附件行不被遮挡；
+   面板宽度随屏宽自动收窄，保证聊天区始终可读（≤560px 退化为全宽面板） */
+body.traj-open{padding-left:294px}
+body.sub-open{padding-right:320px}
+body.tasks-open{padding-right:280px}
+@media (max-width:1200px){
+  #trajPanel{width:210px}body.traj-open{padding-left:252px}
+  #subPanel{width:270px}body.sub-open{padding-right:270px}
+  #tasksPanel{width:230px}body.tasks-open{padding-right:230px}
+}
+@media (max-width:860px){
+  #trajPanel{width:160px}body.traj-open{padding-left:202px}
+  #subPanel{width:190px}body.sub-open{padding-right:190px}
+  #tasksPanel{width:190px}body.tasks-open{padding-right:190px}
+}
+@media (max-width:560px){
+  body.traj-open,body.sub-open,body.tasks-open{padding:0}
+  #trajPanel{width:calc(100vw - 42px);left:42px}
+  #subPanel,#tasksPanel{width:100vw}
+}
 header{min-height:52px;display:flex;align-items:center;gap:10px;padding:8px 12px;border-bottom:1px solid var(--border);background:var(--bg2);flex:none;flex-wrap:nowrap;white-space:nowrap;overflow-x:auto}
 header .logo{font-weight:700;font-size:16px;color:var(--accent);letter-spacing:.5px;flex:none}
 header .logo span{color:var(--text)}
@@ -42,7 +62,8 @@ header select{flex:none}
 #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}
 /* 输入框上方工作状态条（审计：长任务静默硬伤——实时显示执行步数/耗时与后台任务数）。
    与输入框同宽对齐（复用 #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{width:fit-content;max-width:100%;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;overflow:hidden}
+#workStatus .ws-busy{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 /* 状态条 busy 行：承载完整阶段信息（合并原顶部活动条），与输入框同列不遮挡聊天区 */
 #workStatus .ws-phase{color:var(--accent2);font-weight:600;white-space:nowrap}
 /* 左侧轨迹固定栏 + 右侧子代理面板（布局重构：轨迹在左、子代理在右） */

package/src/web/routes/domains/config.js

@@ -208,7 +208,7 @@ export async function handle({ req, res, method, p, url }, deps, shared) {
       const label = String(body.label || '').trim();
       const baseUrl = String(body.baseUrl || '').trim();
       if (!baseUrl) return json(res, 400, { error: 'API 地址（baseUrl）不能为空' });
-      const vurl = shared.validateRemoteUrl(baseUrl); // 质检 S1：SSRF 防护
+      const vurl = await shared.validateRemoteUrl(baseUrl); // 质检 S1：SSRF 防护
       if (vurl.error) return json(res, 400, { error: vurl.error });
       if (action === 'addCustom' && (cfg.customModels || {})[name]) {
         return json(res, 400, { error: `自定义模型 ${name} 已存在（可修改）` });
@@ -265,7 +265,7 @@ export async function handle({ req, res, method, p, url }, deps, shared) {
     if (action === 'setBaseUrl') {
       const baseUrl = String(body.baseUrl || '').trim();
       if (baseUrl) {
-        const vurl = shared.validateRemoteUrl(baseUrl); // 质检 S1：SSRF 防护
+        const vurl = await shared.validateRemoteUrl(baseUrl); // 质检 S1：SSRF 防护
         if (vurl.error) return json(res, 400, { error: vurl.error });
       }
       cfg.baseUrl = baseUrl || undefined;

package/src/web/routes/domains/misc.js

@@ -30,7 +30,8 @@ export async function handle({ req, res, method, p, url }, deps, shared) {
     });
     let body;
     try {
-      body = await readBody(req, MAX_API_BODY);
+      // chat 保留默认 40MB 上限（附件 base64 可达 ~26MB）；普通 JSON 接口才用 MAX_API_BODY=1MB
+      body = await readBody(req);
     } catch (/** @type {any} */ e) {
       refs.inflight -= 1;
       res.write(`data: ${JSON.stringify({ type: 'error', message: e.message })}\n\n`);

package/src/web/routes/domains/sync.js

@@ -39,7 +39,7 @@ export async function handle({ req, res, method, p, url }, deps, shared) {
   if (method === 'POST' && p === '/api/sync') {
     const body = await readBody(req, MAX_API_BODY);
     if (body.action === 'login') {
-      const vurl = validateRemoteUrl(body.url); // 质检 S1：SSRF 防护（同步端点同样只允许公网）
+      const vurl = await validateRemoteUrl(body.url); // 质检 S1：SSRF 防护（同步端点同样只允许公网）
       if (vurl.error) return json(res, 400, { error: vurl.error });
       const r = await syncLogin({ url: body.url, username: body.username, password: body.password, deviceName: body.deviceName });
       if (r.error) return json(res, 400, { error: r.error });

package/src/web/routes/domains/workspace.js

@@ -85,11 +85,17 @@ export async function handle({ req, res, method, p, url }, deps, shared) {
   if (method === 'GET' && p === '/api/fs-browse') {
     let dir = String(url.searchParams.get('dir') || '').trim();
     if (!path.isAbsolute(dir)) return json(res, 400, { error: '需要绝对路径' });
-    // 质检 A3：目录浏览限定基目录（默认家目录 + config.web.browseRoots 显式授权），
-    // 拒绝越界——此前可枚举服务器任意绝对路径（整机目录结构探测面）
-    const browseRoots = [os.homedir(), startupCwd, state.workingDir, ...(Array.isArray(cfg.web?.browseRoots) ? cfg.web.browseRoots : [])].map((r) => path.resolve(String(r)));
-    const inRoot = browseRoots.some((r) => dir === r || dir.startsWith(r + path.sep));
-    if (!inRoot) return json(res, 403, { error: '目录不在可浏览范围内（家目录或 web.browseRoots 授权目录）' });
+    // 质检 A3：目录浏览限定基目录，拒绝越界。Windows（CodeArts 报告）：家目录覆盖整个用户配置树
+    // （AppData 等）——收紧为 桌面/文档/下载 三常用目录 + 启动目录 + 工作目录 + web.browseRoots 显式授权；
+    // 路径比较在 win32 下大小写归一（D:\\ vs d:\\ 不再误拒）。
+    const base = process.platform === 'win32' && process.env.USERPROFILE
+      ? [path.join(process.env.USERPROFILE, 'Desktop'), path.join(process.env.USERPROFILE, 'Documents'), path.join(process.env.USERPROFILE, 'Downloads')]
+      : [os.homedir()];
+    const norm = (/** @type {string} */ x) => (process.platform === 'win32' ? x.toLowerCase() : x);
+    const browseRoots = [...base, startupCwd, state.workingDir, ...(Array.isArray(cfg.web?.browseRoots) ? cfg.web.browseRoots : [])].map((r) => norm(path.resolve(String(r))));
+    const ndir = norm(dir);
+    const inRoot = browseRoots.some((r) => ndir === r || ndir.startsWith(r + path.sep));
+    if (!inRoot) return json(res, 403, { error: '目录不在可浏览范围内（授权目录或 web.browseRoots 显式添加）' });
     try {
       const st = fs.statSync(dir);
       if (!st.isDirectory()) return json(res, 400, { error: '不是目录' });
@@ -101,7 +107,7 @@ export async function handle({ req, res, method, p, url }, deps, shared) {
         .slice(0, 300);
       let parent = path.dirname(dir);
       // 父目录同样不得越出基目录
-      if (!browseRoots.some((r) => parent === r || parent.startsWith(r + path.sep))) parent = /** @type {any} */ (null);
+      if (!browseRoots.some((r) => norm(parent) === r || norm(parent).startsWith(r + path.sep))) parent = /** @type {any} */ (null);
       json(res, 200, { ok: true, path: dir, parent: parent === dir ? null : parent, entries });
     } catch (/** @type {any} */ err) {
       json(res, 400, { error: String(err?.message || err) });

package/src/web/server.js

@@ -68,11 +68,16 @@ const INDEX_HTML = path.join(path.dirname(fileURLToPath(import.meta.url)), 'inde
 function json(res, code, obj) {
   res.writeHead(code, { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' });
   res.end(JSON.stringify(obj));
+  // 返回 truthy：域路由 `return json(...)` 必须被编排器视为「已处理」——
+  // 否则兜底 404 会对已结束的响应二次写入（Node 18 下 write-after-end 未捕获 → 整服务崩溃）
+  return true;
 }
 
-/** @param {any} req */
-function readBody(req) {
-  const MAX_BODY = 40 * 1024 * 1024; // 附件 base64 上限（4×5MB 图片 + 文本）留余量
+/** 读取请求体。limit 默认 40MB（附件 base64 上限：4×5MB 图片 + 文本）；
+ * 普通 JSON 接口必须显式传较小 limit（质检 A4；此前第二参数被忽略 → 1MB 限制形同虚设）。 */
+/** @param {any} req @param {number} [limit] */
+function readBody(req, limit = 40 * 1024 * 1024) {
+  const MAX_BODY = limit; // 附件 base64 上限（4×5MB 图片 + 文本）留余量
   return new Promise((resolve, reject) => {
     /** @type {any[]} */
     const chunks = [];
@@ -89,9 +94,11 @@ function readBody(req) {
     req.on('data', (/** @type {any} */ d) => {
       size += d.length;
       if (size > MAX_BODY) {
-        const err = /** @type {Error & { status?: number }} */ (new Error('请求体过大（>40MB）'));
+        const err = /** @type {Error & { status?: number }} */ (new Error(`请求体过大（>${Math.round(MAX_BODY / 1048576)}MB）`));
         err.status = 413;
-        req.destroy();
+        // 排空残余数据但保留连接：让上层 catch 返回真 413（此前 destroy 导致客户端只收到连接重置）
+        req.pause();
+        req.resume();
         reject(err);
         return;
       }
@@ -184,15 +191,20 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken
   const provider = await getProviderFor(modelName);
   const undoStore = { backups: new Map() };
 
-  // MCP：后台启动，就绪后工具并入后续轮次
+  // MCP：A2 预热——await 连接（6s 超时）；超时本会话冻结工具集（不再中途注入，保护前缀缓存）
   /** @type {any} */
   let mcpManager = null;
   if (cfg.mcpServers && Object.keys(cfg.mcpServers).length) {
-    startMcpServers(cfg.mcpServers, workingDir)
-      .then((m) => {
-        mcpManager = m;
-      })
-      .catch(() => {});
+    // 超时后输家 promise 仍在跑：迟到就绪的 manager 立即 stop，防 detached 子进程成孤儿（自查 #2）
+    const mcpStartP = startMcpServers(cfg.mcpServers, workingDir).catch(() => null);
+    mcpManager = await Promise.race([
+      mcpStartP,
+      new Promise((/** @type {any} */ r) => setTimeout(() => r(null), 6000)),
+    ]);
+    if (!mcpManager) {
+      console.error('[MingDao] ⚠ MCP 连接超时（6s）：本会话不注入 MCP 工具（重启 mingdao web 可重试）');
+      mcpStartP.then((/** @type {any} */ m) => { if (m) m.stop(); });
+    }
   }
   const mcpFacade = {
     toolSchemas: () => (mcpManager ? mcpManager.toolSchemas() : []),
@@ -228,17 +240,23 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken
   // —— SSRF 防护（质检 S1）：远端地址校验 ——
   /** @param {any} hostname */
   function isPrivateHost(hostname) {
-    const h = String(hostname || '').toLowerCase();
+    let h = String(hostname || '').toLowerCase();
     if (!h) return true;
-    if (h === 'localhost' || h.endsWith('.localhost') || h === '::1' || h === '::ffff:127.0.0.1') return true;
+    h = h.replace(/^\[|\]$/g, ''); // IPv6 字面量去括号（URL('http://[::1]/').hostname 带方括号）
+    if (h === 'localhost' || h.endsWith('.localhost') || h === '::1') return true;
+    if (h.includes(':')) {
+      // IPv6：回环 ::1、链路本地 fe80::/10、唯一本地 fc00::/7、IPv4 映射 ::ffff:私网
+      if (/^::ffff:/.test(h)) return isPrivateHost(h.slice(7));
+      return /^fe[89ab]/.test(h) || /^f[c d]/.test(h) || h === '::' || h === '::1';
+    }
     const m = h.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
-    if (!m) return false; // 域名：交给 DNS 解析（无法静态判定）
+    if (!m) return false; // 域名：由 validateRemoteUrl 的 DNS 解析复检
     const a = Number(m[1]);
     const b = Number(m[2]);
     return a === 10 || a === 127 || a === 0 || a >= 224 || (a === 169 && b === 254) || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || (a === 100 && b >= 64 && b <= 127);
   }
   /** @param {any} raw */
-  function validateRemoteUrl(raw) {
+  async function validateRemoteUrl(raw) {
     let u;
     try {
       u = new URL(String(raw));
@@ -247,10 +265,24 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken
     }
     if (u.protocol !== 'http:' && u.protocol !== 'https:') return { error: '仅支持 http/https 地址' };
     // 威胁模型：本机回环绑定时（默认/桌面版），本机模型服务（如 Ollama）属可信场景，放行；
-    // 对外监听（0.0.0.0）时拒绝私网目标——除非显式 allowPrivateEndpoints
+    // 对外监听（0.0.0.0）时拒绝私网目标——除非显式 allowPrivateEndpoints。
+    // 域名目标：DNS 解析后逐条校验（2026-09-02 加固，防 DNS 重绑定把域名指向内网绕过字面量检查）。
     const serverBoundLocal = isLoopbackHost(host);
-    if (!cfg.web?.allowPrivateEndpoints && !serverBoundLocal && isPrivateHost(u.hostname)) {
-      return { error: `拒绝访问内网/本机地址（${u.hostname}）——服务已对外监听，如确需连接可信内网服务，请在 config.json 设 web.allowPrivateEndpoints: true` };
+    if (!cfg.web?.allowPrivateEndpoints && !serverBoundLocal) {
+      const h = String(u.hostname || '').toLowerCase();
+      let blocked = isPrivateHost(h);
+      if (!blocked && h && h !== 'localhost' && !/^\d{1,3}(\.\d{1,3}){3}$/.test(h)) {
+        try {
+          const { lookup } = await import('node:dns/promises');
+          const addrs = await lookup(h, { all: true, verbatim: true });
+          blocked = addrs.some((/** @type {any} */ a) => isPrivateHost(a.address));
+        } catch {
+          // DNS 解析失败：保持放行（服务端会在连接时报错）；解析成功且指向内网 → 拦截
+        }
+      }
+      if (blocked) {
+        return { error: `拒绝访问内网/本机地址（${u.hostname}）——服务已对外监听，如确需连接可信内网服务，请在 config.json 设 web.allowPrivateEndpoints: true` };
+      }
     }
     return { ok: true };
   }