mingdao-harness 0.4.0 → 0.4.2

package/docs/CONFIG.md

@@ -111,8 +111,21 @@ WebUI 中每个会话记住自己的工作目录：新会话记录创建时的
 }
 ```
 
-格式与 Claude Code 相同；工具以 `mcp__<服务器>__<工具>` 并入 Agent 循环，带 `readOnlyHint`
-标注的工具自动放行。会话内 `/mcp` 查看状态；`mingdao mcp preset list/add` 一键接入常用服务器。
+格式与 Claude Code 相同；工具以 `mcp__<服务器>__<工具>` 并入 Agent 循环。
+
+- **只读自动放行需显式授信（v0.4.1 P0）**：带 `readOnlyHint` 的工具默认**不再**自动放行——
+  服务器可谎称只读绕过权限确认。只有加了 `"trusted": true` 的服务器，其 `readOnlyHint` 才被
+  信任（只读档自动放行、ask 档不询问）；未授信服务器的全部工具（含标注只读的）都走权限确认。
+
+```json
+{
+  "mcpServers": {
+    "filesystem": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/你的/目录"], "trusted": true }
+  }
+}
+```
+
+会话内 `/mcp` 查看状态；`mingdao mcp preset list/add` 一键接入常用服务器。
 
 ## WebUI 服务器
 
@@ -253,6 +266,18 @@ completion 计费，防止推理吃满上限时空轮白烧）、`compactTrigger
 { "timeout": { "firstTokenMs": 600000, "streamIdleMs": 120000, "totalMs": 1800000 } }
 ```
 
+### 文件访问边界（v0.4.1 P0 路径穿越防护）
+
+read/write/edit/ls/glob/grep/undo 默认限定在**工作目录**内——auto 权限模式下，模型（或被提示注入
+诱导）也无法读 `~/.ssh`、`~/.mingdao/credentials.json`（API Key 明文）等越界文件；`realpath` 逐级
+校验防软链接逃逸。需要访问工作目录外时，显式加白名单：
+
+```json
+{ "fsAllowDirs": ["/home/you/projects/shared", "/tmp/build-output"] }
+```
+
+白名单目录同样受 `realpath` 校验（目录内的软链接指向白名单外仍拒绝）。
+
 ## 自定义 Provider 模块（非 OpenAI 兼容协议）
 
 在 `~/.mingdao/providers/<name>.mjs` 导出：

package/docs/PLAN-v0.4.1.md

@@ -0,0 +1,65 @@
+# v0.4.1 规划：安全版本（偿还 v0.4.0 审计安全债）
+
+> 依据：`MingDao Harness v0.4.0 完整审计报告.docx`（2026-09-05，源码通读 + 4 项实测复现）。
+> 定调：**暂停新功能，先清零 P0 安全债**——一个能自动执行 shell 的 agent，安全边界优先级高于任何新特性。
+> 纪律：实现后不单独发布，与 v0.4.1 一起发布；等用户在 3820 验收后再发。
+
+## 已修复（本批次）
+
+### P0 安全（5 项）
+1. **路径穿越防护**（fs-tools.js）：read/write/edit/ls/glob/grep/undo 限定工作目录 + `config.fsAllowDirs`
+   白名单；`realpath` 逐级校验防软链接逃逸。auto 模式也无法读 ~/.ssh、credentials.json。
+2. **SSRF 302 重定向绕过**（fetch.js）：`redirect:'manual'` 手动跟随，每跳重新 isPrivateHost + DNS 复检，
+   跳数上限 5。
+3. **权限前缀规则绕过**（permissions.js）：黑名单改白名单字符 `[A-Za-z0-9_ ./\\:-]`，单 `&`、重定向
+   `< >`、回车 `\r` 及一切 shell 元字符都不匹配前缀规则，回落权限确认。
+4. **预设 permission 提权**（presets.js）：新增 `presetPermissionOverride`——预设声明 permission 若
+   比当前更宽松（ask→auto 等）则忽略并提示；CLI/REPL/WebUI 三入口统一接入。
+5. **MCP 权限收紧**（mcp.js）：`readOnlyHint` 自动放行改为「仅 `mcpServers.<name>.trusted:true` 才信任」，
+   未授信服务器谎报只读也走权限确认。
+
+### P1 正确性（6 项）
+6. **turnToolCache 跨步去重失效**（agent.js）：声明从 while 体内提到 for 轮内——去重跨步生效。
+7. **windowPressure 永不复位**（agent.js）：压缩成功后复位，不再每轮 force 压缩持续烧钱。
+8. **mountConfigTools 阻塞事件循环**（tools/index.js）：spawnSync → 异步 spawn + Promise。
+9. **batch.js 未跟进 model-caps**：超窗口预检改用 `resolveModelCaps(cfg, model).contextWindow`。
+10. **语义检索无匹配记忆全丢**（memory.js）：无共同词时回退最近 N 条（相关性失败 ≠ 记忆不存在）。
+11. **沙箱探测缺陷**（bash.js）：`detectSandbox` 从 `--version` 改为最小真实沙箱探测
+    （`bwrap --ro-bind / / --tmpfs /tmp true`），容器内 bwrap 不可用则降级 none。
+
+### P2 质量（6 项）
+12. 正则笔误 `/^f[c d]/` → `/^f[cd]/`（fetch.js + server.js）。
+13. git.js log/diff 限量实现（log 默认 -n 50、diff 默认 --stat），修注释与实现不符。
+14. cost-guard.js `todayCostWarned` TDZ 前置。
+15. registerTool 增 `readOnly` 选项（进 READONLY_TOOLS，只读档自动放行）。
+16. context.js 幂等守卫死代码移除（回收结果从不回写原 messages，守卫恒 false）。
+17. agent.js reasoning 清洗 O(n²) → 单次遍历 O(n)。
+
+### macOS 本地模型「输出截断 / 子代理无反馈」（追加修复，2026-09-05）
+
+用户 MacBook 用 mtplx-qwen38-27b（routing.enabled=true）复现，日志 `text=0` 且 `status=done`。两个根因：
+
+18. **子代理无反馈**（routing.js）：`subagentModel` 在 routing 开启时恒返回 executor
+    （deepseek-v4-flash），无 routeTask 的「池外不干预」检查——本地/自定义模型派子代理时，把
+    executor 模型名发到本地 baseUrl（8081）→ 服务端不认识 → 400 → 子代理全灭。修复：池外跟随当前模型。
+19. **输出截断/text=0**（agent.js）：兜底总结请求此前用 `trimMessages(messages, budget)` 全量历史，
+    本地 q8 模型 ≈98k token 的 prefill 逼近/超过 600s 首 token 超时 → 总结请求失败被 `catch {}` 静默吞 →
+    返回 text:null。修复：兜底总结改用轻量输入（system + 交付物清单 + 提示，几 k token），慢 prefill
+    也能秒出总结；失败不再静默（io.print 提示原因）。
+20. 子代理空输出透出 note 原因（agent.js）：不再笼统「（子任务无输出）」，主线程可据此决策。
+21. diagnose 报告新增「当前模型能力」段：本地模型未声明 contextWindow 时显式提示兜底 32k 及其后果
+    （输出/预算被压缩），帮用户自诊。
+
+## 顺延（明确记录，不强行塞入本批次）
+
+- **WebUI 速率限制**：本地优先工具默认回环绑定 + token 认证已挡远程；已有 `MAX_CONCURRENT=8`
+  并发上限 + `costGuard` 日费用上限双保险。令牌桶的维度（IP/会话/token）与阈值需产品决策，
+  待 v0.4.2 单独设计。
+- **容器环境 CI job**：审计建议加 container 矩阵覆盖 bwrap 不可用路径（沙箱探测修复已从代码层
+  缓解，CI 覆盖作为后续工程项）。
+- **省钱机制有效性自检**（/cost 展示各机制实际节省额）：依赖更细的分账埋点，顺延。
+
+## 验收
+
+- smoke 新增路径穿越/SSRF 重定向/权限绕过/预设提权/MCP trusted/语义检索回退等回归断言。
+- 全绿门禁 + strict 0/0 + typecheck；发布前自检；用户 3820 验收后再随 v0.4.1 发布。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mingdao-harness",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "MingDao Harness —— 开源智能体框架（Agent Harness）。零依赖、开箱即用，针对 DeepSeek-V4 系列优化，开放主流模型接入。",
   "type": "module",
   "bin": {

package/presets/local-audit.json

@@ -1,10 +1,10 @@
 {
   "name": "local-audit",
   "label": "本地模型审计",
-  "description": "面向本地/资源受限模型（如 131k 窗口 q8 量化）的只读审计预设：只读工具集 + auto 权限 + 保守参数，配合 v0.3.2 本地自适应长任务不中断",
+  "description": "面向本地/资源受限模型（如 131k 窗口 q8 量化）的只读审计预设：只读工具集 + 只读权限 + 保守参数，配合 v0.3.2 本地自适应长任务不中断",
   "systemPrompt": "你是一名代码审计员。任务是对给定代码库做只读审计：先 ls/glob 摸清结构，再 read/grep 逐文件审查，可用 git 查看历史与 diff、fetch 抓取相关文档。输出审计报告：发现的缺陷按严重度分级，每条给出文件:行号证据；不做任何修改。若上下文紧张，先审查最关键的部分并明示未覆盖区域。",
   "tools": ["read", "ls", "glob", "grep", "skill", "git", "fetch", "todo"],
-  "permission": "auto",
+  "permission": "readonly",
   "maxRounds": 4,
   "maxOutputTokens": 4096
 }

package/src/agent.js

@@ -123,7 +123,12 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
     const t0 = Date.now();
     const res = await subAgent.runTurn(messages);
     const ms = Date.now() - t0;
-    const text = res.text || (res.truncated ? '（子任务达到步骤上限，未完成）' : '（子任务无输出）');
+    // v0.4.1：子代理空输出给主线程可用的失败信号（含 note 原因），而非笼统「无输出」——
+    // 主智能体据此决定是否重试/换法，而非把子代理静默当作「已完成但没说话」。
+    const text =
+      res.text ||
+      (res.truncated ? '（子任务达到步骤上限，未完成' : '（子任务无输出') +
+      (res.note ? '：' + res.note : '') + ')';
     io.print(style(`  ↳ 子任务完成（${ms}ms）`, C.magenta));
     return text;
   }
@@ -209,12 +214,14 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       }
     };
     try {
+    // 同回合只读工具去重（Hermes C4）：相同 name+args 的只读调用只执行一次，结果复用回填。
+    // v0.4.1 P1 修复：turnToolCache 必须声明在 while 之外、for 轮内——此前在 while 体内每步重建，
+    // 去重只在本步的多个工具调用间生效，跨步（如先 grep 定位再 read 确认同一文件）完全失效。
+    const turnToolCache = new Map();
     for (round = 0; round < maxRounds; round++) {
       steps = 0;
       while (steps < stepLimit) {
       steps += 1;
-      // 同回合只读工具去重（Hermes C4）：相同 name+args 的只读调用只执行一次，结果复用回填
-      const turnToolCache = new Map();
       // 自动压缩（P3-1）：预算不足、静默裁剪即将丢弃早期段落时，先用 executor 模型
       // 把被裁段落压成摘要注入，替代「失忆」；失败/不值得时回退普通裁剪。
       if (cfg.autoCompact !== false) {
@@ -225,7 +232,9 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
             count,
             provider,
             executorModel: subagentModel(cfg, modelName),
-            triggerRatio: cfg.compactTrigger, // 可配置触发线（默认 80%）
+            // 可配置触发线：默认远程 80%；本地模型默认 60% 提前压缩——本地推理内存预算有限，
+            // 等到 80% 再压时上下文已累积过多、prefill 与内存双高（v0.4.2 本地模型 507 修复）
+            triggerRatio: Number(cfg.compactTrigger) > 0 ? cfg.compactTrigger : (caps.isLocal ? 0.6 : undefined),
             force: windowPressure, // v0.3.2：逼近窗口时强制压缩（忽略最小阈值门槛）
           });
           if (compacted) {
@@ -240,6 +249,12 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
                 C.dim
               )
             );
+            // v0.4.1 P1 修复：压缩成功后复位 windowPressure——此前永不复位，后续每轮都 force 压缩，
+            // 叠加 compact.js force 分支跳过 2000 token 最小阈值，增量段极短也发真实模型调用持续烧钱。
+            if (windowPressure) {
+              windowPressure = false;
+              pressureWarned = false;
+            }
             try {
               onCompact?.(messages);
             } catch {}
@@ -251,14 +266,25 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       // reasoning 回填防护（Kimi P0 修正）：带 tool_calls 的 assistant 消息必须「完整」回传
       // reasoning_content（DeepSeek thinking_mode 官方要求：后续请求含 tools 时缺/截断即 400，
       // 多轮工具会话必崩）；仅纯文本回复的 reasoning 可裁剪（不回传也不影响）。
+      // v0.4.1 P2 修复：单次遍历构建新数组（O(n)），此前循环内每次替换都 sanitized.map 全量重建（O(n²)）。
       let sanitized = trimmed;
-      for (const m of sanitized) {
+      let dirty = false;
+      for (let i = 0; i < sanitized.length; i++) {
+        const m = sanitized[i];
         const rc = m.reasoning_content;
         if (typeof rc !== 'string' || (Array.isArray(m.tool_calls) && m.tool_calls.length)) continue;
+        let replacement = null;
         if (rc.length > 4000) {
-          sanitized = sanitized.map((/** @type {any} */ x) => (x === m ? { ...x, reasoning_content: `[思考过程已省略（原 ${rc.length} 字）]` } : x));
+          replacement = `[思考过程已省略（原 ${rc.length} 字）]`;
         } else if (rc.length > 1000) {
-          sanitized = sanitized.map((/** @type {any} */ x) => (x === m ? { ...x, reasoning_content: rc.slice(-500) + ' …[思考过程已截断]' } : x));
+          replacement = rc.slice(-500) + ' …[思考过程已截断]';
+        }
+        if (replacement !== null) {
+          if (!dirty) {
+            sanitized = sanitized.slice();
+            dirty = true;
+          }
+          sanitized[i] = { ...m, reasoning_content: replacement };
         }
       }
 
@@ -432,6 +458,10 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
         // 其余模式/工具保持串行，避免多个权限对话框交错。事件顺序（start/render/post/回填）不变。
         const READONLY_BATCH = new Set(['read', 'ls', 'glob', 'grep']);
         const canBatch = permission.mode === 'auto';
+        // v0.4.2（本地模型 507 memory_refusal 修复）：子代理目标为本地模型时，只读子代理不并行——
+        // 多路大 prefill 同时冲进本地推理服务会击穿其单进程内存预算（507 memory_refusal），
+        // 串行化只读子代理避免并发峰值（只读 read/ls/glob/grep 仍并行，它们不额外触发大 prefill）。
+        const subagentIsLocal = resolveModelCaps(cfg, subagentModel(cfg, modelName)).isLocal;
 
         // 预检：解析参数 → PreToolUse 钩子 → 权限检查；拒绝/失败只回填不执行（返回 null）
         // task 工具标记 readOnly 时也可并行（评估 A4：只读子代理 Promise.all）
@@ -584,7 +614,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
             const prep = /** @type {any} */ (await prepTool(tc));
             const name = tc.function?.name || '';
             let batchable = canBatch && Boolean(prep) && !prep.isMcp && READONLY_BATCH.has(name);
-            if (!batchable && canBatch && Boolean(prep) && name === 'task' && prep.args?.readOnly === true) batchable = true;
+            if (!batchable && canBatch && Boolean(prep) && name === 'task' && prep.args?.readOnly === true && !subagentIsLocal) batchable = true;
             batch.push({ prep, batchable });
             i += 1;
             if (!batchable) break;
@@ -717,13 +747,17 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
     stripOrphanCalls();
     // v0.2.8 兜底总结（对齐 DSH）：跑满步数/末轮无正文且未中断时，补一次 no-tool 小输出请求，
     // 让任务以「总结文字 + 交付物清单」收尾，而非静默结束；失败则回退旧行为（text:null）。
+    // v0.4.1 修复：输入轻量化——此前用 trimMessages(messages, budget) 全量历史，本地 q8 量化模型
+    // （prefill ~165 tok/s）≈98k token 的 prefill 逼近/超过 600s 首 token 超时 → 总结请求失败被吞 →
+    // 表现为「输出截断/子代理无反馈」。改用 system + 交付物清单 + 提示（几 k token），慢 prefill 也能秒出总结。
     if (!aborted && messages.length) {
       try {
-        // stripOrphanCalls 残留的空 assistant（无 tool_calls 且 content 为空）回传会触发 API 400，先清掉
-        const lastMsg = messages[messages.length - 1];
-        if (lastMsg.role === 'assistant' && !lastMsg.content && !Array.isArray(lastMsg.tool_calls)) messages.pop();
+        const sys = messages.find((/** @type {any} */ m) => m.role === 'system');
         const wrapReq = [
-          ...trimMessages(messages, budget, count),
+          ...(sys ? [sys] : []),
+          ...(deliverables.length
+            ? [{ role: 'user', content: '已交付文件：\n' + deliverables.map((/** @type {string} */ f) => `- ${f}`).join('\n') }]
+            : []),
           { role: 'user', content: '（系统提示）任务已执行完毕。请用一段话总结刚才完成的工作，列出交付物（文件路径），并说明遗留问题与后续建议。' },
         ];
         currentAc = new AbortController();
@@ -746,7 +780,10 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
         if (wrapRes.text) messages.push({ role: 'assistant', content: wrapRes.text });
         // capHit：本轮因步数上限被迫收尾（任务可能未真正完成）→ 供上层落检查点续跑
         return { text: wrapRes.text || null, reasoning: wrapRes.reasoning || '', usage, steps, finish, truncated: false, aborted: false, capHit: true, durationMs: Date.now() - startedAt, perf: perf() };
-      } catch {}
+      } catch (/** @type {any} */ err) {
+        // v0.4.1：不再静默吞异常——总结失败原因透出，便于定位（此前用户只见「输出截断/无反馈」）
+        try { io.print(style(`⚠ 兜底总结失败：${String(err?.message || err)}`, C.yellow)); } catch {}
+      }
     }
     return { text: null, reasoning: '', usage, steps, finish, truncated: true, aborted: false, capHit: true, durationMs: Date.now() - startedAt, perf: perf() };
     }

package/src/batch.js

@@ -13,7 +13,6 @@ import { resolveProviderConfig } from './providers/index.js';
 import { estimateBatchCost, BATCH_DISCOUNT } from './pricing.js';
 import { recordCacheStats } from './cachestats.js';
 import { approxTokens } from './context.js';
-import { modelPreset } from './models.js';
 
 const DEFAULT_WINDOW = '24h';
 const DEFAULT_ENDPOINT = '/v1/chat/completions';
@@ -120,8 +119,10 @@ export async function runBatch({ cfg, model, questions, workingDir = process.cwd
   if (deduped > 0) onStatus?.(`去重：${deduped} 条重复问题合并（${list.length} → ${unique.length} 条实际提交）`);
 
   // —— 省钱 B2：单问超窗口预检（估算输入 + max_tokens 超过模型窗口 95% 即报错，绝不提交烧钱）——
-  const preset = modelPreset(model) || {};
-  const windowTokens = Number(preset.budgetTokens) || 128000;
+  // v0.4.1 P1 修复：接入 resolveModelCaps 取真实 contextWindow（此前用 preset.budgetTokens 当窗口，
+  // 本地小模型 32k 窗口会套 128000 默认 → 超窗口预检完全失效，提交后烧钱且失败）。
+  const { resolveModelCaps } = await import('./model-caps.js');
+  const windowTokens = resolveModelCaps(cfg, model).contextWindow;
   const sysTokens = approxTokens(systemPrompt);
   for (let i = 0; i < unique.length; i++) {
     const est = sysTokens + approxTokens(unique[i]);

package/src/cli.js

@@ -362,13 +362,21 @@ async function main() {
   let presetBlock = '';
   let presetOverlay = /** @type {Record<string, any>} */ ({});
   if (opts.preset) {
-    const { loadPreset, presetConfigOverrides, presetSystemBlock, listPresets } = await import('./presets.js');
+    const { loadPreset, presetConfigOverrides, presetSystemBlock, presetPermissionOverride, listPresets } = await import('./presets.js');
     activePreset = loadPreset(workingDir, opts.preset);
     if (!activePreset) {
       const names = listPresets(workingDir).map((/** @type {any} */ p) => p.name).join(', ') || '（无可用预设）';
       io.print(style(`⚠ 预设 "${opts.preset}" 不存在。可用：${names}`, C.yellow));
     } else {
       presetOverlay = { ...presetConfigOverrides(activePreset), presetName: activePreset.name };
+      // P0（v0.4.1）：预设 permission 提权防护——预设不得把 ask/readonly 静默改成 auto
+      const permOv = presetPermissionOverride(activePreset, cfg.permission ?? 'ask');
+      if (permOv.escalated) {
+        delete presetOverlay.permission;
+        io.print(style(`⚠ 预设 "${activePreset.name}" 声明 permission=${activePreset.permission} 属提权（当前 ${cfg.permission ?? 'ask'}），已忽略并保持 ${permOv.permission}。`, C.yellow));
+      } else if (activePreset.permission !== undefined) {
+        presetOverlay.permission = permOv.permission;
+      }
       if (!opts.model && presetOverlay.model) modelName = presetOverlay.model;
       presetBlock = presetSystemBlock(activePreset);
       io.print(style(`▣ 已应用智能体预设：${activePreset.name}${activePreset.label ? '（' + activePreset.label + '）' : ''}`, C.cyan));

package/src/commands/diagnose.js

@@ -52,6 +52,21 @@ export async function handleDiagnose(/** @type {any} */ _cmd, /** @type {any} */
     const cfg = loadConfig();
     push(cfg ? redactSensitive(JSON.stringify(cfg, null, 2)) : '（不存在或读取失败）');
 
+    // v0.4.1：模型能力定位——本地模型未声明 contextWindow 会兜底 32k → maxOutput/budget 偏小，
+    // 表现为「输出截断/频繁压缩」。此处显式提示，帮用户自诊。
+    if (cfg?.model) {
+      push('');
+      push('## 当前模型能力');
+      try {
+        const { resolveModelCaps, safeBudget } = await import('../model-caps.js');
+        const caps = resolveModelCaps(cfg, cfg.model);
+        push(`- 模型：${cfg.model}（${caps.isLocal ? '本地部署' : '远程'}）`);
+        push(`- 上下文窗口：${caps.contextWindow}${caps.isLocal && !((cfg.customModels || {})[cfg.model]?.contextWindow) ? '（未在 customModels 声明 contextWindow，按本地兜底 32k——建议声明真实窗口，如 131072，否则输出/预算被压缩）' : ''}`);
+        push(`- 最大输出：${caps.maxOutputTokens} · 预算：${safeBudget(cfg, caps)}`);
+        push(`- 自动路由：${cfg.routing?.enabled ? '开（planner=' + cfg.routing.planner + ' executor=' + cfg.routing.executor + '）' : '关'}`);
+      } catch {}
+    }
+
     push('');
     push('## 凭证库');
     push(`${redactSensitive(credentialsPath())}：${fs.existsSync(credentialsPath()) ? '已存在（内容不打包）' : '无'}`);

package/src/commands/repl.js

@@ -316,7 +316,7 @@ export async function runRepl(ctx) {
         io.print('已清空上下文（会话文件已同步重置）。');
       } else if (cmd === '/preset') {
         // v0.4.0 Agent Preset：列出/切换声明式智能体预设（工具白名单/权限/参数 + 系统提示定制段）
-        const { listPresets, loadPreset, presetConfigOverrides, presetSystemBlock } = await import('../presets.js');
+        const { listPresets, loadPreset, presetConfigOverrides, presetSystemBlock, presetPermissionOverride } = await import('../presets.js');
         if (!arg) {
           const ps = listPresets(workingDir);
           if (!ps.length) io.print(style('（无可用预设。目录：<项目>/.mingdao/presets/、~/.mingdao/presets/、内置 presets/）', C.dim));
@@ -332,6 +332,14 @@ export async function runRepl(ctx) {
         const over = presetConfigOverrides(p);
         // 应用覆盖：权限/参数/工具白名单/模型建议——只进 agentCfg（会话级 overlay），
         // 绝不改写 cfg：否则后续 /model、/think 的 saveConfig 会把预设字段持久化进 config.json。
+        // P0（v0.4.1）：预设 permission 提权防护——不得把 ask/readonly 静默改成 auto
+        const permOv = presetPermissionOverride(p, cfg.permission ?? 'ask');
+        if (permOv.escalated) {
+          delete over.permission;
+          io.print(style(`⚠ 预设 "${p.name}" 声明 permission=${p.permission} 属提权（当前 ${cfg.permission ?? 'ask'}），已忽略并保持 ${permOv.permission}。`, C.yellow));
+        } else if (p.permission !== undefined) {
+          over.permission = permOv.permission;
+        }
         agentCfg = { ...cfg, ...over, presetName: p.name };
         if (over.model) await switchToModel(over.model, { silent: true, persist: false });
         presetBlock = presetSystemBlock(p);

package/src/context.js

@@ -88,9 +88,9 @@ export function trimMessages(/** @type {any} */ messages, /** @type {any} */ bud
       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;
+      // 注：无幂等守卫——回收结果只写在投影副本 out 上、从不回写原 messages（trimMessages 是投影，
+      // 每次调用从原 messages 重新拷贝），故「已回收」标记不会进入下一次调用的输入，无需守卫。
+      // 截断逻辑确定（同输入同输出），字节稳定，不会逐轮嵌套重截（审计 v0.4.1 确认的死代码已移除）。
       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} 字）]` };

package/src/cost-guard.js

@@ -17,6 +17,9 @@ export function costGuardConfig() {
 // 质检 M10：按 cache-stats 文件 mtime 缓存统计结果——文件未变直接复用，
 // 避免 Agent 每步对整文件（可能数千行）重复解析与累加。
 let todayCache = { mtime: -1, size: -1, start: 0, sum: 0 };
+// v0.4.1 P2 修复（TDZ）：todayCostWarned 提到 todayCost 使用点之前声明——
+// 此前在第 44 行才 let 声明、第 36 行已使用（模块加载顺序碰巧掩盖了风险，循环依赖场景会抛 ReferenceError）。
+let todayCostWarned = false;
 export function todayCost() {
   const start = beijingDayStart().getTime();
   try {
@@ -40,7 +43,6 @@ export function todayCost() {
     return null;
   }
 }
-let todayCostWarned = false;
 
 export function costGuardStatus() {
   const g = costGuardConfig();

package/src/mcp.js

@@ -25,11 +25,12 @@ const HANDSHAKE_TIMEOUT_MS = 20000;
 let nextId = 1;
 
 export class McpClient {
-  constructor(/** @type {any} */ name, /** @type {any} */ { command, args = [], env = {} }, /** @type {any} */ workingDir) {
+  constructor(/** @type {any} */ name, /** @type {any} */ { command, args = [], env = {}, trusted = false }, /** @type {any} */ workingDir) {
     this.name = name;
     this.command = command;
     this.args = args;
     this.env = env;
+    this.trusted = trusted === true; // v0.4.1 P0：仅 trusted 服务器的 readOnlyHint 才被信任自动放行
     this.workingDir = workingDir;
     this.tools = /** @type {any[]} */ ([]);
     this.child = null;
@@ -262,7 +263,11 @@ export async function startMcpServers(/** @type {any} */ mcpCfg, /** @type {any}
     },
     isReadonly(/** @type {any} */ prefixedName) {
       const found = this.lookup(prefixedName);
-      return found ? found.client.isReadonly(found.toolName) : false;
+      if (!found) return false;
+      // v0.4.1 P0：未授信服务器（未设 mcpServers.<name>.trusted）即使工具标注 readOnlyHint 也不自动放行——
+      // 服务器可谎称只读绕过权限确认；只有显式 trusted 才信任其标注。
+      if (!found.client.trusted) return false;
+      return found.client.isReadonly(found.toolName);
     },
     status() {
       const rows = [];

package/src/memory.js

@@ -255,7 +255,11 @@ export function retrieveRelevant(/** @type {any[]} */ entries, /** @type {any} *
     return { e, score: overlap / union };
   });
   scored.sort((/** @type {any} */ a, /** @type {any} */ b) => b.score - a.score);
-  return scored.filter((/** @type {any} */ s) => s.score > 0).slice(0, topN).map((/** @type {any} */ s) => s.e);
+  const hits = scored.filter((/** @type {any} */ s) => s.score > 0).slice(0, topN).map((/** @type {any} */ s) => s.e);
+  // v0.4.1 P1 修复：无匹配时回退最近 N 条（entries 按「旧→新」追加，尾部即最新）——此前 filter(score>0)
+  // 在 query 与记忆无共同词时返回空数组，项目记忆完全消失（相关性判断失败 ≠ 记忆不存在）。
+  if (hits.length) return hits;
+  return entries.slice(-topN);
 }
 
 export function appendProjectMemory(/** @type {any} */ workingDir, /** @type {any} */ lines) {

package/src/permissions.js

@@ -31,8 +31,10 @@ function ruleMatches(rule, name, args) {
     if (ruleName !== name) return false;
     const want = rule.slice(idx + 1).trim();
     const have = summarize(name, args).trim();
-    // bash 前缀规则防链式命令绕过：含 && / ; / | / ` / $( 的复合命令不匹配前缀规则，回落权限确认
-    if (name === 'bash' && /&&|\|\||[;|`]|\$\(|\n/.test(have)) return false;
+    // bash 前缀规则防链式命令绕过（P0 安全，v0.4.1）：白名单字符法——前缀规则仅匹配
+    // 单条简单命令（字母数字/空格/下划线/./-/），任何 shell 元字符（&&/||/;|&<>`$()\n\r）都不匹配，
+    // 回落权限确认。黑名单枚举永远追不上绕过手法（单 & 后台串联、重定向、\r 等），白名单才可靠。
+    if (name === 'bash' && !/^[A-Za-z0-9_ ./\\:-]+$/.test(have)) return false;
     if (want.endsWith('*')) return have.startsWith(want.slice(0, -1));
     return have === want;
   }

package/src/presets.js

@@ -136,6 +136,7 @@ export function loadPreset(/** @type {any} */ workingDir, /** @type {any} */ nam
 /**
  * 预设 → cfg 覆盖：只返回预设声明的参数键（其余键保持调用方当前配置）。
  * tools 单独走 cfg.presetTools（白名单在 agent 的 toolsFor 处生效）。
+ * 注意：permission 提权由调用方用 presetPermissionOverride 过滤（防项目级预设提权，见下）。
  */
 export function presetConfigOverrides(/** @type {any} */ preset) {
   const out = /** @type {Record<string, any>} */ ({});
@@ -146,6 +147,26 @@ export function presetConfigOverrides(/** @type {any} */ preset) {
   return out;
 }
 
+// 权限宽松度排序（数值越大越宽松/越危险）。
+const PERM_RANK = /** @type {Record<string, number>} */ ({ readonly: 0, ask: 1, auto: 2 });
+
+/**
+ * 预设 permission 提权防护（P0 安全，v0.4.1）：预设声明的 permission 不得比当前配置更宽松
+ * （如当前 ask → 预设 auto 属提权，忽略并返回当前值）。clone 恶意仓库含 .mingdao/presets/*.json
+ * 声明 auto 时，不能静默跳过用户全部确认。返回 { permission, escalated }：escalated=true 表示已拦截提权。
+ * @param {any} preset @param {string} currentPermission
+ */
+export function presetPermissionOverride(/** @type {any} */ preset, /** @type {any} */ currentPermission) {
+  const want = preset && preset.permission !== undefined ? String(preset.permission) : null;
+  if (!want || !(want in PERM_RANK)) return { permission: currentPermission, escalated: false };
+  const cur = currentPermission in PERM_RANK ? currentPermission : 'ask';
+  if (PERM_RANK[want] > PERM_RANK[cur]) {
+    // 提权：忽略预设值，保持当前更保守的权限
+    return { permission: cur, escalated: true };
+  }
+  return { permission: want, escalated: false };
+}
+
 /** 预设系统提示定制段（无则空串），插入系统提示 BASE 之后。 */
 export function presetSystemBlock(/** @type {any} */ preset) {
   const s = preset && typeof preset.systemPrompt === 'string' ? preset.systemPrompt.trim() : '';

package/src/providers/openai-compatible.js

@@ -49,8 +49,10 @@ export async function chat(/** @type {any} */ { baseUrl, apiKey, model, messages
       const j = JSON.parse(raw);
       if (j?.error?.message) detail = j.error.message;
     } catch {}
+    // 本地模型内存不足（507 memory_refusal）：给可操作降级提示而非裸状态码（v0.4.2 本地模型 507 修复）
+    const hint = res.status === 507 ? '（本地模型内存不足：请压缩上下文、减少并发子任务，或重启模型服务释放内存）' : '';
     /** @type {ApiError} */
-    const e = new Error(`[${model}] API 错误 ${res.status}: ${detail}`);
+    const e = new Error(`[${model}] API 错误 ${res.status}: ${detail}${hint}`);
     e.status = res.status;
     e.headers = res.headers; // 重试退避读取 Retry-After 用
     throw e;

package/src/routing.js

@@ -139,9 +139,13 @@ export async function routeTask(/** @type {any} */ { cfg, provider, currentModel
   return rc.executor === currentModel ? { model: currentModel, reason: null } : { model: rc.executor, reason: '回退执行模型' };
 }
 
-// 子代理模型选择：路由开启时固定 executor
+// 子代理模型选择：路由开启时固定 executor——但当前模型不在路由池（如本地/自定义模型）时
+// 必须跟随当前模型，否则子代理会把 executor 模型名（deepseek-v4-flash）发到当前模型的 baseUrl
+// （本地 8081），服务端不认识 → 400 → 子代理全灭，表现为主线程「子代理无反馈」。
 export function subagentModel(/** @type {any} */ cfg, /** @type {any} */ currentModel) {
   const rc = routingConfig(cfg);
   if (!rc) return currentModel;
+  // v0.4.1 修复：与 routeTask 的池外检查一致——当前模型不在 planner/executor 池内时不干预
+  if (currentModel !== rc.planner && currentModel !== rc.executor) return currentModel;
   return modelPreset(rc.executor) ? rc.executor : currentModel;
 }

package/src/tools/bash.js

@@ -34,8 +34,16 @@ export function detectSandbox() {
   sandboxSupport = 'none';
   if (process.platform === 'linux') {
     try {
-      const r = spawnSync('bwrap', ['--version'], { stdio: 'ignore', timeout: 3000 });
-      sandboxSupport = r.error ? 'none' : 'bwrap';
+      // v0.4.1 P1 修复：实际能力探测而非仅 --version——bwrap 存在但 /proc 挂载受限（Docker/devcontainer/
+      // CI 流水线等容器环境）时 --version 能跑、真正建沙箱却失败。用最小真实沙箱命令验证：
+      // --ro-bind / / --tmpfs /tmp true 能成功退出 0 才算可用，否则降级 none（runBash 会注明降级）。
+      const v = spawnSync('bwrap', ['--version'], { stdio: 'ignore', timeout: 3000 });
+      if (v.error) {
+        sandboxSupport = 'none';
+      } else {
+        const probe = spawnSync('bwrap', ['--die-with-parent', '--ro-bind', '/', '/', '--dev', '/dev', '--proc', '/proc', '--tmpfs', '/tmp', 'true'], { stdio: 'ignore', timeout: 5000 });
+        sandboxSupport = probe.error || probe.status !== 0 ? 'none' : 'bwrap';
+      }
     } catch {
       sandboxSupport = 'none';
     }

package/src/tools/fetch.js

@@ -9,7 +9,7 @@ function isPrivateHost(/** @type {string} */ hostname) {
   if (h === 'localhost' || h.endsWith('.localhost') || h === '::1') return true;
   if (h.includes(':')) {
     if (/^::ffff:/.test(h)) return isPrivateHost(h.slice(7));
-    return /^fe[89ab]/.test(h) || /^f[c d]/.test(h) || h === '::' || h === '::1';
+    return /^fe[89ab]/.test(h) || /^f[cd]/.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;
@@ -39,10 +39,42 @@ export async function runFetch(/** @type {any} */ args, /** @type {any} */ _ctx)
     }
   }
   if (blocked) return { ok: false, error: `拒绝访问内网/本机地址（${host}）——SSRF 防护。` };
+  // 302 重定向复检（P0 安全，v0.4.1）：redirect:'follow' 只检查初始 URL，攻击者可用公网 302 跳回内网。
+  // 改 redirect:'manual' 手动跟随，每一跳重新 isPrivateHost + DNS 复检，跳数上限 5。
   const ac = new AbortController();
   const timer = setTimeout(() => ac.abort(), 15000);
   try {
-    const res = await fetch(u, { signal: ac.signal, redirect: 'follow' });
+    let cur = u;
+    let res = /** @type {any} */ (null);
+    for (let hop = 0; hop <= 5; hop++) {
+      if (hop > 5) return { ok: false, error: '重定向次数超过上限（5 跳）。' };
+      const ch = String(cur.hostname || '').toLowerCase();
+      let hopBlocked = isPrivateHost(ch);
+      if (!hopBlocked && ch && ch !== 'localhost' && !/^\d{1,3}(\.\d{1,3}){3}$/.test(ch)) {
+        try {
+          const addrs = await lookup(ch, { all: true, verbatim: true });
+          hopBlocked = addrs.some((/** @type {any} */ a) => isPrivateHost(a.address));
+        } catch {
+          // DNS 解析失败：放行，连接阶段会报错
+        }
+      }
+      if (hopBlocked) return { ok: false, error: `拒绝访问内网/本机地址（${ch}）——SSRF 重定向防护。` };
+      res = await fetch(cur, { signal: ac.signal, redirect: 'manual' });
+      if (res.status >= 300 && res.status < 400) {
+        const loc = res.headers.get('location');
+        if (!loc) break; // 无 Location：按最终响应处理
+        try {
+          cur = new URL(loc, cur);
+        } catch {
+          return { ok: false, error: `非法重定向地址：${loc}` };
+        }
+        if (cur.protocol !== 'http:' && cur.protocol !== 'https:') {
+          return { ok: false, error: '重定向到非 http(s) 地址，已拒绝。' };
+        }
+        continue;
+      }
+      break;
+    }
     const buf = await res.arrayBuffer();
     clearTimeout(timer);
     if (buf.byteLength > 512 * 1024) return { ok: false, error: `响应超过 512KB 上限（实际 ${buf.byteLength} 字节）。` };

package/src/tools/fs-tools.js

@@ -19,6 +19,53 @@ function resolvePath(cwd, p) {
   return path.resolve(cwd, p);
 }
 
+// —— 路径穿越防护（P0 安全，v0.4.1）——
+// 文件工具限定在「工作目录 + config.fsAllowDirs 白名单」内；realpath 逐级校验防软链接逃逸。
+// auto 模式下模型（或被提示注入诱导）也无法 read ~/.ssh、~/.mingdao/credentials.json 等越界文件。
+// 白名单：config.json 的 fsAllowDirs 数组（绝对目录），需要访问工作目录外时显式添加。
+function normCmp(/** @type {any} */ p) {
+  return process.platform === 'win32' ? String(p).toLowerCase() : String(p);
+}
+function realPathOrNull(/** @type {any} */ p) {
+  try {
+    return normCmp(fs.realpathSync(p));
+  } catch {
+    return null;
+  }
+}
+// 判断 target 是否在 root 内：对 target 逐级向上找最近的已存在祖先 realpath，再与 root realpath 比较。
+// （write 新文件时父目录可能尚不存在，逐级向上即可正确处理；软链接已被 realpath 展开。）
+function withinRoot(/** @type {any} */ root, /** @type {any} */ target) {
+  const rr = realPathOrNull(root);
+  if (!rr) return false;
+  let cur = target;
+  for (let i = 0; i < 64; i++) {
+    const rp = realPathOrNull(cur);
+    if (rp) return rp === rr || rp.startsWith(rr + path.sep);
+    const parent = path.dirname(cur);
+    if (parent === cur) return false;
+    cur = parent;
+  }
+  return false;
+}
+/**
+ * 解析路径并做工作目录边界检查。
+ * @param {any} ctx
+ * @param {any} p
+ * @returns {{ ok: true, path: string } | { ok: false, error: string }}
+ */
+function boundedPath(/** @type {any} */ ctx, /** @type {any} */ p) {
+  const cwd = ctx?.cwd || ctx?.workingDir || process.cwd();
+  const raw = resolvePath(cwd, p ?? '');
+  if (!raw) return { ok: false, error: '缺少 path 参数。' };
+  const allowDirs = Array.isArray(ctx?.cfg?.fsAllowDirs) ? ctx.cfg.fsAllowDirs : [];
+  const roots = [cwd, ...allowDirs.map((/** @type {any} */ d) => path.resolve(String(d)))];
+  for (const r of roots) {
+    if (withinRoot(r, raw)) return { ok: true, path: raw };
+  }
+  return { ok: false, error: `路径越界（工作目录外）：${raw}。如需访问请将目录加入 config.fsAllowDirs 白名单。` };
+}
+
 /**
  * @param {any} buf
  */
@@ -76,7 +123,7 @@ function backup(ctx, p) {
 export function undo(args, ctx) {
   const store = ctx?.undoStore?.backups;
   if (!(store instanceof Map) || !store.size) return { ok: false, error: '没有可撤销的修改。' };
-  const p = args.path ? resolvePath(ctx.cwd, args.path) : null;
+  const p = args.path ? (() => { const bb = boundedPath(ctx, args.path); return bb.ok ? bb.path : null; })() : null;
   if (p) {
     const list = store.get(p);
     if (!list?.length) return { ok: false, error: `${p} 没有可撤销的修改记录。` };
@@ -124,8 +171,9 @@ export function invalidateReadCache(p) {
  */
 export function read(args, ctx) {
   try {
-    const p = resolvePath(ctx.cwd, args.path ?? '');
-    if (!p) return { ok: false, error: '缺少 path 参数。' };
+    const b = boundedPath(ctx, args.path ?? '');
+    if (!b.ok) return b;
+    const p = b.path;
     const st = fs.statSync(p);
     if (st.isDirectory()) return { ok: false, error: `"${p}" 是目录，请使用 ls 查看。` };
     if (st.size > MAX_FILE_BYTES) {
@@ -181,8 +229,9 @@ const MAX_WRITE_BYTES = 2 * 1024 * 1024; // write 单次内容上限（防模型
  */
 export function write(args, ctx) {
   try {
-    const p = resolvePath(ctx.cwd, args.path ?? '');
-    if (!p) return { ok: false, error: '缺少 path 参数。' };
+    const b = boundedPath(ctx, args.path ?? '');
+    if (!b.ok) return b;
+    const p = b.path;
     const content = String(args.content ?? '');
     if (Buffer.byteLength(content) > MAX_WRITE_BYTES) {
       return { ok: false, error: `内容超过 ${MAX_WRITE_BYTES / 1024 / 1024}MB 上限，请分多次写入。` };
@@ -222,11 +271,12 @@ function regionAround(text, lineStart, lineCount, context = 2) {
  */
 export function edit(args, ctx) {
   try {
-    const p = resolvePath(ctx.cwd, args.path ?? '');
+    const b = boundedPath(ctx, args.path ?? '');
+    if (!b.ok) return b;
+    const p = b.path;
     const oldString = String(args.old_string ?? '');
     const newString = String(args.new_string ?? '');
     const replaceAll = Boolean(args.replace_all);
-    if (!p) return { ok: false, error: '缺少 path 参数。' };
     if (!oldString) return { ok: false, error: '缺少 old_string 参数。' };
     try {
       if (fs.statSync(p).size > MAX_FILE_BYTES) {
@@ -265,7 +315,9 @@ export function edit(args, ctx) {
  */
 export function ls(args, ctx) {
   try {
-    const p = resolvePath(ctx.cwd, args.path || '.');
+    const b = boundedPath(ctx, args.path || '.');
+    if (!b.ok) return b;
+    const p = b.path;
     const entries = fs.readdirSync(p, { withFileTypes: true });
     const rows = entries
       .map((e) => {
@@ -354,7 +406,9 @@ function walkFiles(root, visitor) {
 export function glob(args, ctx) {
   try {
     const pattern = String(args.pattern ?? '*');
-    const root = resolvePath(ctx.cwd, args.path || '.');
+    const b = boundedPath(ctx, args.path || '.');
+    if (!b.ok) return b;
+    const root = b.path;
     if (!fs.existsSync(root)) return { ok: false, error: `目录不存在：${root}` };
     const re = globToRegExp(pattern);
     const matchRel = pattern.includes('/');
@@ -401,7 +455,9 @@ export function grep(args, ctx) {
     const MAX_LINE = 20 * 1024;
     /** @type {(line: any) => any} */
     const testLine = (line) => (line.length > MAX_LINE ? re.test(line.slice(0, MAX_LINE)) : re.test(line));
-    const root = resolvePath(ctx.cwd, args.path || '.');
+    const root0 = boundedPath(ctx, args.path || '.');
+    if (!root0.ok) return root0;
+    const root = root0.path;
     const include = args.include ? globToRegExp(String(args.include)) : null;
     /** @type {any[]} */
     const matches = [];

package/src/tools/git.js

@@ -14,10 +14,18 @@ export async function runGit(/** @type {any} */ args, /** @type {any} */ ctx) {
   if (!GIT_READONLY.has(sub)) {
     return { ok: false, error: `git ${sub} 不是只读子命令（仅支持 ${[...GIT_READONLY].join(' / ')}）。写操作请用 bash 并注意授权。` };
   }
-  // 追加默认防超大输出：log/diff 限量（除非模型显式给了 -n/--max-count）
+  // 追加默认防超大输出：log/diff 限量（除非模型显式给了 -n/--max-count）——
+  // v0.4.1 P2 修复：此前注释声明限量但无实现，git log -p 在大型仓库会撞 maxBuffer 4MB 报 ENOBUFS。
+  let effectiveArgv = argv;
+  if ((sub === 'log' || sub === 'shortlog') && !argv.some((/** @type {string} */ a) => /^-(n|\d+)$/.test(a) || a === '--max-count')) {
+    effectiveArgv = [...argv, '-n', '50'];
+  } else if (sub === 'diff' && !argv.some((/** @type {string} */ a) => a === '--stat')) {
+    // diff 全量可能极巨：默认 --stat 概览，模型需要全文再显式加 --no-stat 或指定文件
+    effectiveArgv = [...argv, '--stat'];
+  }
   const cwd = ctx.workingDir || process.cwd();
   try {
-    const { stdout, stderr } = await execFile('git', argv, {
+    const { stdout, stderr } = await execFile('git', effectiveArgv, {
       cwd,
       timeout: 15000,
       maxBuffer: 4 * 1024 * 1024,

package/src/tools/index.js

@@ -6,7 +6,7 @@ import { runBash } from './bash.js';
 import { runGit } from './git.js';
 import { runFetch } from './fetch.js';
 import { listSkills, loadSkill } from '../skills.js';
-import { spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 
 // 只读工具集合的单一来源：permissions.js 引用此导出，新增只读工具时只需改这里
 export const READONLY_TOOLS = new Set(['read', 'glob', 'grep', 'ls', 'skill', 'git', 'fetch']);
@@ -254,7 +254,9 @@ const CUSTOM_TOOL_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
 
 /**
  * 注册第三方工具（进程级，重复注册同名会报错——避免静默覆盖）。
- * @param {{ name: string, description?: string, parameters?: any, run: (args: any, ctx: any) => any | Promise<any> }} tool
+ * readOnly（v0.4.1 P2 新增）：标注后进 READONLY_TOOLS 集合——只读档自动放行、ask 档不询问、
+ * 只读子代理可用。默认 false（写类/副作用工具仍走权限询问）。
+ * @param {{ name: string, description?: string, parameters?: any, readOnly?: boolean, run: (args: any, ctx: any) => any | Promise<any> }} tool
  */
 export function registerTool(/** @type {any} */ tool) {
   const name = String(tool?.name ?? '').trim();
@@ -279,11 +281,18 @@ export function registerTool(/** @type {any} */ tool) {
       function: { name, description: String(tool.description || ''), parameters },
     },
     run: tool.run,
+    readOnly: tool.readOnly === true,
   };
   customTools.set(name, entry);
+  if (tool.readOnly === true) READONLY_TOOLS.add(name);
   return entry.schema;
 }
 
+/** 判断第三方工具是否标注只读。 */
+export function isRegisteredToolReadonly(/** @type {any} */ name) {
+  return customTools.get(name)?.readOnly === true;
+}
+
 /** 已注册的第三方工具名列表。 */
 export function listRegisteredTools() {
   return [...customTools.keys()];
@@ -318,26 +327,49 @@ export function mountConfigTools(/** @type {any} */ cfg) {
         name,
         description: String(e.description || ''),
         parameters: e.parameters,
-        run: (/** @type {any} */ args, /** @type {any} */ ctx) => {
-          const shell = process.platform === 'win32' ? 'cmd.exe' : '/bin/bash';
-          const shellArgs = process.platform === 'win32' ? ['/d', '/s', '/c', e.command] : ['-lc', e.command];
-          const r = spawnSync(shell, shellArgs, {
-            cwd: ctx.cwd,
-            env: { ...process.env, MINGDAO_TOOL_ARGS: JSON.stringify(args ?? {}) },
-            timeout: Math.min(Number(e.timeout) > 0 ? Number(e.timeout) : 120, 600) * 1000,
-            maxBuffer: 2 * 1024 * 1024,
-          });
-          const out = String(r.stdout || '');
-          const err = String(r.stderr || '');
-          const capped = out.length > 20000 ? out.slice(0, 20000) + `\n…[输出过长已截断，共 ${out.length} 字]` : out;
-          return {
-            ok: r.error ? false : (r.status ?? 0) === 0,
-            exitCode: r.error ? null : (r.status ?? null),
-            output: (capped || '（无输出）').trim(),
-            ...(err.trim() ? { stderr: err.trim().slice(0, 4000) } : {}),
-            ...(r.error ? { error: `命令执行失败：${String(r.error?.message || r.error)}` } : {}),
-          };
-        },
+        // v0.4.1 P1 修复：异步 spawn 而非 spawnSync——spawnSync 最长阻塞 600s，WebUI 下单个请求
+        // 即冻结整个 Node 进程（所有并发会话/权限确认/SSE 流全无响应）。异步执行不阻塞事件循环。
+        run: (/** @type {any} */ args, /** @type {any} */ ctx) =>
+          new Promise((resolve) => {
+            const shell = process.platform === 'win32' ? 'cmd.exe' : '/bin/bash';
+            const shellArgs = process.platform === 'win32' ? ['/d', '/s', '/c', e.command] : ['-lc', e.command];
+            const timeoutMs = Math.min(Number(e.timeout) > 0 ? Number(e.timeout) : 120, 600) * 1000;
+            const child = spawn(shell, shellArgs, {
+              cwd: ctx.cwd,
+              env: { ...process.env, MINGDAO_TOOL_ARGS: JSON.stringify(args ?? {}) },
+            });
+            let out = '';
+            let err = '';
+            let done = false;
+            let timedOut = false;
+            const cap = (/** @type {any} */ s, /** @type {any} */ d) => {
+              const t = s + d;
+              return t.length > 20000 * 2 ? t.slice(-20000 * 2) : t;
+            };
+            const finish = (/** @type {any} */ result) => {
+              if (done) return;
+              done = true;
+              clearTimeout(timer);
+              resolve(result);
+            };
+            const timer = setTimeout(() => {
+              timedOut = true;
+              try { child.kill('SIGKILL'); } catch {}
+            }, timeoutMs);
+            child.stdout.on('data', (d) => { out = cap(out, d); });
+            child.stderr.on('data', (d) => { err = cap(err, d); });
+            child.on('error', (er) => finish({ ok: false, error: `命令执行失败：${String(er?.message || er)}` }));
+            child.on('close', (code) => {
+              const capped = out.length > 20000 ? out.slice(0, 20000) + `\n…[输出过长已截断，共 ${out.length} 字]` : out;
+              finish({
+                ok: timedOut ? false : (code ?? 0) === 0,
+                exitCode: timedOut ? null : (code ?? null),
+                output: (capped || '（无输出）').trim(),
+                ...(err.trim() ? { stderr: err.trim().slice(0, 4000) } : {}),
+                ...(timedOut ? { error: `命令执行超时（${Math.round(timeoutMs / 1000)}s），已终止` } : {}),
+              });
+            });
+          }),
       });
       mountedConfigTools.add(name);
       mounted.push(name);

package/src/web/app.js

@@ -64,6 +64,7 @@ function initTips() {
   const perm = $('#permSel'); if (perm) attachTip(perm, perm.getAttribute('title'));
   const reas = $('#reasoningSel'); if (reas) attachTip(reas, reas.getAttribute('title'));
   const model = $('#modelSel'); if (model) attachTip(model, () => { const o = model.options[model.selectedIndex]; return (o && o.title) ? o.title : '切换模型'; });
+  const preset = $('#presetSel'); if (preset) attachTip(preset, () => { const o = preset.options[preset.selectedIndex]; return (o && o.title) ? o.title : '智能体预设：一键切换工具白名单/权限/参数组合（选「无预设」恢复默认）'; });
   const at = $('#attachBtn'); if (at) attachTip(at, at.getAttribute('title'));
 }
 initTips();
@@ -148,6 +149,7 @@ $('#dirPickOk').onclick = () => { const cb = pickerCb; pickerCb = null; $('#dirM
 $('#dirPickNone').onclick = () => { const cb = pickerCb; pickerCb = null; $('#dirModal').style.display = 'none'; if (cb) cb(null); };
 $('#dirPickCancel').onclick = () => { pickerCb = null; $('#dirModal').style.display = 'none'; };
 const chatEl = $('#chat'), input = $('#input'), sendBtn = $('#sendBtn');
+let presetData = []; // v0.4.0 Agent Preset：预设列表缓存（含 description/tools/permission，供下拉提示与选中反馈）
 let activeAiMsg=null, bgRunning=0, curSteps=0, curWorkT0=0, curTools=0, curTasks=0; // 本轮进度（活动条/状态条/轨迹共用）
 let bgTasks=[]; // 后台任务列表快照（chip tooltip 详情用，updateTasksPanel 每 2s 刷新）
 let curPhase='模型推理中'; // 阶段语义（服务端 progress 事件下发）
@@ -615,6 +617,23 @@ function applyReasoningUI(reasoning){
   sel.value = ['off','low','high','max'].includes(effort) ? effort : 'high';
 }
 $('#reasoningSel').onchange=()=>{ applyConfig({reasoningEffort:$('#reasoningSel').value}); };
+// v0.4.0 Agent Preset：选中预设时给出「这是什么 / 覆盖了什么」的即时反馈（否则用户不知道各选项作用）
+$('#presetSel').onchange=()=>{ presetPicked(); };
+function presetPicked(){
+  const val=$('#presetSel')?.value||'';
+  const p=presetData.find((x)=>x.name===val);
+  if(!p){ renderBanner({ text: '已取消预设，恢复默认配置（不注入预设定制段/白名单/权限覆盖）。' }); return; } // 选回「无预设」= 退出预设模式
+  const over=[];
+  if(Array.isArray(p.tools)) over.push('工具白名单 '+p.tools.length+' 个');
+  if(p.permission) over.push('权限 '+p.permission);
+  if(p.model) over.push('模型 '+p.model);
+  if(p.maxRounds) over.push('maxRounds '+p.maxRounds);
+  if(p.maxOutputTokens) over.push('maxOutput '+p.maxOutputTokens);
+  if(p.temperature!==undefined) over.push('温度 '+p.temperature);
+  if(p.contextBudget) over.push('预算 '+p.contextBudget);
+  const summary=over.length?'（覆盖：'+over.join(' · ')+'）':'';
+  renderBanner({ text: '🧩 已选预设「'+(p.label||p.name)+'」：'+(p.description||'（无描述）')+summary+'。随本次发送生效，其余设置保持不变。' });
+}
 async function init(){
   try{
     const r=await fetch('/api/state',{cache:'no-store'}); const j=await r.json();
@@ -653,7 +672,8 @@ async function init(){
   try{
     // v0.4.0 Agent Preset：加载预设列表进下拉（项目 → 用户 → 内置）
     const pr=await fetch('/api/presets',{cache:'no-store'}).catch(()=>null); const pj=pr?await pr.json():{presets:[]};
-    const psel=$('#presetSel'); if(psel&&pj.presets){ for(const p of pj.presets){ const o=document.createElement('option'); o.value=p.name; o.textContent=p.label+'（'+(p.source==='project'?'项目':p.source==='user'?'用户':'内置')+'）'; o.title=p.description||p.name; psel.appendChild(o); } }
+    presetData = Array.isArray(pj.presets) ? pj.presets : [];
+    const psel=$('#presetSel'); if(psel&&presetData.length){ for(const p of presetData){ const o=document.createElement('option'); o.value=p.name; o.textContent=p.label+'（'+(p.source==='project'?'项目':p.source==='user'?'用户':'内置')+'）'; o.title=p.description||p.name; psel.appendChild(o); } }
   }catch(e){}
   try{
     const dr=await fetch('/api/draft?file='+encodeURIComponent(currentSession||''),{cache:'no-store'}); const dj=await dr.json();
@@ -930,7 +950,8 @@ async function refreshModelsCfg(){
     div.innerHTML='<span style="flex:1;min-width:0"><b>'+esc(c.name)+'</b> <span style="color:var(--faint)">'+esc(c.label)+' · '+esc(c.baseUrl)+'</span></span><span style="white-space:nowrap">'+kstate+'</span>';
     const sk=document.createElement('button'); sk.textContent='设Key'; sk.style.cssText='padding:1px 8px;font-size:11px'; sk.onclick=async()=>{ const k=await uiPrompt('API Key（'+c.name+'）：', null, {hidden:true}); if(k===null) return; fetch('/api/models-config',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'setCustomKey',name:c.name,key:k})}).then(rr=>rr.json()).then(jj=>{ if(jj.ok) refreshModelsCfg(); else uiAlert(jj.error||'设置失败'); }); };
     const test=document.createElement('button'); test.textContent='测试'; test.style.cssText='padding:1px 8px;font-size:11px'; test.onclick=async()=>{ test.disabled=true; test.textContent='测试中…'; try{ const rr=await fetch('/api/models-config',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'testCustom',name:c.name})}); const jj=await rr.json().catch(()=>({error:'请求失败'})); if(jj.ok){ await uiAlert('✅ 连接成功（'+jj.latencyMs+'ms）：'+esc(jj.reply||'空回复')); } else { await uiAlert('✖ 连接失败：'+esc(jj.error||'未知错误')); } } finally { test.disabled=false; test.textContent='测试'; } };
-    const ed=document.createElement('button'); ed.textContent='修改'; ed.style.cssText='padding:1px 8px;font-size:11px'; ed.onclick=async()=>{ const u=await uiPrompt('API 地址：', c.baseUrl); if(u===null) return; const l=await uiPrompt('标签：', c.label); if(l===null) return; fetch('/api/models-config',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'updateCustom',name:c.name,baseUrl:u,label:l})}).then(rr=>rr.json()).then(jj=>{ if(jj.ok){ refreshModelsCfg(); reloadModels(); } else uiAlert(jj.error||'修改失败'); }); };
+    const ed=document.createElement('button'); ed.textContent='修改'; ed.style.cssText='padding:1px 8px;font-size:11px'; ed.onclick=async()=>{ const u=await uiPrompt('API 地址：', c.baseUrl); if(u===null) return; const l=await uiPrompt('标签：', c.label); if(l===null) return; // v0.4.1：本地模型上下文窗口/最大输出可在设置里直接改（此前只能改 baseUrl+label，本地模型补 contextWindow 需手改 config.json）
+    const cw=await uiPrompt('上下文窗口 tokens（本地模型必填，如 131072；留空=不变）', c.contextWindow||''); if(cw===null) return; const mo=await uiPrompt('最大输出 tokens（可选，如 8192；留空=不变）', c.maxOutputTokens||''); if(mo===null) return; fetch('/api/models-config',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'updateCustom',name:c.name,baseUrl:u,label:l,contextWindow:Number(cw)||undefined,maxOutputTokens:Number(mo)||undefined})}).then(rr=>rr.json()).then(jj=>{ if(jj.ok){ refreshModelsCfg(); reloadModels(); } else uiAlert(jj.error||'修改失败'); }); };
     const rm=document.createElement('button'); rm.textContent='删除'; rm.className='danger'; rm.style.cssText='padding:1px 8px;font-size:11px'; rm.onclick=async()=>{ if(!await uiConfirm('删除自定义模型 '+c.name+'？')) return; const rr=await fetch('/api/models-config',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'removeCustom',name:c.name})}); const jj=await rr.json().catch(()=>({error:'失败'})); if(jj.ok){ refreshModelsCfg(); reloadModels(); } else uiAlert(jj.error||'删除失败'); };
     div.appendChild(sk); div.appendChild(test); div.appendChild(ed); div.appendChild(rm); cl.appendChild(div);
   }

package/src/web/index.html

@@ -332,7 +332,7 @@ footer{flex:none;border-top:1px solid var(--border);background:var(--bg2);paddin
       <option value="readonly">只读</option>
     </select>
     <select id="modelSel" title="切换模型"></select>
-    <select id="presetSel" title="智能体预设：一键切换工具白名单/权限/参数组合（v0.4.0 契约化）"><option value="">预设…</option></select>
+    <select id="presetSel" title="智能体预设：一键切换工具白名单/权限/参数组合（选「无预设」恢复默认）"><option value="">无预设</option></select>
     <select id="reasoningSel" title="思考模式（推理等级）：关＝不推理省 token · 低 · 高（默认）· 最高＝最强推理" style="display:none">
       <option value="off">关</option>
       <option value="low">低</option>

package/src/web/server.js

@@ -257,7 +257,7 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken
     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';
+      return /^fe[89ab]/.test(h) || /^f[cd]/.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; // 域名：由 validateRemoteUrl 的 DNS 解析复检
@@ -421,10 +421,18 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken
     let presetBlock = '';
     let chatCfg = cfg;
     if (typeof body.preset === 'string' && body.preset) {
-      const { loadPreset, presetConfigOverrides, presetSystemBlock } = await import('../presets.js');
+      const { loadPreset, presetConfigOverrides, presetSystemBlock, presetPermissionOverride } = await import('../presets.js');
       chatPreset = loadPreset(taskDir, body.preset);
       if (chatPreset) {
         const over = presetConfigOverrides(chatPreset);
+        // P0（v0.4.1）：预设 permission 提权防护——不得把 ask/readonly 静默改成 auto
+        const permOv = presetPermissionOverride(chatPreset, cfg.permission ?? 'ask');
+        if (permOv.escalated) {
+          delete over.permission;
+          send({ type: 'banner', text: `⚠ 预设 "${chatPreset.name}" 声明 permission=${chatPreset.permission} 属提权（当前 ${cfg.permission ?? 'ask'}），已忽略并保持 ${permOv.permission}。` });
+        } else if (chatPreset.permission !== undefined) {
+          over.permission = permOv.permission;
+        }
         chatCfg = { ...cfg, ...over, presetName: chatPreset.name };
         presetBlock = presetSystemBlock(chatPreset);
       } else {