mingdao-harness 0.6.2 → 0.6.4

package/src/commands/key.js

@@ -2,7 +2,7 @@
 import fs from 'node:fs';
 import { createIO, style, C } from '../ui.js';
 import { ensureHome } from '../config.js';
-import { setStoredKey, removeStoredKey, credentialsPath, loadCredentials, maskKey } from '../credentials.js';
+import { setStoredKey, removeStoredKey, credentialsPath, loadCredentials, readCredentialsStrict, maskKey } from '../credentials.js';
 import { PROVIDERS } from '../models.js';
 
 export async function handleKey(/** @type {any} */ cmd, /** @type {any} */ args) {
@@ -10,6 +10,25 @@ export async function handleKey(/** @type {any} */ cmd, /** @type {any} */ args)
   try {
     const sub = args[0] || 'status';
     const target = args[1];
+    // v0.6.3（审计 H-8）：**写路径前置守卫**——凭证库存在但读不出来时，绝不进入
+    // 「读→改→全量重写」这一步：那会把其余凭据静默清空（实测复现）。
+    // 读路径（status）不受影响：它只需要知道"有哪些 key"，损坏时显示空即可。
+    if (sub === 'set' || sub === 'remove' || sub === 'import') {
+      const st = readCredentialsStrict();
+      if (!st.ok) {
+        io.print(style(`✗ 凭证库无法读取，已拒绝写入：${st.error}`, C.red));
+        io.print(style(`  文件：${credentialsPath()}`, C.dim));
+        io.print(
+          style(
+            '  继续写会**清空其余全部凭据**，所以这里选择拒绝。请先人工检查/修复该文件；' +
+              '若内容已不可恢复，把它改名备份（如 credentials.json.bak）后重试，届时会当作全新凭证库。',
+            C.dim
+          )
+        );
+        process.exitCode = 1;
+        return true;
+      }
+    }
     if (sub === 'status') {
       ensureHome();
       io.print(style(`本地凭证库：${credentialsPath()}`, C.bold));
@@ -86,7 +105,10 @@ export async function handleKey(/** @type {any} */ cmd, /** @type {any} */ args)
       }
       if (!count) io.print('没有可导入的环境变量（如 DEEPSEEK_API_KEY）。');
     } else {
+      // v0.6.3（M-21）：未知子命令此前打印用法后**退 0**——`mingdao key setx …` 会被
+      // 脚本当成「设置成功」。用法提示与失败同码是退出码语义的静默失效。
       io.print('用法：mingdao key [status|set <服务商> [key]|remove <服务商>|import]');
+      process.exitCode = 1;
     }
   } finally {
     io.close();

package/src/commands/ledger.js

@@ -14,17 +14,33 @@ import { createIO, style, C } from '../ui.js';
 import { listRuns, readRun, verifyRun, exportRun, isValidRunId, ledgerDir } from '../ledger.js';
 import { replayRun, renderReplay, KIND } from '../replay.js';
 import { loadConfig } from '../config.js';
-import { getActivePackContext } from '../packs.js';
+import { getActivePackContext, mountPacks } from '../packs.js';
+
+/** 用法串：未知子命令与用法提示共用一份，避免两处漂移 */
+const USAGE = '用法：mingdao ledger list [数量] | show <runId> | export <runId> [--format json|md] [--out 文件] | verify <runId> | replay <runId> [--json]';
+const KNOWN_SUBS = new Set(['list', 'show', 'verify', 'replay', 'export']);
 
 /** @param {any} cmd @param {any} args */
 export async function handleLedger(cmd, args) {
   const io = createIO();
   const sub = args[0] || 'list';
   const rest = args.slice(1);
+  // v0.6.3（M-21）：未知子命令此前会一路走到函数末尾「打印用法并退 0」，脚本/CI 无法与
+  // 「命令成功」区分。这里**先**判子命令——顺序很重要：放在 runId 解析之后会被
+  // 「runId 格式不合法」分支抢先命中，于是同样的输入有时退 1、有时退 0。
+  if (!KNOWN_SUBS.has(sub)) {
+    io.print(USAGE);
+    process.exitCode = 1;
+    return true;
+  }
   const flag = (/** @type {string} */ name, /** @type {any} */ dflt = null) => {
     const i = rest.indexOf(name);
     return i >= 0 && rest[i + 1] ? rest[i + 1] : dflt;
   };
+  // v0.6.3（M-12）：布尔开关必须与「取值型参数」分开解析。
+  // 原实现只有上面的取值型 `flag()`：`--json` 写在末尾时取不到「下一个值」→ 返回 null →
+  // `ledger replay <id> --json` 恒走人读分支，`| jq` 直接失败（而且失败得很安静）。
+  const boolFlag = (/** @type {string} */ name) => rest.includes(name);
   // 位置参数：排除掉 --xxx 及其取值
   const positional = rest.filter((/** @type {any} */ a, /** @type {number} */ i) => !String(a).startsWith('--') && !String(rest[i - 1] || '').startsWith('--'));
 
@@ -54,11 +70,15 @@ export async function handleLedger(cmd, args) {
   }
   if (!isValidRunId(runId)) {
     io.print(`runId 格式不合法：${runId}（形如 mtx16g3y-628443）`);
+    // v0.6.3（M-21）：凡是「用户要求的事没做成」，退出码必须是 1。
+    // 此前 `ledger verify <乱写的 id>` 会打印一行错误然后退 0，CI 拿它当门禁即假通过。
+    process.exitCode = 1;
     return true;
   }
   const events = readRun(runId);
   if (!events.length) {
     io.print(`没有找到账本 ${runId}。用 mingdao ledger list 查看现有账本。`);
+    process.exitCode = 1;
     return true;
   }
 
@@ -92,7 +112,20 @@ export async function handleLedger(cmd, args) {
     // 当前规则栈：显式配置的 constraints 优先，否则取进程级已挂载的 Pack 约束；
     // 权限取 config.permission（缺省 ask）。回放**不联网、无副作用**。
     const cfg = loadConfig() || {};
+    // v0.6.3（P1-12）：CLI 的命令分发发生在 cli.js 的 mountPacks **之前**，因此
+    // `getActivePackContext()` 在这里恒为 null → constraints=[] → compiled.active=false →
+    // 回放恒输出「当前没有任何生效的领域约束」，**恒通过**。把它当 CI 门禁时是静默假阴性。
+    // 与启动路径同口径地挂一次 Pack（幂等），让「新红线能不能拦住历史操作」这个问题
+    // 在 CLI 下真正有答案。
+    if (!Array.isArray(cfg.constraints) && !getActivePackContext()) {
+      try {
+        await mountPacks(cfg, { cwd: process.cwd() });
+      } catch (/** @type {any} */ e) {
+        io.print(style(`⚠ Pack 挂载失败，本次回放将看不到 Pack 约束：${e?.message || e}`, C.yellow));
+      }
+    }
     const currentConstraints = Array.isArray(cfg.constraints) ? cfg.constraints : getActivePackContext()?.constraints ?? [];
+    const asJson = boolFlag('--json');
     const r = replayRun(runId, { constraints: currentConstraints, permission: cfg.permission ?? 'ask' });
     if (r.error || !r.summary) {
       io.print(String(r.error ?? '回放失败'));
@@ -100,7 +133,7 @@ export async function handleLedger(cmd, args) {
       return true;
     }
     const summary = r.summary;
-    if (flag('--json')) {
+    if (asJson) {
       io.print(JSON.stringify({ runId: r.runId, summary, steps: r.steps, notes: r.notes }, null, 2));
     } else {
       io.print(renderReplay(r).trimEnd());
@@ -108,7 +141,7 @@ export async function handleLedger(cmd, args) {
     // 非零退出码让它能当门禁用：CI 里「新红线必须能拦住历史上那批操作」就是这个断言
     if (summary.nowBlocked > 0) {
       process.exitCode = 1;
-      if (!flag('--json')) io.print(style(`\n↑ 有 ${summary.nowBlocked} 步今天会被红线拦住：若这正是新红线的目的，回放通过；否则说明规则收得过紧。`, C.yellow));
+      if (!asJson) io.print(style(`\n↑ 有 ${summary.nowBlocked} 步今天会被红线拦住：若这正是新红线的目的，回放通过；否则说明规则收得过紧。`, C.yellow));
     }
     return true;
   }
@@ -117,11 +150,13 @@ export async function handleLedger(cmd, args) {
     const format = String(flag('--format', 'json'));
     if (format !== 'json' && format !== 'md') {
       io.print('--format 只支持 json 或 md');
+      process.exitCode = 1;
       return true;
     }
     const r = exportRun(runId, { format });
     if (r.error) {
       io.print(r.error);
+      process.exitCode = 1;
       return true;
     }
     const out = flag('--out');
@@ -140,6 +175,9 @@ export async function handleLedger(cmd, args) {
     return true;
   }
 
+  // v0.6.3（M-21）：未知子命令此前静默落到「打印用法并退 0」——CI/脚本无法区分
+  // 「用法提示」与「命令成功」。这是退出码语义的静默失效，明确退 1。
   io.print('用法：mingdao ledger list [数量] | show <runId> | export <runId> [--format json|md] [--out 文件] | verify <runId> | replay <runId> [--json]');
+  process.exitCode = 1;
   return true;
 }

package/src/commands/net.js

@@ -24,7 +24,9 @@ function parseSince(/** @type {any} */ v) {
 /** @param {any} cmd @param {any} args */
 export async function handleNet(cmd, args) {
   const io = createIO();
-  const sub = args[0] || 'report';
+  // `mingdao net --json` 这类「只给开关、没给子命令」的调用此前会把 `--json` 当成子命令，
+  // 于是一个合法调用反而落到用法提示；以 `-` 开头的参数一律视为 report 的开关。
+  const sub = args[0] && !String(args[0]).startsWith('-') ? args[0] : 'report';
   const cfg = loadConfig() || {};
 
   if (sub === 'policy') {
@@ -81,6 +83,8 @@ export async function handleNet(cmd, args) {
     return true;
   }
 
+  // v0.6.3（M-21）：未知子命令此前打印用法后**退 0**，脚本/CI 无法与「成功」区分。
   io.print('用法：mingdao net report [--since 7d|24h|90m] [--json] | mingdao net policy');
+  process.exitCode = 1;
   return true;
 }

package/src/commands/pack.js

@@ -1,14 +1,16 @@
 // `mingdao pack` 命令族（v0.5.0 阶段 A）：垂域 Pack 的查看 / 校验 / 脚手架。
-// 下游 CI 门禁入口是 `mingdao pack verify <dir>`——它只做静态校验（不 import Pack 代码），
-// 因此可以在没有内核运行时的环境里安全执行。
+// 下游 CI 门禁入口是 `mingdao pack verify <dir>`——**默认只做静态校验，不 import Pack 代码**
+// （v0.6.3 / H-9：此前帮助文案这么写、实现却无条件 loadPack → 等于在 CI 上执行被审仓库的任意代码，
+// 且不经 pack trust 信任门。现在默认静态、要执行须显式 --runtime）。
 import fs from 'node:fs';
 import path from 'node:path';
-import { listPacks, loadPack, validateManifest, coreVersionOf, SUPPORTED_PACK_API, CONSTRAINT_KINDS, packedDirsForHelp, packTrustState, trustPack, untrustPack } from '../packs.js';
+import { listPacks, loadPack, loadPackStatic, validateManifest, coreVersionOf, SUPPORTED_PACK_API, CONSTRAINT_KINDS, packedDirsForHelp, packTrustState, trustPack, untrustPack } from '../packs.js';
 import { loadConfig } from '../config.js';
 
 const HELP = `用法：
   mingdao pack list                 已发现的 Pack（名/版本/来源/兼容状态）
-  mingdao pack verify <目录>        静态校验 manifest + 文件齐全 + 约束合法（下游 CI 门禁）
+  mingdao pack verify <目录>        静态校验 manifest + 文件齐全（**不执行 pack.mjs**，下游 CI 门禁用这个）
+  mingdao pack verify <目录> --runtime  额外 import pack.mjs 验证运行时契约（会执行 Pack 代码，慎用）
   mingdao pack new <名字>           生成最小可用 Pack 脚手架
   mingdao pack info <名字>          单个 Pack 的贡献面明细
   mingdao pack trust <项目目录>     信任该项目的 .mingdao/packs（未信任则**不挂载**）
@@ -133,7 +135,22 @@ export async function handlePack(cmd, args) {
       process.exitCode = 1;
       return true;
     }
-    // 再走一次完整加载（会 import pack.mjs，验证运行时契约）
+    // v0.6.3（H-9）：默认**静态**收口——`verify` 是给 CI 审第三方 Pack 用的，不能顺手执行它的代码。
+    const runtime = args.includes('--runtime');
+    if (!runtime) {
+      const st2 = loadPackStatic(abs);
+      if (!st2.ok) {
+        console.log(`[失败] ${manifest.name} 静态校验未通过：`);
+        st2.errors.forEach((/** @type {any} */ e, /** @type {number} */ i) => console.log(`  ${i + 1}. ${e}`));
+        process.exitCode = 1;
+        return true;
+      }
+      console.log(`[通过·静态] ${manifest.name} v${manifest.version}（apiVersion ${manifest.apiVersion}，内核窗口 ${manifest.engines?.mingdao}）`);
+      console.log('  已校验：manifest 字段 / 兼容窗口 / 声明文件齐全 / pack.mjs 存在性。**未执行 Pack 代码。**');
+      console.log('  约束与提示词段的合法性由代码在装载时产出，静态阶段无法校验；需要时请加 --runtime（会执行代码）。');
+      return true;
+    }
+    console.log('  ⚠ --runtime：即将 import pack.mjs——它会在**本进程内以完整 Node 权限执行**。');
     const res = await loadPack(abs);
     if (!res.ok) {
       console.log(`[失败] ${manifest.name} 加载校验未通过：`);
@@ -142,7 +159,7 @@ export async function handlePack(cmd, args) {
       return true;
     }
     const c = res.contributions;
-    console.log(`[通过] ${manifest.name} v${manifest.version}（apiVersion ${manifest.apiVersion}，内核窗口 ${manifest.engines?.mingdao}）`);
+    console.log(`[通过·运行时] ${manifest.name} v${manifest.version}（apiVersion ${manifest.apiVersion}，内核窗口 ${manifest.engines?.mingdao}）`);
     console.log(`  工具 ${Array.isArray(c.tools) ? c.tools.length : 0} 个 · 约束 ${Array.isArray(c.constraints) ? c.constraints.length : 0} 条 · 提示词段 ${Array.isArray(c.promptSections) ? c.promptSections.length : 0} 段`);
     for (const w of Array.isArray(res.warnings) ? res.warnings : []) console.log(`  ⚠ ${w}`);
     return true;

package/src/commands/repl.js

@@ -271,6 +271,8 @@ export async function runRepl(ctx) {
           rewriteSession(session.file, messages);
         } catch {}
         tuiState.persisted = messages.length;
+        // 同上：上下文被清空后，"这个文件你看过"的记忆也必须一起清掉
+        agent.clearReadCache?.();
         io.print('已清空上下文（会话文件已同步重置）。');
       } else if (cmd === '/preset') {
         // v0.4.0 Agent Preset：列出/切换声明式智能体预设（工具白名单/权限/参数 + 系统提示定制段）
@@ -391,8 +393,14 @@ export async function runRepl(ctx) {
           continue;
         }
         messages = compacted.messages;
-        appendMessages(session.file, [{ role: 'system', content: '── /compact 压缩点 ──' }, ...messages.slice(1)]);
+        // v0.6.3（H-4）：手动 /compact 此前用**追加**落盘（再补一条"压缩点"标记），而压缩前的历史
+        // 早已在文件里 → 每次 /compact 文件近乎翻倍，`-c/--continue` 恢复后历史重复并立刻再次触发压缩。
+        // 自动压缩走的是 rewriteSession（原子重写）——两处写盘口径不一致，这里统一到重写。
+        rewriteSession(session.file, messages);
         tuiState.persisted = messages.length;
+        // v0.6.3（M-1）：压缩把早期消息（含文件正文）换成了摘要，但读取去重缓存仍记着"这个文件你看过"
+        // → 模型再读同一文件只会拿到「内容与上次读取一致」的占位串，而正文已不在上下文里。
+        agent.clearReadCache?.();
         io.print(style(`✓ 已压缩上下文：${compacted.droppedCount} 条早期消息 → 摘要（回收约 ${compacted.droppedTokens} tokens）`, C.green));
       } else if (cmd === '/init') {
         const target = path.join(workingDir, 'AGENTS.md');

package/src/commands/skill.js

@@ -6,6 +6,7 @@ import { loadConfig, saveConfig, ensureHome } from '../config.js';
 import { searchSessions, relativeTime } from '../session.js';
 import { runWebServer } from '../web/server.js';
 import readline from 'node:readline';
+import fs from 'node:fs'; // v0.6.3（BUG-015）：--auth-token=- 从 stdin 读
 
 // 首次运行询问「是否自动后台启动 WebUI」（交互终端才问；管道/脚本下默认否）
 function askAutoStart() {
@@ -53,6 +54,13 @@ export async function handleSkill(/** @type {any} */ cmd, /** @type {any} */ arg
       const rn = /** @type {any} */ (r);
       const srcLabel = rn.host ? '（线上 registry）' : '';
       console.log(`✓ 已安装技能 ${rn.name}${srcLabel} → ~/.mingdao/skills/${rn.name}/（可编辑/删除，下次会话生效）`);
+      if (rn.host) {
+        // v0.6.3（M-6）：**如实说明这条校验的边界**。
+        // sha256 来自索引本身（文件与哈希同源），所以它能挡住传输损坏与第三方镜像篡改，
+        // 但**挡不住索引被投毒**——投毒者会同时下发恶意正文与与之匹配的哈希，校验必然通过。
+        // 结论：它是完整性检查，不是来源可信性证明。用户有权知道这个区别。
+        console.log('  说明：完整性校验（sha256）与索引同源，只防传输损坏/镜像篡改，不防**索引本身被投毒**。');
+      }
     }
     return true;
   }
@@ -172,8 +180,29 @@ export async function handleWeb(/** @type {any} */ cmd, /** @type {any} */ args)
   if (atIdx !== -1) {
     const raw = args[atIdx];
     authToken = raw.includes('=') ? raw.slice(raw.indexOf('=') + 1) : args[atIdx + 1];
+    // v0.6.3（BUG-015）：`--auth-token <令牌>` 会把令牌留在 **argv** 里 —— `ps aux` 与 shell 历史
+    // 都能看到（本仓发布链路早就把"token 不进 argv"定为纪律，这里此前是漏网的一处）。
+    // 现在支持 `--auth-token=-` 从 **stdin** 读（脚本里 `printf %s "$TOK" | mingdao web --auth-token=-`），
+    // 直接用字面量时给出明确告警而不是默默泄露。
+    if (authToken === '-') {
+      try {
+        authToken = fs.readFileSync(0, 'utf8').trim();
+      } catch {
+        authToken = '';
+      }
+      if (!authToken) {
+        console.log('[错误] --auth-token=- 需要从 stdin 读入令牌（例如：printf %s "$MINGDAO_WEB_TOKEN" | mingdao web --auth-token=-）');
+        process.exitCode = 1;
+        return true;
+      }
+    } else if (authToken) {
+      console.warn(
+        '[MingDao] ⚠ 令牌写在命令行里会留在 argv 与 shell 历史中（ps aux 可见）。\n' +
+          '  建议改用：环境变量 MINGDAO_WEB_TOKEN、config.json 的 web.token，或 `--auth-token=-` 从 stdin 读入。'
+      );
+    }
     if (!authToken) {
-      console.log('用法：mingdao web [端口] [--auth-token <令牌>]');
+      console.log('用法：mingdao web [端口] [--auth-token <令牌>|--auth-token=-]');
       process.exitCode = 1;
       return true;
     }

package/src/commands/sync.js

@@ -280,6 +280,13 @@ export async function handleSync(/** @type {any} */ cmd, /** @type {any} */ args
       return true;
     }
     console.log(`✓ 已推送 ${r.pushed.length} 个会话${r.skipped?.length ? `（跳过 ${r.skipped.length} 个空会话）` : ''}${r.conflicts.length ? `，远端 ${r.conflicts.length} 个不同版本已备份为 .server-*（本地覆盖远端）` : ''}`);
+    // v0.6.3（审计 H-2）：上传前脱敏必须让用户知道——否则他以为远端存的是原文
+    if (r.redacted?.length) {
+      console.log(
+        `ℹ ${r.redacted.length} 个会话在上传前已脱敏（疑似密钥被掩码）：${r.redacted.slice(0, 3).join('、')}${r.redacted.length > 3 ? ' 等' : ''}\n` +
+          '  本地文件保持原样；远端与其它设备拿到的是掩码版。会话原文仍建议不要粘贴长期凭据。'
+      );
+    }
     return true;
   }
   if (sub === 'pull') {

package/src/commands/workspace.js

@@ -12,7 +12,7 @@ export async function handleWorkspace(/** @type {any} */ cmd, /** @type {any} */
       process.exitCode = 1;
       return true;
     }
-    const r = addWorkspace(name, args[2]);
+    const r = await addWorkspace(name, args[2]);
     if (r.error) {
       console.log('[错误] ' + r.error);
       process.exitCode = 1;
@@ -29,7 +29,7 @@ export async function handleWorkspace(/** @type {any} */ cmd, /** @type {any} */
     }
     // v0.6.2：removeWorkspace 现在可能返回 {error}（注册表写失败）。
     // 只判真值会把对象当成成功，把「写失败」说成「✓ 已移除」——那正是本批要消灭的假成功。
-    const rm = removeWorkspace(name);
+    const rm = await removeWorkspace(name);
     if (rm === true) console.log(`✓ 已移除 ${name}`);
     else if (rm && /** @type {any} */ (rm).error) {
       console.log('[错误] ' + /** @type {any} */ (rm).error);
@@ -63,7 +63,7 @@ export async function handleWorkspace(/** @type {any} */ cmd, /** @type {any} */
       process.exitCode = 1;
       return true;
     }
-    touchWorkspace(name);
+    await touchWorkspace(name);
     console.log(`✓ 工作空间 ${name}：${p}`);
     console.log(`  快速进入：cd "$(mingdao workspace path ${name})"（建议做成 shell 函数/别名，如 mdw() { cd "$(mingdao workspace path "$1")"; }）`);
     return true;

package/src/compact.js

@@ -13,6 +13,8 @@ const MIN_DROP_TOKENS = 2000; // 被裁段落 token 数低于此值不值得一
 // B1/B2（评估建议）：达到预算 80% 即提前压缩、压到 60%——滞回缓冲带避免在预算线附近
 // 反复触发裁剪/压缩，让摘要成为稳定前缀、后续轮次全程缓存命中；压缩触发频率也大幅下降。
 const DEFAULT_TRIGGER_RATIO = 0.8;
+/** v0.6.3（BUG-036）：triggerRatio 越界只告警一次，避免每回合刷屏 */
+let triggerWarned = false;
 const TARGET_RATIO = 0.6;
 const SUMMARY_MAX_CHARS = 1600; // 摘要上限（约几百 token，远小于被裁段落）
 const INPUT_MAX_CHARS = 30000; // 摘要输入上限（防超长工具输出撑爆摘要请求）
@@ -69,7 +71,19 @@ export async function compactConversation(/** @type {any} */ { messages, budget,
   // boundary 保持 messages.length，于是除 system 外整段会话（含最新用户指令）被全部压成摘要，
   // 且 WebUI 的 onCompact 会把结果 rewriteSession 永久写回会话文件（真·失忆）。
   // config.compactTrigger 是文档化的 0–1 可调项，「想更早压缩」的自然用法正好命中。
-  const trigger = Number.isFinite(Number(triggerRatio)) ? Math.max(Number(triggerRatio), TARGET_RATIO) : DEFAULT_TRIGGER_RATIO;
+  // v0.6.3（BUG-036）：**上限也要夹**。原实现只 `Math.max(..., TARGET_RATIO)`，于是
+  // `config.compactTrigger` 配成 >1（或手滑多打一个 0）时，`total <= budget*trigger` 恒真 →
+  // 自动压缩**永久失效**（force 分支之外永不触发）→ 长会话一路涨到窗口上限才由服务端报错。
+  // 上限定在 1（= 用满预算才压）并**明确告警**，而不是静默失效。
+  let triggerIn = Number(triggerRatio);
+  if (Number.isFinite(triggerIn) && triggerIn > 1) {
+    if (!triggerWarned) {
+      triggerWarned = true;
+      console.warn(`[MingDao] ⚠ compactTrigger=${triggerIn} 超出有效范围（0–1），已按 1 处理——否则自动压缩永不触发，长会话会一直涨到窗口上限。`);
+    }
+    triggerIn = 1;
+  }
+  const trigger = Number.isFinite(triggerIn) ? Math.max(triggerIn, TARGET_RATIO) : DEFAULT_TRIGGER_RATIO;
   // force（v0.3.2 边缘检测）：逼近窗口时即便启发式计数低估（total 未达触发线）也强制压缩——
   // 非 DeepSeek 模型启发式计数误差可达 ±2 倍，等它越过触发线时真实 prompt 可能已到窗口边缘。
   if (total <= budget * trigger && !force) return null;

package/src/config.js

@@ -24,21 +24,86 @@ export function configPath() {
   return path.join(mingdaoHome(), 'config.json');
 }
 
-/** 读取配置对象（不存在/损坏返回 null）；返回值为用户可编辑的任意 JSON 配置，类型不定
- * @returns {any} */
-export function loadConfig() {
+/**
+ * 严格读取配置：区分「不存在」与「存在但读不出来」。v0.6.3（H-7）。
+ *
+ * 原实现 `catch { return null }` 把 ENOENT 与「JSON 解析失败 / 权限不足 / 不是对象」抹平成同一件事，
+ * 而所有调用点对 null 的处理都是**当作首次运行**——于是改坏一个字符（或存成带 BOM 的 UTF-8）
+ * 之后跑 `mingdao init` / 桌面版首启，`customModels`/`mcpServers`/`sync`/`net`/`costGuard`
+ * 会被一个全新对象**整文件覆盖**，且不备份、不告警。BOM 这一支尤其冤：内容完全合法，
+ * 只是 JSON.parse 不认 BOM。
+ *
+ * @returns {{ok: boolean, exists: boolean, data: any, error: string|null}}
+ */
+export function readConfigStrict() {
+  const file = configPath();
+  let raw;
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+  } catch (/** @type {any} */ err) {
+    if (err?.code === 'ENOENT') return { ok: true, exists: false, data: null, error: null };
+    return { ok: false, exists: true, data: null, error: `无法读取 ${file}：${err?.message || err}` };
+  }
+  // BOM：合法的 JSON 内容 + 文件头 BOM = JSON.parse 直接抛（Excel/记事本另存为的常见产物）
+  const text = raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw;
+  if (!text.trim()) return { ok: false, exists: true, data: null, error: `${file} 是空文件` };
+  try {
+    const data = JSON.parse(text);
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+      return { ok: false, exists: true, data: null, error: `${file} 的内容不是 JSON 对象（实际是 ${Array.isArray(data) ? '数组' : typeof data}）` };
+    }
+    return { ok: true, exists: true, data, error: null };
+  } catch (/** @type {any} */ err) {
+    return { ok: false, exists: true, data: null, error: `${file} 解析失败：${err?.message || err}` };
+  }
+}
+
+/**
+ * 把「读不出来的 config.json」**改名**成 `config.json.corrupt-<时间戳>`。
+ * 用改名而不是复制：后续任何「写全新配置」都不会再压到用户的原始数据上。
+ * @param {string} reason
+ * @returns {string|null} 备份路径（无需备份时 null）
+ */
+export function quarantineCorruptConfig(reason) {
+  const file = configPath();
+  if (!fs.existsSync(file)) return null;
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  // 同一秒内发生两次损坏时，rename 会**覆盖**上一份备份（POSIX rename 是覆盖语义）——
+  // 而备份的意义正是"一份都不许丢"。故重名时顺延编号。
+  let dest = `${file}.corrupt-${stamp}`;
+  for (let k = 1; fs.existsSync(dest); k += 1) dest = `${file}.corrupt-${stamp}-${k}`;
   try {
-    return JSON.parse(fs.readFileSync(configPath(), 'utf8'));
+    fs.renameSync(file, dest);
   } catch {
     return null;
   }
+  console.warn(
+    `[MingDao] ⚠ 配置文件读不出来，已**改名备份**而不是覆盖它：\n` +
+      `  原因：${reason}\n` +
+      `  备份：${dest}\n` +
+      `  接下来会按全新配置继续（首次运行向导 / 最小可用配置）。请从备份里把\n` +
+      `  customModels / mcpServers / sync / net / costGuard 等字段手动并回新的 config.json。`
+  );
+  return dest;
+}
+
+/** 读取配置对象（不存在/损坏返回 null）；返回值为用户可编辑的任意 JSON 配置，类型不定
+ *
+ * 注意（v0.6.3 / H-7）：null **同时**表示「不存在」与「读不出来」。凡是要**写**配置的调用点，
+ * 必须先用 `readConfigStrict()` 区分这两件事，否则会把损坏配置静默覆盖掉。
+ * @returns {any} */
+export function loadConfig() {
+  const r = readConfigStrict();
+  return r.ok ? r.data : null;
 }
 
 /** 桌面版首次运行：无配置时自动创建最小可用配置（引导在 WebUI 内完成，
  * 不再要求先去终端跑 mingdao init）。CLI 的 mingdao init 向导不受影响。 */
 export function ensureMinimalConfig() {
-  const existing = loadConfig();
-  if (existing) return existing;
+  const strict = readConfigStrict();
+  if (strict.ok && strict.data) return strict.data;
+  // v0.6.3（H-7）：存在但读不出来 → 先备份再写，绝不让"首启自动建配置"吃掉用户配置
+  if (strict.exists && !strict.ok) quarantineCorruptConfig(strict.error || '未知原因');
   ensureHome();
   const pp = PROVIDERS['deepseek'] || Object.values(PROVIDERS)[0];
   const model = modelPreset(DEFAULT_MODEL) ? DEFAULT_MODEL : pp.models[0];

package/src/constraints.js

@@ -5,6 +5,8 @@
 // 而 prompt 是建议不是强制——模型越界一次就是事故。本模块提供三个执行时机：
 //
 //   ① PreToolUse  —— tool-deny / tool-arg-require / arg-forbid：阻止执行并回填错误给模型
+//                    confirm：**即使权限档位是 auto 也要人工确认**（v0.6.3 起真正求值，
+//                    此前它只是 KINDS 里的一个字符串，永远不会被求值——红线静默消失）
 //   ② PostToolUse —— completeness / result-forbid：拒绝工具结果并要求补采
 //   ③ 输出前       —— output-forbid：按 action（block / block-and-rewrite / warn）处理
 //
@@ -26,6 +28,34 @@ export const PATTERN_KINDS = new Set(['arg-forbid', 'output-forbid', 'result-for
 /** 作用域限于「某个工具」的 kind：其 pattern 坏掉时可以精确 fail-closed（只拦这个工具） */
 const SCOPED_PATTERN_KINDS = new Set(['arg-forbid', 'result-forbid']);
 
+// v0.6.3（审计 BUG-040）：completeness（必填项校验）的「缺失」哨兵**不能只认中文**。
+//
+// 原实现硬编码 `String(v).trim() === '未提及'`：英文/多语种会话里模型会写
+// "not mentioned" / "N/A" / "unknown" —— 判定不中，于是"必填项缺失"这条红线
+// **因为语言而静默停止生效**（合规约束里最不该出现的一种失效）。
+// 保守取一组明确的"未提供"措辞；**刻意不含 `无` / `none`**——医疗等域里
+// 「过敏史: 无」是**有效数据**，把它当缺失会误拒。域内若另有约定，
+// 由约束自己声明 `missingValues: [...]` 扩展。
+const MISSING_VALUE_SENTINELS = new Set([
+  'null', 'undefined', 'n/a', 'na', 'not mentioned', 'not provided', 'not available',
+  'not recorded', 'unknown', 'tbd', '未提及', '未提供', '未采集', '未填写', '未记录',
+  '不详', '未知', '待补充', '待采集', '待确认',
+]);
+/**
+ * 该字段值是否应判为「缺失」。
+ * @param {any} c 约束（可带 missingValues 扩展）
+ * @param {any} v 字段值
+ */
+function isMissingFieldValue(/** @type {any} */ c, /** @type {any} */ v) {
+  if (v === undefined || v === null) return true;
+  const t = String(v).trim();
+  if (t === '') return true;
+  const lower = t.toLowerCase();
+  if (MISSING_VALUE_SENTINELS.has(lower)) return true;
+  const extra = Array.isArray(c?.missingValues) ? c.missingValues : [];
+  return extra.some((/** @type {any} */ x) => String(x).trim().toLowerCase() === lower);
+}
+
 /** 预编译的正则缓存：pattern → RegExp（非法正则返回 null，由调用方 fail-closed） */
 const reCache = new Map();
 /** @param {any} pattern */
@@ -152,7 +182,7 @@ export function compileConstraints(list) {
       continue;
     }
     n += 1;
-    if (c.kind === 'tool-deny' || c.kind === 'tool-arg-require' || c.kind === 'arg-forbid') pre.push(c);
+    if (c.kind === 'tool-deny' || c.kind === 'tool-arg-require' || c.kind === 'arg-forbid' || c.kind === 'confirm') pre.push(c);
     else if (c.kind === 'completeness' || c.kind === 'result-forbid') post.push(c);
     else output.push(c);
   }
@@ -177,6 +207,11 @@ export function compileConstraints(list) {
  */
 function event(c, stage, extra = {}) {
   return {
+    // v0.6.3（P1-1）：事件必须自带 `id`。此前只有 `constraint`，而**两个**消费方都读 `id`
+    // （agent.js 的账本 `tool.call.constraint.id`、replay.js 的 `constraintId`），
+    // 于是每次被红线拦下，账本里「是哪条红线拦的」恒为 null——不报错、只输出 null，
+    // 任何断言都不会失败。`constraint` 保留，兼容既有事件消费方与历史账本。
+    id: c?.id || null,
     pack: c?.pack || null,
     constraint: c?.id || null,
     kind: c?.kind || null,
@@ -188,12 +223,15 @@ function event(c, stage, extra = {}) {
 /**
  * ① PreToolUse：工具与参数层面的红线。
  * @param {any} compiled @param {any} toolName @param {any} args
- * @returns {{ blocked: boolean, reason: string, event: any } | null}
+ * @returns {{ blocked: boolean, needsConfirm?: boolean, reason: string, event: any } | null}
  */
 export function checkPreTool(compiled, toolName, args) {
   if (!compiled?.active) return null;
   try {
+    // 第一遍：**阻断类**。confirm 必须留到第二遍——否则「confirm 声明在 tool-deny 之前」
+    // 会让 confirm 先返回、后面的 deny 再也走不到，等于给红线开了后门（fail-open）。
     for (const c of compiled.pre) {
+      if (c.kind === 'confirm') continue;
       if (!toolMatches(c, toolName)) continue;
       if (c.kind === 'tool-deny') {
         return { blocked: true, reason: `领域约束「${c.id}」禁止调用 ${c.tool}`, event: event(c, 'pre-tool', { action: 'block' }) };
@@ -229,6 +267,20 @@ export function checkPreTool(compiled, toolName, args) {
         }
       }
     }
+    // 第二遍：confirm（v0.6.3 / P1-2）。本函数是纯函数、拿不到 IO，因此只**声明**
+    // 「这次调用需要人工确认」，由调用方（agent.js）去问；问不到/答否一律按阻断处理。
+    // 返回 `blocked:false` 而非 `blocked:true`，是为了让调用方能区分
+    // 「规则直接禁止」与「规则要求先确认」两种情况，回填给模型的措辞也不同。
+    for (const c of compiled.pre) {
+      if (c.kind !== 'confirm') continue;
+      if (!toolMatches(c, toolName)) continue;
+      return {
+        blocked: false,
+        needsConfirm: true,
+        reason: `领域约束「${c.id}」要求人工确认后才可调用 ${c.tool}`,
+        event: event(c, 'pre-tool', { action: 'confirm' }),
+      };
+    }
     return null;
   } catch (/** @type {any} */ err) {
     // fail-closed：约束求值异常按阻断处理，绝不静默放行
@@ -285,10 +337,7 @@ export function checkPostTool(compiled, toolName, result) {
           event: event(c, 'post-tool', { action: 'reject', reason: 'no-data' }),
         };
       }
-      const missing = (Array.isArray(c.fields) ? c.fields : []).filter((/** @type {any} */ f) => {
-        const v = data[f];
-        return v === undefined || v === null || String(v).trim() === '' || String(v).trim() === '未提及';
-      });
+      const missing = (Array.isArray(c.fields) ? c.fields : []).filter((/** @type {any} */ f) => isMissingFieldValue(c, data[f]));
       if (missing.length) {
         return {
           rejected: true,

package/src/credentials.js

@@ -15,15 +15,46 @@ export function credentialsPath() {
   return path.join(mingdaoHome(), 'credentials.json');
 }
 
-export function loadCredentials() {
+// v0.6.3（审计 H-8）：**必须区分「文件不存在」与「内容损坏」**。
+//
+// 原实现把两者都 `catch → {}`，而 key set/remove/import 的写路径是
+// 「loadCredentials() → 改一个键 → saveCredentials() 全量重写」——
+// 于是 credentials.json 一旦损坏（手改/中断写入），执行任意一次 key 写操作就会
+// **把其余全部凭据静默清空并打印成功**（实测复现）。
+//
+// 读路径（getStoredKey / key status）保持宽松语义不变；写路径必须用严格读并**拒绝写**。
+/**
+ * 严格读凭证库。
+ * @returns {{ok: boolean, missing: boolean, data: Record<string, any>, error: string|null}}
+ *   ok=false 且 missing=false 表示「文件存在但读不出来/解析失败」——**此时绝不能写**。
+ */
+export function readCredentialsStrict() {
+  let raw;
+  try {
+    raw = fs.readFileSync(credentialsPath(), 'utf8');
+  } catch (err) {
+    if (/** @type {any} */ (err)?.code === 'ENOENT') return { ok: true, missing: true, data: {}, error: null };
+    return { ok: false, missing: false, data: {}, error: String(/** @type {any} */ (err)?.message ?? err) };
+  }
   try {
-    const data = JSON.parse(fs.readFileSync(credentialsPath(), 'utf8'));
-    return data && typeof data === 'object' ? data : {};
-  } catch {
-    return {};
+    // 容错 BOM：Windows 上 PowerShell 的 `Set-Content -Encoding UTF8` 会写出 BOM，
+    // 那是**可解析**的内容，不该被当成损坏而拒绝服务（否则用户改一次配置就永远写不进去）。
+    const text = raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw;
+    const data = JSON.parse(text);
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+      return { ok: false, missing: false, data: {}, error: '顶层不是 JSON 对象' };
+    }
+    return { ok: true, missing: false, data, error: null };
+  } catch (err) {
+    return { ok: false, missing: false, data: {}, error: String(/** @type {any} */ (err)?.message ?? err) };
   }
 }
 
+export function loadCredentials() {
+  // 宽松读（读路径）：读不出来就当空——调用方只想知道「有哪些 key」
+  return readCredentialsStrict().data;
+}
+
 /** @param {any} creds */
 export function saveCredentials(creds) {
   ensureHome();