mingdao-harness 0.6.2 → 0.6.4

package/src/hooks.js

@@ -92,19 +92,54 @@ export function createHooks(hooksCfg = {}, /** @type {any} */ workingDir, /** @t
       // cmd:'true' / echo 形式的策略脚本）且载荷超过管道缓冲（约 64KB，write 大文件时必然发生），
       // write 的 EPIPE 会作为异步 error 事件抛出——无人监听即未捕获异常，整个进程崩溃
       // （WebUI 场景下所有并发会话一起死）。write() 本身的 try/catch 捕不到异步事件。
-      child.stdin.on('error', () => {});
+      //
+      // v0.6.3（审计 BUG-042）：**但不能只吞不报**。载荷没送到时 hook 的判定不可信，
+      // 而本模块把「空输出」当作**放行**——于是 v0.4.6 这个"防崩溃"的监听顺带造成 fail-open：
+      // 一次本该拦截的策略因为没收到载荷而被静默通过。现在记下失败，在 close 时收口。
+      /** @type {string|null} */
+      let stdinFailed = null;
+      // v0.6.3（BUG-042 第二版修复）：**不能依赖 error 事件的到达时机**。
+      //
+      // 第一版只看 `stdinFailed`（stdin 'error'）。它在 Linux 上是竞态：子进程若 `dup` 过
+      // fd 0（libuv 对 stdin 的常见处理），关闭 fd 0 并不会让父进程立刻拿到 EPIPE——
+      // 要等子进程真正退出、内核回收重复描述符之后才会送达。于是 child 'close' 与
+      // stdin 'error' 谁先到取决于调度：macOS 上 error 先到（本地 5/5 通过），
+      // ubuntu Node 18/20 上 close 先到 → 空输出被当成「放行」，用例在 CI 上红。
+      //
+      // 改成看**可完成的写入**：`end()` 之后 'finish' 表示载荷已全部交给内核（对端读过），
+      // 'error' 表示失败，两者都不发生就说明载荷**从未送达**。这个判据不依赖事件先后：
+      //   · 读了 stdin 的 hook → finish 必然在它退出前触发（数据在它读走时就进了内核）；
+      //   · 没读 stdin 的 hook → finish 永不触发，close 时按「未送达」处理。
+      let stdinFlushed = false;
+      child.stdin.on('finish', () => {
+        stdinFlushed = true;
+      });
+      child.stdin.on('error', (e) => {
+        stdinFailed = String(/** @type {any} */ (e)?.message ?? e);
+      });
       child.on('error', (e) => {
         clearTimeout(timer);
         finish({ ok: false, error: `hook 启动失败：${e.message}` });
       });
       child.on('close', (code) => {
         clearTimeout(timer);
+        // 载荷没送进去、且 hook 也没给出任何判定 → 这次运行**不可信**，按 hook 失败处理
+        // （调用方 !ok → block，fail-closed）。若 hook 仍给出了输出，说明它本就没打算读 stdin
+        // （例如 `echo '{"decision":"approve"}'`），那种情况下尊重它的判定，避免误伤既有策略。
+        if (!String(out).trim() && (stdinFailed || !stdinFlushed)) {
+          const why = stdinFailed ?? '载荷未写完（子进程可能未读取 stdin 就退出）';
+          finish({ ok: false, error: `hook 输入写入失败：${why}` });
+          return;
+        }
         finish({ ok: true, exitCode: code, output: out, stderr: err });
       });
       try {
         child.stdin.write(JSON.stringify(payload));
         child.stdin.end();
-      } catch {}
+      } catch (e) {
+        // 同步抛出与异步 error 同源，统一交给 close 收口（不在这里 finish，避免重复结算）
+        stdinFailed = String(/** @type {any} */ (e)?.message ?? e);
+      }
     });
   }
 

package/src/ledger.js

@@ -18,7 +18,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { atomicWriteFileSync } from './atomic-write.js';
+import { atomicWriteFileSync, appendFilePrivateSync } from './atomic-write.js';
 import { mingdaoHome, ensureHome } from './config.js';
 import { redactSecrets, redactSensitive } from './redact.js';
 
@@ -119,10 +119,10 @@ export function createLedger(runId, { enabled = true, maxRuns = DEFAULT_MAX_RUNS
     if (!alive) return null;
     try {
       ensureHome();
-      fs.mkdirSync(ledgerDir(), { recursive: true });
+      fs.mkdirSync(ledgerDir(), { recursive: true, mode: 0o700 });
       const event = { v: LEDGER_VERSION, runId, seq: seq + 1, at: now(), type, prev, ...redactDeep(payload) };
       const line = JSON.stringify(event);
-      fs.appendFileSync(runFile(runId), line + '\n');
+      appendFilePrivateSync(runFile(runId), line + '\n');
       try {
         fs.chmodSync(runFile(runId), 0o600);
       } catch {}

package/src/log-writer.js

@@ -1,16 +1,9 @@
-// 统一日志写入器（质检 A6）：追加写 + 超限按行截断（原子替换，绝不截断在行中间）。
+// 统一日志写入器（质检 A6）：追加写 + 超限轮转（v0.6.3 起为改名式，见下方说明）。
 // 桌面主进程（appLog）与 Web 服务端（srvlog）共用同一实现，消除双文件口径漂移与 O(n) 全量重写。
 import fs from 'node:fs';
 import path from 'node:path';
-import crypto from 'node:crypto';
 
 export function createLogWriter(/** @type {string} */ file, { maxBytes = 512 * 1024 } = {}) {
-  // 轮转低水位（v0.4.6 P2 修复）：保留到 maxBytes/2 而不是刚好卡在上限。
-  // 此前 `cut = raw.length - maxBytes` 让保留区恰好等于上限，文件在轮转后立刻又超限，
-  // 于是**每次追加都整文件重写**（实测：上限之后 2000 次追加 = 2000 次全量读写 ≈1GB I/O）。
-  // 另外 raw.length 是 UTF-16 码元数、st.size 是字节数，中文日志下 cut 直接变负 → 只砍掉一行。
-  // 改为按字节定位行边界（Buffer.lastIndexOf(0x0a)），并留出一半余量。
-  const keepBytes = Math.max(1, Math.floor(maxBytes / 2));
   return (/** @type {string} */ msg) => {
     try {
       fs.mkdirSync(path.dirname(file), { recursive: true });
@@ -23,17 +16,29 @@ export function createLogWriter(/** @type {string} */ file, { maxBytes = 512 * 1
         fs.appendFileSync(file, line);
         try { fs.chmodSync(file, 0o600); } catch {}
       }
+      // v0.6.3（M-20）：轮转改为**改名式**，且不引入锁。
+      //
+      // 原实现是「全量读 → 算保留尾 → 写 .tmp → 原子替换」：读与写之间别人追加的行
+      // 会被替换掉（静默丢日志）。两种修法里这里刻意**不用锁**——本写入器由 web 服务端
+      // 在 chat 请求路径上调用（`srvlog(...)`），加上同步锁会在这个路径上引入 Atomics.wait
+      // 阻塞（正是 v0.6.2 花大力气消掉的东西），而 `.lock` 的 `n` 清单也在提醒这一点。
+      //
+      // 改名式轮转没有"读-改-写"窗口，因此不需要锁：
+      //   1. 把整文件 rename 成 `<file>.1`（**每一行都还在**，连"别人此刻正追加到旧 inode"
+      //      的那一行也一并保住了）；
+      //   2. 立刻按 logrotate 的 create 语义建一个空文件，读者不会看到"日志文件消失"；
+      //   3. 上一轮的 `.1` 在 rename 前删掉，磁盘占用有界（≤ 2× 上限）。
+      // Windows 上若其它进程仍持有该文件句柄，rename 会失败——被下面的 catch 吞掉，
+      // 结果是"这次没轮转、文件继续长"，**不丢数据**，属于可接受降级。
       const st = fs.statSync(file);
       if (st.size > maxBytes) {
-        const buf = fs.readFileSync(file);
-        // 从「字节位置 st.size - keepBytes」起找下一个换行，保证不在行/多字节字符中间切开
-        const from = Math.max(0, buf.length - keepBytes);
-        const nl = buf.indexOf(0x0a, from);
-        const keep = nl === -1 ? buf.subarray(from) : buf.subarray(nl + 1);
-        const tmp = file + '.' + process.pid + '.' + crypto.randomBytes(3).toString('hex') + '.tmp';
-        fs.writeFileSync(tmp, keep, { mode: 0o600 }); // 轮转重建保持 600
-        fs.renameSync(tmp, file);
-        try { fs.chmodSync(file, 0o600); } catch {} // rename 后兜底收权（历史 644 日志迁移）
+        const rotated = file + '.1';
+        fs.rmSync(rotated, { force: true });
+        fs.renameSync(file, rotated);
+        try {
+          fs.writeFileSync(file, '', { mode: 0o600, flag: 'wx' });
+        } catch {}
+        try { fs.chmodSync(file, 0o600); } catch {}
       }
     } catch {
       // 日志失败绝不抛错（best-effort）

package/src/mcp.js

@@ -13,6 +13,13 @@ import { isSensitiveEnv } from './tools/bash.js';
 
 // 评估 6.2（v0.4.3）：MCP 子进程不再继承完整 process.env（含 API Key）——与 bash/hooks 同口径
 // 默认过滤敏感变量；config.mcpEnvKeep 按名放行、config.mcpEnvFilter=false 整体关闭。
+//
+// v0.6.3（审计 BUG-051）：`mcpEnvFilter=false` 是**显式**逃生口（默认是过滤，已核实无默认关闭路径），
+// 但它会把这台机器上**全部**凭据交给**每一个**已配置的 MCP 服务器（多数是 npx 拉来的第三方进程）。
+// 不改显式配置（那会破坏用户按需放行的合法用法），但必须**说出来**——只做一次告警，
+// 并指向更窄的替代方案 mcpEnvKeep。
+let mcpEnvWarned = false;
+
 function filteredProcessEnv(/** @type {Set<string>} */ keepSet) {
   const out = /** @type {any} */ ({});
   for (const [k, v] of Object.entries(process.env)) {
@@ -236,7 +243,18 @@ export class McpClient {
 // topCfg 为顶层 config.json（提供 mcpEnvKeep/mcpEnvFilter 环境过滤口径，与 bash/hooks 一致）
 export async function startMcpServers(/** @type {any} */ mcpCfg, /** @type {any} */ workingDir, /** @type {any} */ topCfg = {}) {
   const keep = new Set((topCfg?.mcpEnvKeep || []).map(String));
-  const baseEnv = topCfg?.mcpEnvFilter === false ? process.env : filteredProcessEnv(keep);
+  const envFilterOff = topCfg?.mcpEnvFilter === false;
+  const baseEnv = envFilterOff ? process.env : filteredProcessEnv(keep);
+  if (envFilterOff && !mcpEnvWarned) {
+    mcpEnvWarned = true;
+    const names = Object.keys(mcpCfg || {});
+    if (names.length) {
+      console.warn(
+        `[MingDao] ⚠ config.mcpEnvFilter=false：${names.length} 个 MCP 服务器（${names.slice(0, 3).join('、')}${names.length > 3 ? ' 等' : ''}）` +
+          `将继承**完整环境变量**（含 API Key / Token）。若只是个别变量需要，请改用 config.mcpEnvKeep: ["VAR_NAME"]。`
+      );
+    }
+  }
   const clients = new Map();
   const entries = Object.entries(mcpCfg || {});
   await Promise.all(

package/src/memory.js

@@ -9,7 +9,7 @@ import path from 'node:path';
 import { mingdaoHome, ensureHome } from './config.js';
 import { beijingParts } from './pricing.js';
 import { tokenize } from './session-index.js';
-import { atomicWriteFileSync } from './atomic-write.js';
+import { atomicWriteFileSync, appendFilePrivateSync, atomicWritePrivateSync } from './atomic-write.js';
 import { recordAuxUsage } from './cachestats.js';
 
 export function memoryFile() {
@@ -35,7 +35,7 @@ export function appendMemory(/** @type {any} */ lines) {
   // 审计 B9 + 质检 M8：与费用统计同口径，用配置时区（默认北京时间）自然日做记忆日期戳
   const bp = beijingParts(new Date());
   const date = `${bp.year}-${String(bp.month).padStart(2, '0')}-${String(bp.day).padStart(2, '0')}`;
-  fs.appendFileSync(memoryFile(), add.map((/** @type {any} */ l) => (l.startsWith('-') ? `- [${date}] ${l.slice(1).trim()}` : `- [${date}] ${l}`)).join('\n') + '\n');
+  appendFilePrivateSync(memoryFile(), add.map((/** @type {any} */ l) => (l.startsWith('-') ? `- [${date}] ${l.slice(1).trim()}` : `- [${date}] ${l}`)).join('\n') + '\n');
   return add.length;
 }
 
@@ -49,7 +49,7 @@ function backupMemory() {
 export function writeMemory(/** @type {any} */ content) {
   backupMemory();
   ensureHome();
-  atomicWriteFileSync(memoryFile(), String(content ?? ''));
+  atomicWritePrivateSync(memoryFile(), String(content ?? ''));
 }
 
 // 去重：忽略日期前缀后内容相同的条目只保留第一条
@@ -72,7 +72,7 @@ export function dedupeMemory() {
   }
   if (removed > 0) {
     backupMemory();
-    atomicWriteFileSync(memoryFile(), kept.join('\n') + '\n');
+    atomicWritePrivateSync(memoryFile(), kept.join('\n') + '\n');
   }
   return removed;
 }
@@ -97,7 +97,7 @@ export function removeMemoryLines(/** @type {any} */ keyword) {
     // 少了它，文件结尾与下一次 append 的内容会拼成同一行
     // （`- [date] 旧条目- [date] 新条目`），整条记忆既解析不出来也读不懂。
     // 隔壁 dedupeMemory 一直是带 `+ '\n'` 的，这里漏了。
-    atomicWriteFileSync(memoryFile(), kept.length ? kept.join('\n') + '\n' : '');
+    atomicWritePrivateSync(memoryFile(), kept.length ? kept.join('\n') + '\n' : '');
   }
   return removed;
 }
@@ -115,7 +115,7 @@ export function appendJournal(/** @type {any} */ home, /** @type {any} */ entry)
     // 「D:\a\D:\b」式非法路径——Windows 上 mkdir 抛错被静默吞掉，journal 整体失效（评估 D1）。
     fs.mkdirSync(path.dirname(journalFile()), { recursive: true });
     // 纯追加：并发会话收尾互不覆盖；崩溃最多丢最后一行
-    fs.appendFileSync(journalFile(), JSON.stringify(entry) + '\n');
+    appendFilePrivateSync(journalFile(), JSON.stringify(entry) + '\n');
   } catch (err) {
     // 静默吞错面收窄（评估建议 3）：调试开关可见原因，正常使用仍零打扰
     if (process.env.MINGDAO_DEBUG) console.warn('[MingDao] journal 写入失败：' + ((/** @type {any} */ (err))?.message || err));
@@ -126,7 +126,7 @@ export function appendJournal(/** @type {any} */ home, /** @type {any} */ entry)
     if (fs.statSync(journalFile()).size > JOURNAL_MAX_BYTES) {
       const lines = fs.readFileSync(journalFile(), 'utf8').split('\n').filter(Boolean);
       if (lines.length > JOURNAL_KEEP_LINES) {
-        atomicWriteFileSync(journalFile(), lines.slice(-JOURNAL_KEEP_LINES).join('\n') + '\n');
+        atomicWritePrivateSync(journalFile(), lines.slice(-JOURNAL_KEEP_LINES).join('\n') + '\n');
       }
     }
   } catch {}
@@ -321,7 +321,7 @@ export function dedupeProjectMemory(/** @type {any} */ workingDir) {
   }
   if (removed > 0) {
     try {
-      atomicWriteFileSync(projectMemoryFile(workingDir), kept.join('\n') + '\n');
+      atomicWritePrivateSync(projectMemoryFile(workingDir), kept.join('\n') + '\n');
     } catch (err) {
       // v0.6.2（B-WS-1/2 第七处）：算出了重复条数但**写不回去**，就不能报告「已去重 N 条」——
       // 文件里那些重复行一条都没少。返回 0 是唯一诚实的答案（WebUI/CLI 都按这个数报给用户）。

package/src/packs.js

@@ -281,6 +281,7 @@ export function packDirs(cfg, projectDir) {
  * @param {any} [cfg] @param {any} [projectDir]
  */
 export function listPacks(cfg, projectDir, opts = {}) {
+  /** @type {Map<string, any>} */
   const seen = new Map(); // name -> entry
   for (const tier of packDirs(cfg, projectDir).sort((a, b) => a.priority - b.priority)) {
     // v0.6.2（代码审计 P2-4 的连带发现）：`config.packs` 的**文档写法是直接指向 Pack 目录**
@@ -310,8 +311,20 @@ export function listPacks(cfg, projectDir, opts = {}) {
         continue;
       }
       const v = validateManifest(manifest, opts);
-      seen.set(manifest?.name || (e.name === '.' ? path.basename(tier.dir) : e.name), {
-        name: manifest?.name || (e.name === '.' ? path.basename(tier.dir) : e.name),
+      const key = manifest?.name || (e.name === '.' ? path.basename(tier.dir) : e.name);
+      const prev = seen.get(key);
+      // v0.6.3（M-5）：**未信任的 tier 不参与遮蔽**。
+      // 原实现按 name 后写覆盖，tier 顺序是 builtin < user < project——于是"clone 一个仓库、
+      // 在里面放一个同名 Pack"就能让内置 Pack 的 constraints/promptSections **静默失效**：
+      // 项目级条目因为带 gate 不会被挂载，而被它顶掉的内置版本也回不来了（两边都没生效）。
+      if (tier.gate && prev) {
+        prev.warning =
+          `Pack「${key}」存在同名冲突：项目级未信任版本（${dir}）**不挂载**，` +
+          `因此当前生效的仍是 ${prev.source} 版本（${prev.dir}）。如需改用项目内版本，请先 mingdao pack trust。`;
+        continue;
+      }
+      const entry = {
+        name: key,
         displayName: manifest?.displayName || '',
         version: manifest?.version || '',
         apiVersion: manifest?.apiVersion,
@@ -321,7 +334,11 @@ export function listPacks(cfg, projectDir, opts = {}) {
         ...(tier.gate ? { gate: tier.gate, gateDir: tier.dir } : {}),
         manifest,
         error: v.ok ? null : v.errors.join('；'),
-      });
+      };
+      // 已信任的高优先级版本遮蔽低优先级同名版本：这是设计行为，但必须**可见**
+      // （下游 `pack list` / 启动告警都要能看到"哪个版本真的生效"）
+      if (prev) /** @type {any} */ (entry).shadowed = { name: key, dir: prev.dir, source: prev.source };
+      seen.set(key, entry);
     }
   }
   return [...seen.values()].sort((a, b) => String(a.name).localeCompare(String(b.name)));
@@ -350,7 +367,9 @@ function validateConstraint(c, i) {
   if (!c || typeof c !== 'object' || Array.isArray(c)) return `${tag} 必须是对象`;
   if (typeof c.id !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(c.id)) return `${tag}.id 非法（需 [A-Za-z0-9_-]，≤64）`;
   if (!CONSTRAINT_KINDS.has(c.kind)) return `${tag}.kind 非法（允许：${[...CONSTRAINT_KINDS].join(' / ')}）`;
-  if (c.kind === 'tool-deny' || c.kind === 'tool-arg-require' || c.kind === 'arg-forbid' || c.kind === 'completeness') {
+  if (c.kind === 'tool-deny' || c.kind === 'tool-arg-require' || c.kind === 'arg-forbid' || c.kind === 'completeness' || c.kind === 'confirm') {
+    // confirm 也必须带 tool：engine 的 toolMatches 对「无 tool」返回 false，
+    // 于是「忘了写 tool 的 confirm」会变成一条永不命中的红线——正是本仓反复强调的静默失效。
     if (typeof c.tool !== 'string' || !c.tool.trim()) return `${tag}（${c.kind}）需要 tool 字段`;
   }
   if (c.kind === 'tool-arg-require' && (typeof c.requireArg !== 'string' || !c.requireArg.trim())) {
@@ -388,12 +407,13 @@ let mountedTools = 0;
 let activeCtx = /** @type {any} */ (null);
 
 /**
- * 加载单个 Pack 目录：校验 manifest + 文件齐全 + import pack.mjs。
- * 只做「能不能用」的判定，不改全局状态（mount 才改）。
+ * **静态**校验单个 Pack 目录：manifest 字段 / 兼容窗口 / 声明文件齐全 / pack.mjs 存在性。
+ * **绝不 import pack.mjs**——`pack verify`（下游 CI 门禁）走这条路径，被审仓库的代码不该在 CI 上执行。
+ * 因此它拿不到"代码产出的约束"（那种校验只能靠 loadPack）。
  * @param {string} dir @param {{ coreVersion?: string }} [opts]
- * @returns {Promise<any>} { ok: true, manifest, contributions, dir } | { ok: false, errors: string[] }
+ * @returns {any} { ok: true, manifest } | { ok: false, errors: string[] }
  */
-export async function loadPack(dir, opts = {}) {
+export function loadPackStatic(dir, opts = {}) {
   const mf = path.join(dir, 'pack.json');
   if (!fs.existsSync(mf)) return { ok: false, errors: [`缺少 pack.json（${dir}）`] };
   let manifest;
@@ -413,6 +433,7 @@ export async function loadPack(dir, opts = {}) {
     ['skills', 'skills'],
     ['commands', 'commands'],
   ];
+  /** @type {string[]} */
   const errors = [];
   for (const [field, sub] of fileChecks) {
     for (const rel of Array.isArray(contributes[sub]) ? contributes[sub] : []) {
@@ -421,7 +442,27 @@ export async function loadPack(dir, opts = {}) {
     }
   }
   if (errors.length) return { ok: false, errors };
+  // 声明了代码贡献就必须有 pack.mjs（存在性检查，**不加载**）
+  const hasCode = contributes.tools === true || contributes.constraints !== undefined || contributes.promptSections !== undefined || contributes.memorySchema !== undefined;
+  if (hasCode && !fs.existsSync(path.join(dir, 'pack.mjs'))) {
+    return { ok: false, errors: [`manifest 声明了代码贡献，但缺少 pack.mjs（${dir}）`] };
+  }
+  return { ok: true, manifest };
+}
 
+/**
+ * 加载单个 Pack 目录：静态校验 + import pack.mjs（**会执行 Pack 代码**）。
+ * `pack verify` 默认只做静态校验（见 loadPackStatic），因为下游 CI 里被审仓库的代码不该被执行。
+ * @param {string} dir @param {{ coreVersion?: string }} [opts]
+ * @returns {Promise<any>} { ok: true, manifest, contributions, dir } | { ok: false, errors: string[] }
+ */
+export async function loadPack(dir, opts = {}) {
+  const st = loadPackStatic(dir, opts);
+  if (!st.ok) return st;
+  const manifest = st.manifest;
+  const contributes = manifest.contributes || {};
+  /** @type {string[]} */
+  const errors = [];
   /** @type {string[]} */
   const warnings = [];
   let contributions = /** @type {any} */ ({});
@@ -516,6 +557,14 @@ export async function mountPacks(cfg, opts = {}) {
   const constraints = [];
   const projectDir = opts.cwd || process.cwd();
   for (const info of listPacks(cfg, projectDir, opts)) {
+    // v0.6.3（M-5）：同名遮蔽/冲突必须**可见**——否则"哪个版本真的生效"只能靠猜
+    if (info.warning) warnings.push(info.warning);
+    if (info.shadowed) {
+      warnings.push(
+        `Pack「${info.name}」被同名高优先级版本遮蔽：生效的是 ${info.source} 版本（${info.dir}），` +
+          `${info.shadowed.source} 版本（${info.shadowed.dir}）不再生效。`
+      );
+    }
     // 项目级 Pack 未信任 → 不挂载。这里**必须把「为什么 + 怎么办」讲清楚**：
     // 原缺陷的另一半正是「静默执行 / 静默跳过」都让人不知道发生了什么。
     if (info.gate) {

package/src/permissions.js

@@ -59,8 +59,12 @@ function ruleMatches(rule, name, args, forDeny = false) {
     if (forDeny && name === 'bash') {
       // v0.6.2（自评报告 P2-2）：deny 必须**按 shell 分隔符拆段后逐段判**。
       // 原实现只拿整条命令的前缀去比：`deny:['bash:rm *']` 拦得住 `rm -rf /x`，
-      // 却放过 `cd /tmp && rm -rf /x`（开头不是 rm）——而 auto 档下 deny 是**唯一防线**，
-      // 失配就等于这条规则不存在。v0.4.6 只修了元字符失配那一半，链式仍可绕过。
+      // 却放过 `cd /tmp && rm -rf /x`（开头不是 rm）——而 auto 档下不会对每条命令发问，
+      // deny 失配就等于这条规则**形同不存在**。v0.4.6 只修了元字符失配那一半，链式仍可绕过。
+      //
+      // v0.6.3：措辞订正。原注释写「auto 档下 deny 是唯一防线」，容易被读成"不可越过的硬拦截"，
+      // 而 docs/CONFIG.md 明确记载「被 deny 拦截会弹窗询问、同意即放行」——**能越过**。
+      // 要真正的硬拦截请显式开 `denyStrict: true`（见 normalizePermission 注释）。
       // 方向是 fail-closed：宁可多拦（多问一次），不可漏拦。
       const segs = splitShellSegments(have);
       return segs.some((seg) => (want.endsWith('*') ? seg.startsWith(want.slice(0, -1)) : seg === want));
@@ -74,21 +78,26 @@ function ruleMatches(rule, name, args, forDeny = false) {
 /**
  * 归一化权限配置（v0.6.0 C2：从 check() 中抽出，供**纯函数**判定复用）。
  * @param {any} rawMode
- * @returns {{mode: string, allow: any[], deny: any[]}}
+ * @returns {{mode: string, allow: any[], deny: any[], denyStrict: boolean}}
  */
 export function normalizePermission(/** @type {any} */ rawMode) {
   let mode = 'ask';
   let allow = [];
   let deny = [];
+  // v0.6.3（审计 H-11）：`denyStrict` = 把 deny 升级为**不可临时放行**的硬拦截。
+  // 默认 false 保持既有行为（docs/CONFIG.md 明确记载「被 deny 拦截会弹窗询问，同意即放行」，
+  // 那是 v0.4.6 有意加的"不再静默拦截"）；需要硬拦截的场景（无人值守/强合规）显式打开。
+  let denyStrict = false;
   if (typeof rawMode === 'string') {
     mode = rawMode;
   } else if (rawMode && typeof rawMode === 'object') {
     mode = rawMode.mode ?? 'ask';
     allow = rawMode.allow ?? [];
     deny = rawMode.deny ?? [];
+    denyStrict = rawMode.denyStrict === true;
   }
   if (!['ask', 'auto', 'readonly'].includes(mode)) mode = 'ask';
-  return { mode, allow, deny };
+  return { mode, allow, deny, denyStrict };
 }
 
 /**
@@ -104,12 +113,12 @@ export function normalizePermission(/** @type {any} */ rawMode) {
  * @param {any} rawMode
  * @param {any} name
  * @param {any} args
- * @returns {{decision: 'allow'|'deny'|'ask', reason: string, rule: string|null}}
+ * @returns {{decision: 'allow'|'deny'|'ask', reason: string, rule: string|null, denyStrict?: boolean}}
  */
 export function evaluatePermission(/** @type {any} */ rawMode, /** @type {any} */ name, /** @type {any} */ args = {}) {
-  const { mode, allow, deny } = normalizePermission(rawMode);
+  const { mode, allow, deny, denyStrict } = normalizePermission(rawMode);
   const hitDeny = deny.find((/** @type {any} */ r) => ruleMatches(r, name, args, true));
-  if (hitDeny) return { decision: 'deny', reason: 'rule-deny', rule: hitDeny };
+  if (hitDeny) return { decision: 'deny', reason: 'rule-deny', rule: hitDeny, denyStrict };
   const hitAllow = allow.find((/** @type {any} */ r) => ruleMatches(r, name, args));
   if (hitAllow) return { decision: 'allow', reason: 'rule-allow', rule: hitAllow };
   if (mode === 'auto') return { decision: 'allow', reason: 'mode-auto', rule: null };
@@ -137,9 +146,26 @@ export function createPermission(rawMode, io) {
       // 判定只此一份（evaluatePermission）；这里只负责「需要用户点头时怎么问」。
       const v = evaluatePermission(rawMode, name, args);
       if (v.decision === 'allow') return true;
-      // 1) 被 deny 规则拦截 → 询问是否本次强制放行，而不是静默拒绝
+      // 1) 被 deny 规则拦截。
+      //    默认（与 docs/CONFIG.md 一致）：询问是否本次强制放行，而不是静默拒绝。
+      //    但 `denyStrict: true` 时**不给放行入口**——那是用户显式要求的硬拦截。
       if (v.decision === 'deny') {
-        return askOverride(`规则拦截了 ${name}${summarize(name, args)}，是否本次强制放行？[y/N] `);
+        if (v.denyStrict) {
+          try {
+            io.print(
+              style(
+                `⛔ 已拒绝：${name}${summarize(name, args)} 命中 deny 规则「${v.rule}」` +
+                  `（config.permission.denyStrict=true：deny 为硬拦截，不提供本次放行）。`,
+                C.red
+              )
+            );
+          } catch {}
+          return false;
+        }
+        // 知情同意：点名命中的规则与来源，而不是笼统的"规则拦截了"
+        return askOverride(
+          `⚠ ${name}${summarize(name, args)} 命中你配置的 deny 规则「${v.rule}」——是否本次强制放行？（这会绕过你自己写的禁令）[y/N] `
+        );
       }
       // 2) 只读模式下的写操作 → 询问是否本次放行
       if (v.reason === 'readonly-write') {

package/src/presets.js

@@ -101,14 +101,33 @@ export function listPresets(/** @type {any} */ workingDir) {
       const key = String(obj.name);
       if (seen.has(key)) continue; // 同名遮蔽：项目 → 用户 → 内置（先发现者胜）
       seen.set(key, { obj, source, file });
+      // v0.6.3（M-8）：记录"这个名字是否把更低优先级来源遮蔽了"——静默遮蔽是注入面
+      // （项目级预设可以按名顶掉内置预设，同时注入自己的 systemPrompt/tools）
+      const shadowedFrom = [];
+      // 只统计**比当前来源更低**优先级的目录（发现顺序即优先级：项目 → 用户 → 内置）。
+      // 第一版写成"遇到自己就 break"，结果是项目级永远统计不到（自己就是第一个）——断言当场发现。
+      const locs = presetLocations(workingDir);
+      const selfAt = locs.findIndex((/** @type {any} */ l) => l.source === source);
+      for (const { dir: d2, source: s2 } of (selfAt >= 0 ? locs.slice(selfAt + 1) : [])) {
+        try {
+          for (const f2 of fs.readdirSync(d2).filter((/** @type {any} */ x) => x.endsWith('.json'))) {
+            try {
+              const o2 = JSON.parse(fs.readFileSync(path.join(d2, f2), 'utf8'));
+              if (String(o2?.name) === key) shadowedFrom.push({ source: s2, file: path.join(d2, f2) });
+            } catch {}
+          }
+        } catch {}
+      }
+      if (shadowedFrom.length) seen.get(key).shadowed = shadowedFrom;
     }
   }
-  return [...seen.values()].map(({ obj, source, file }) => ({
+  return [...seen.values()].map(({ obj, source, file, shadowed }) => ({
     name: String(obj.name),
     label: String(obj.label || obj.name),
     description: String(obj.description || ''),
     source,
     file,
+    ...(shadowed ? { shadowed } : {}),
     ...(obj.systemPrompt ? { systemPrompt: obj.systemPrompt } : {}),
     ...(Array.isArray(obj.tools) ? { tools: obj.tools } : {}),
     ...(obj.permission ? { permission: String(obj.permission) } : {}),
@@ -120,10 +139,26 @@ export function listPresets(/** @type {any} */ workingDir) {
  * 按名解析单个预设（含全部字段），找不到返回 null。
  * @param {any} workingDir @param {any} name
  */
+const shadowWarned = new Set();
 export function loadPreset(/** @type {any} */ workingDir, /** @type {any} */ name) {
   const all = listPresets(workingDir);
   const hit = all.find((/** @type {any} */ p) => p.name === name || path.basename(String(p.file), '.json') === name);
   if (!hit) return null;
+  // v0.6.3（M-8）：项目级预设按名遮蔽内置/用户级预设时**必须说出来**。
+  // 场景：clone 一个仓库 → cd 进去 → `mingdao --preset reviewer`：拿到的是仓库里那份
+  // systemPrompt/tools，而用户以为是自己熟悉的那个预设（静默注入面）。
+  // 这里不阻断（遮蔽本身是文档化行为），但把"生效的是哪一份、被顶掉的是哪一份"打出来。
+  if (hit.source === 'project' && Array.isArray(hit.shadowed) && hit.shadowed.length) {
+    const key = `${workingDir}|${hit.name}`;
+    if (!shadowWarned.has(key)) {
+      shadowWarned.add(key);
+      const beaten = hit.shadowed.map((/** @type {any} */ x) => `${x.source}（${x.file}）`).join('、');
+      console.warn(
+        `[MingDao] ⚠ 预设「${hit.name}」来自**项目目录**（${hit.file}），它遮蔽了：${beaten}。\n` +
+          `  项目级预设可以定义 systemPrompt / 工具白名单——请确认这份是你信任的内容（不需要它时删掉该文件即可）。`
+      );
+    }
+  }
   try {
     return JSON.parse(fs.readFileSync(hit.file, 'utf8'));
   } catch {
@@ -172,6 +207,16 @@ export function presetPermissionOverride(/** @type {any} */ preset, /** @type {a
     // 提权：忽略预设值，保持当前更保守的权限（对象形态保留其 allow/deny）
     return { permission: curMode in PERM_RANK ? currentPermission : cur, escalated: true };
   }
+  // v0.6.3（审计 P1-3）：**未提权分支也必须保留对象形态**。
+  //
+  // 原实现返回裸字符串 `want`，于是配置对象里的 `allow`/`deny` 被整体丢弃——
+  // 而 `deny` 是用户自己写的禁令：`{mode:'auto', deny:['fetch:*']}` 遇到预设
+  // permission:'readonly' 时，这条禁令会**静默消失**（只读档下 fetch 照样可用）。
+  // 方向是**放宽权限**，与该函数"只能收紧不能放松"的意图正好相反。
+  // 现在：对象进 → 对象出（只改 mode，保留 allow/deny）；字符串进 → 字符串出。
+  if (currentPermission && typeof currentPermission === 'object') {
+    return { permission: { ...currentPermission, mode: want }, escalated: false };
+  }
   return { permission: want, escalated: false };
 }