mingdao-harness 0.6.0 → 0.6.2

package/src/audit.js

@@ -8,10 +8,14 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { mingdaoHome, ensureHome } from './config.js';
 import { redactSecrets } from './redact.js';
+import { atomicWriteFileSync } from './atomic-write.js';
 
-const MAX_LINES = 20000;
+// v0.6.2（第三方代码审计 P2-2）：截断触发改为看**文件大小**。
+// 原判据 `auditCount > 20000` 是**进程内**计数：CLI 每次会话只 append 几次、进程结束即归零，
+// 于是这个条件永远不成立 → 截断是**死代码**，audit.jsonl 对 CLI 用户无界增长
+// （与注释里「低频截断」的意图正好相反）。按大小判断跨进程有效且同样是 O(1)。
+const MAX_BYTES = 4 * 1024 * 1024; // 约合 20000 行
 const KEEP_LINES = 10000;
-let auditCount = 0; // 内存计数（评估 P3-2）：避免每次写入都整文件读一遍只为查行数
 
 export function auditFile() {
   return path.join(mingdaoHome(), 'audit.jsonl');
@@ -20,6 +24,18 @@ export function auditFile() {
 // 轻量脱敏（统一单一来源 v0.3.1 P1-1）：sk-/ghp_ 等常见前缀掩码，见 src/redact.js
 export { redactSecrets };
 
+let auditWarned = false;
+let auditError = /** @type {string|null} */ (null);
+let auditFailures = 0;
+/** 审计写入失败次数（0 = 本次进程内从未失败）。 */
+export function auditWriteFailures() {
+  return auditFailures;
+}
+/** 审计最近一次写失败原因（无则 null）。 */
+export function auditWriteError() {
+  return auditError;
+}
+
 export function writeAudit(/** @type {any} */ entry) {
   try {
     ensureHome();
@@ -28,21 +44,35 @@ export function writeAudit(/** @type {any} */ entry) {
     try {
       fs.chmodSync(file, 0o600);
     } catch {}
-    auditCount += 1;
-  } catch {
-    return; // 审计失败绝不影响会话
+
+  } catch (err) {
+    // v0.6.2（B-WS-1/2 第八处）：仍然「不影响会话」（审计不能反过来打断用户干活），
+    // 但**不再无声**——此前连"这次运行的审计记录是空的"都无从得知。
+    // 保留计数与原因供诊断/测试；一次性 console.warn 避免每步刷屏。
+    auditFailures += 1;
+    auditError = String(/** @type {any} */ (err)?.message ?? err);
+    if (!auditWarned) {
+      auditWarned = true;
+      console.warn(
+        `[MingDao] ⚠ 审计记录写入失败：${auditError}\n` +
+          `  该次运行的 audit.jsonl 会缺事件（执行账本 ledger/ 不受影响）；请检查 ${auditFile()} 的磁盘空间与权限。`
+      );
+    }
+    return;
   }
-  // 低频截断：跨过上限后每 200 条才读盘检查一次
-  if (auditCount > MAX_LINES && auditCount % 200 === 0) {
-    try {
-      const raw = fs.readFileSync(auditFile(), 'utf8');
-      const lines = raw.split('\n').filter(Boolean);
-      if (lines.length > MAX_LINES) {
-        fs.writeFileSync(auditFile(), lines.slice(-KEEP_LINES).join('\n') + '\n', { mode: 0o600 });
-        auditCount = KEEP_LINES;
+  // 低频截断：statSync 廉价，只有真的超过阈值才整文件读一次并重写
+  try {
+    const f = auditFile(); // 上面 try 里的 file 是块内作用域，这里单独取一次
+    if (fs.statSync(f).size > MAX_BYTES) {
+      const lines = fs.readFileSync(f, 'utf8').split('\n').filter(Boolean);
+      if (lines.length > KEEP_LINES) {
+        // v0.6.2（P2-3）：**原子写**——原先直接 writeFileSync，截断过程中崩溃会留下半截
+        // audit.jsonl（审计证据丢事件）。atomicWriteFileSync 的 tmp 名含 pid+随机后缀，
+        // 写完 rename 原子替换，读者永远看到完整文件；mode 保持 0600。
+        atomicWriteFileSync(f, lines.slice(-KEEP_LINES).join('\n') + '\n', { mode: 0o600 });
       }
-    } catch {}
-  }
+    }
+  } catch {}
 }
 
 export function listAudit(limit = 20) {

package/src/autostart.js

@@ -50,41 +50,92 @@ export function autostartStatus() {
   return fs.existsSync(autostartPath());
 }
 
-export function enableAutostart() {
-  const target = autostartPath();
-  try {
-    fs.mkdirSync(path.dirname(target), { recursive: true });
-    const node = nodeBin();
-    const cli = cliEntry();
-    if (process.platform === 'win32') {
-      fs.writeFileSync(target, `@echo off\r\nstart "" "${node}" "${cli}" web 3820\r\n`);
-    } else if (process.platform === 'darwin') {
-      const plist = `<?xml version="1.0" encoding="UTF-8"?>
+// ---------- v0.6.2（第三方审计 P2-14）：三个平台的自启文件都缺转义 ----------
+// 路径是**用户可控**的（家目录/用户名/node 安装位置）。含 & < > 的路径插进 plist 会让 XML
+// 非法 → launchctl 加载失败，而写文件本身"成功"，于是表现为「开关打开了但登录后不自启」，
+// 且错误只在 StandardErrorPath 里（用户看不到）。Linux 的 .desktop 与 Windows 的 .bat 同理。
+// 转义规则按各自格式的规范来，抽成纯函数以便直接测试（不动用户真实的自启配置）。
+
+/** XML 文本转义（plist 的 <string> 内容） */
+export function escapeXml(/** @type {any} */ s) {
+  return String(s ?? '')
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+/** Desktop Entry 规范：双引号参数内的 \ " $ ` 必须反斜杠转义 */
+export function escapeDesktopEntry(/** @type {any} */ s) {
+  return String(s ?? '')
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\$/g, '\\$')
+    .replace(/`/g, '\\`');
+}
+
+/** Windows 批处理：% 是变量展开符，须写成 %% */
+export function escapeBatch(/** @type {any} */ s) {
+  return String(s ?? '').replace(/%/g, '%%');
+}
+
+/** macOS LaunchAgent plist 内容（纯函数，便于断言转义正确） */
+export function plistContent(/** @type {any} */ node, /** @type {any} */ cli, /** @type {any} */ pathEnv) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0"><dict>
   <key>Label</key><string>org.mingdao.web</string>
   <key>ProgramArguments</key><array>
-    <string>${node}</string><string>${cli}</string><string>web</string><string>3820</string>
+    <string>${escapeXml(node)}</string><string>${escapeXml(cli)}</string><string>web</string><string>3820</string>
   </array>
   <key>RunAtLoad</key><true/>
   <key>EnvironmentVariables</key><dict>
-    <key>PATH</key><string>${path.dirname(node)}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
+    <key>PATH</key><string>${escapeXml(pathEnv)}</string>
   </dict>
   <key>StandardOutPath</key><string>/tmp/mingdao-web.log</string>
   <key>StandardErrorPath</key><string>/tmp/mingdao-web.err</string>
 </dict></plist>
 `;
+}
+
+/** Linux XDG Autostart .desktop 内容 */
+export function desktopEntryContent(/** @type {any} */ node, /** @type {any} */ cli) {
+  return (
+    '[Desktop Entry]\nType=Application\nName=MingDao 自动启动\n' +
+    'Comment=MingDao-Harness WebUI 服务器（登录时启动）\n' +
+    `Exec="${escapeDesktopEntry(node)}" "${escapeDesktopEntry(cli)}" web 3820\n` +
+    'X-GNOME-Autostart-enabled=true\nHidden=false\n'
+  );
+}
+
+/** Windows 启动文件夹 .bat 内容 */
+export function batchContent(/** @type {any} */ node, /** @type {any} */ cli) {
+  return `@echo off\r\nstart "" "${escapeBatch(node)}" "${escapeBatch(cli)}" web 3820\r\n`;
+}
+
+export function enableAutostart() {
+  const target = autostartPath();
+  try {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const node = nodeBin();
+    const cli = cliEntry();
+    if (process.platform === 'win32') {
+      fs.writeFileSync(target, batchContent(node, cli));
+    } else if (process.platform === 'darwin') {
+      const plist = plistContent(node, cli, `${path.dirname(node)}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin`);
       fs.writeFileSync(target, plist);
+      // 写完先自检：转义写错 / 路径怪异会让 plist 非法，而 launchd 只在加载时报错、
+      // 用户看不到（表现为「开关打开了但登录后不自启」）。这里把它变成**立即失败**。
+      try {
+        const chk = spawnSync('plutil', ['-lint', target], { stdio: 'ignore' });
+        if (!chk.error && chk.status !== 0) return false;
+      } catch {}
       // 立即注册（否则要等下次登录才生效，用户以为开关没起作用）。失败不致命：
       // 文件已落盘，下次登录仍会由 RunAtLoad 拉起。
       try {
         spawnSync('launchctl', ['bootstrap', `gui/${process.getuid?.() ?? 0}`, target], { stdio: 'ignore' });
       } catch {}
     } else {
-      fs.writeFileSync(
-        target,
-        `[Desktop Entry]\nType=Application\nName=MingDao 自动启动\nComment=MingDao-Harness WebUI 服务器（登录时启动）\nExec="${node}" "${cli}" web 3820\nX-GNOME-Autostart-enabled=true\nHidden=false\n`
-      );
+      fs.writeFileSync(target, desktopEntryContent(node, cli));
     }
     return true;
   } catch {

package/src/cachestats.js

@@ -11,11 +11,35 @@ export function cacheStatsFile() {
   return path.join(mingdaoHome(), 'cache-stats.jsonl');
 }
 
-// 内存计数 + 低频轮转（评估 P3-3：此前无限增长且每次全量解析）
+// 低频轮转（评估 P3-3：此前无限增长且每次全量解析）
+// v0.6.2（第三方代码审计 P2-2）：触发改为**文件大小**，删掉进程内计数。
+// 三份「追加 + 超限截断」实现（audit / journal / cachestats）此前都用进程内计数，
+// 对 CLI 用户永远不成立（每次只写几条、进程结束归零）——轮转全是**死代码**，文件无界增长。
+// 这里尤其要紧：todayCost() 与日费用护栏读的就是本文件。
 const MAX_LINES = 20000;
 const KEEP_LINES = 10000;
-let cacheStatsCount = 0;
+const MAX_BYTES = 4 * 1024 * 1024; // 约合 20000 行
 
+// v0.6.2（第三方报告 B-WS-1/2 第三处）：写入失败**不再静默**。
+//
+// 为什么这一处特别要紧：cache-stats.jsonl 是 todayCost() 与日费用护栏（costGuard）的**唯一数据源**。
+// 读侧早就做了「读不了就告警一次、返回 null 表示无法判断」（见 cost-guard.js）——
+// 而写侧一直 `catch {}`：**追加失败时文件根本不变**，于是读侧的 mtime 缓存继续命中旧值，
+// 护栏拿到一个「看起来正常」的偏小数字，用户可能超支而毫不知情。
+// 读侧已经会说真话，写侧不会——这就是本次要补的不对称。
+let writeWarned = false;
+let rotateWarned = false;
+let lastWriteError = /** @type {string|null} */ (null);
+
+/** 费用明细最近一次写失败原因（无则 null）。给诊断与测试用，避免只能靠 console 观察。 */
+export function cacheStatsWriteError() {
+  return lastWriteError;
+}
+
+/**
+ * @param {any} entry
+ * @returns {{ok: boolean, error: string|null, phase: 'append'|'rotate'|null}}
+ */
 export function recordCacheStats(/** @type {any} */ entry) {
   try {
     ensureHome(); // 审计 B10：与 audit/journal 一致，目录缺失不静默丢统计
@@ -46,10 +70,23 @@ export function recordCacheStats(/** @type {any} */ entry) {
       auxReason: entry.auxReason ? String(entry.auxReason) : undefined,
     });
     fs.appendFileSync(cacheStatsFile(), line + '\n');
-    cacheStatsCount += 1;
-  } catch {}
-  if (cacheStatsCount > MAX_LINES && cacheStatsCount % 200 === 0) {
-    try {
+  } catch (err) {
+    const msg = String(/** @type {any} */ (err)?.message ?? err);
+    lastWriteError = msg;
+    // 只提示一次：写不进去通常是持续性问题（磁盘满/权限），每回合刷屏反而让人忽略它
+    if (!writeWarned) {
+      writeWarned = true;
+      console.warn(
+        `[MingDao] ⚠ 费用明细写入失败：${msg}\n` +
+          `  今日费用护栏会**少计**这部分消费（可能超支而不知）；请检查 ${cacheStatsFile()} 的磁盘空间与权限。`
+      );
+    }
+    // 追加都失败了，后面的轮转毫无意义（statSync 也大概率抛错），直接返回真实原因，
+    // 不要让轮转分支的异常把 append 的原因覆盖掉
+    return { ok: false, error: msg, phase: 'append' };
+  }
+  try {
+    if (fs.statSync(cacheStatsFile()).size > MAX_BYTES) {
       // 审计 P2-3（v0.4.2）：轮转 read-modify-write 加跨进程锁——web/CLI/worker 多进程并发轮转时，
       // 读与写之间他人追加的行会被覆写丢失；锁内重读再瘦身，写用原子替换。
       withFileLockSync(cacheStatsFile() + '.lock', () => {
@@ -77,11 +114,20 @@ export function recordCacheStats(/** @type {any} */ entry) {
           const order = new Map(lines.map((l, i) => [l, i]));
           merged.sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
           atomicWriteFileSync(cacheStatsFile(), merged.join('\n') + '\n');
-          cacheStatsCount = merged.length;
         }
       });
-    } catch {}
+    }
+  } catch (err) {
+    // 轮转失败与追加失败是两件事：这里丢的不是账，而是文件会持续增长
+    const msg = String(/** @type {any} */ (err)?.message ?? err);
+    lastWriteError = msg;
+    if (!rotateWarned) {
+      rotateWarned = true;
+      console.warn(`[MingDao] ⚠ 费用明细轮转失败：${msg}\n  ${cacheStatsFile()} 会持续增长（不影响计费，但请检查磁盘空间/权限）。`);
+    }
+    return { ok: false, error: msg, phase: 'rotate' };
   }
+  return { ok: true, error: null, phase: null };
 }
 
 // listCacheStats 读取缓存（审计：costGuard 每步 / WebUI 每 15s / /cost 命令都调用——
@@ -153,7 +199,7 @@ export function recordUsage(/** @type {any} */ modelName, /** @type {any} */ usa
     // 覆盖内置定价 + 外部定价 + config.pricing.overrides 三条来源，不再依赖 modelPreset 单一判断。
     cost = estimateCost(modelName, prompt, completion, null, priceAt);
   }
-  recordCacheStats({
+  return recordCacheStats({
     model: modelName,
     prompt,
     completion,
@@ -188,14 +234,14 @@ export function formatCacheSummary(/** @type {any} */ sum) {
  * @param {any} modelName @param {any} usage @param {string} [reason]
  */
 export function recordAuxUsage(modelName, usage, reason = 'aux') {
-  if (!usage) return;
+  if (!usage) return { ok: true, error: null, phase: null };
   try {
     const prompt = usage.prompt_tokens || 0;
     const completion = usage.completion_tokens || 0;
-    if (!prompt && !completion) return;
+    if (!prompt && !completion) return { ok: true, error: null, phase: null };
     const split = cacheSplit(usage);
     const cost = split ? estimateCost(modelName, prompt, completion, split) : estimateCost(modelName, prompt, completion, null);
-    recordCacheStats({
+    return recordCacheStats({
       model: modelName,
       prompt,
       completion,
@@ -206,7 +252,14 @@ export function recordAuxUsage(modelName, usage, reason = 'aux') {
       aux: true,
       auxReason: reason,
     });
-  } catch {}
+  } catch (err) {
+    // 辅助调用的计费同样不能静默丢（自动路由/标题/记忆提炼的费用也是钱）。
+    // 注意不在这里写 lastWriteError：本 try 也覆盖计价计算，真正的**写**失败已由
+    // recordCacheStats 自己记录，在此覆盖会把「计算失败」误报成「写入失败」。
+    const msg = String(/** @type {any} */ (err)?.message ?? err);
+    return { ok: false, error: msg, phase: null };
+  }
+  return { ok: true, error: null, phase: null };
 }
 
 /**

package/src/cli.js

@@ -4,6 +4,7 @@
 // /mode 模型快捷切换、/verbose 思考开关、/status、/cost、会话选择恢复。
 
 import fs from 'node:fs';
+import { DEFAULT_MODEL } from './models.js';
 import path from 'node:path';
 import readline from 'node:readline';
 import { loadConfig, saveConfig, runWizard, ensureHome, mingdaoHome } from './config.js';
@@ -16,6 +17,7 @@ import { makeTokenCounter } from './tokenizer.js';
 import { messageTokens } from './context.js';
 import { startMcpServers } from './mcp.js';
 import { startTask, listTasks, patchTask, killTask, formatTaskRow } from './tasks.js';
+import { installPipeGuards } from './proc.js';
 import { enableAutostart, disableAutostart, autostartStatus, autostartPath } from './autostart.js';
 import { isLocalBaseUrl } from './model-caps.js';
 import { notifyTaskDone } from './notify.js';
@@ -37,7 +39,7 @@ import {
   postRunStatus,
 } from './schedule.js';
 import { createAgent } from './agent.js';
-import { saveTaskStateMerge, clearTaskState } from './task-state.js';
+import { saveTaskStateMerge, clearTaskState, checkpointHint } from './task-state.js';
 import { createPermission } from './permissions.js';
 import { buildSystemPrompt } from './prompts.js';
 import { listSkills, tamperedSkillNames } from './skills.js';
@@ -121,6 +123,9 @@ async function generatePlan(/** @type {any} */ provider, /** @type {any} */ mode
 // —— 后台任务 worker（Phase C C2）：已抽取至 src/tasks/worker.js，入口处动态导入 ——
 
 async function main() {
+  // v0.6.2（B-UI-1/B-CLI-1/B-REPL-1）：先装管道兜底，再输出任何东西。
+  // `mingdao … | head -1` 这类最常见的用法此前会因 stdout EPIPE 未捕获而带堆栈崩溃。
+  installPipeGuards({ exitOnEpipe: true });
   const opts = parseArgs(process.argv.slice(2));
   if (opts.help) {
     printHelpLines(console.log);
@@ -251,7 +256,7 @@ async function main() {
         for (const j of jobs) {
           // 崩溃恢复（审计）：'running' 但无人监督且 worker 已死 → 按任务结果定案或重新排队，
           // 避免任务永久卡在 running（此前 daemon 重启后既不重跑也不收尾）
-          if (j.status === 'running' && !supervising.has(j.id) && !sleeperAlive(j.pid)) {
+          if (j.status === 'running' && !supervising.has(j.id) && !sleeperAlive(j.pid, j.id)) {
             const t = j.lastTaskId ? readTask(home0, j.lastTaskId) : null;
             // v0.4.7（P2 T15）：先看「跑这个任务的宿主进程」是否仍存活。存活说明它正在跑
             // （可能还没写 lastTaskId），**等它**——否则「本 daemon 刚接管 + 旧 daemon 在途」
@@ -279,7 +284,7 @@ async function main() {
             continue;
           }
           if (j.status !== 'pending' || handled.has(j.id)) continue;
-          if (sleeperAlive(j.pid)) continue; // 旧式 sleeper 仍在：交回给它，避免双跑
+          if (sleeperAlive(j.pid, j.id)) continue; // 旧式 sleeper 仍在：交回给它，避免双跑
           if (j.lastTaskId) {
             const t = readTask(home0, j.lastTaskId);
             if (t && t.status === 'running') continue; // worker 仍在跑（异常窗口），不重拉
@@ -345,7 +350,7 @@ async function main() {
   }
 
   // 模型回退链（向导允许跳过模型选择 → cfg.model 可缺省）：参数 > config > 该服务商首个预设模型 > flash
-  let modelName = opts.model || cfg.model || /** @type {any} */ (PROVIDERS)[cfg.provider]?.models?.[0] || 'deepseek-v4-flash';
+  let modelName = opts.model || cfg.model || /** @type {any} */ (PROVIDERS)[cfg.provider]?.models?.[0] || DEFAULT_MODEL;
   const io = createIO();
   const workingDir = process.cwd();
 
@@ -533,16 +538,20 @@ async function main() {
         } catch {}
       }
       // v0.3.0 P0-2：单次提问跑满步数/中断落检查点（--continue 可续跑），正常完成清除
+      // v0.6.2：检查点写入结果必须被检查——上面 banner 已经承诺「发送『继续』即可」，
+      // 写失败却不出声，就等于给了一个兑现不了的承诺。
       if (res.capHit || res.aborted) {
-        saveTaskStateMerge(path.basename(session.file), {
+        const hint = checkpointHint(saveTaskStateMerge(path.basename(session.file), {
           goal: question,
           progress: res.text || '',
           artifacts: res.perf?.deliverables || [],
           status: res.capHit ? 'cap' : 'interrupted',
           updatedAt: new Date().toISOString(),
-        });
+        }), 'save');
+        if (hint) io.print(style(hint, C.yellow));
       } else {
-        clearTaskState(path.basename(session.file));
+        const hint = checkpointHint(clearTaskState(path.basename(session.file)), 'clear');
+        if (hint) io.print(style(hint, C.yellow));
       }
       try {
         await finalizeSession({ cfg, provider, model: titleModel(cfg, modelName), home, workingDir, messages, turns: 1, lastText: res.text || '' });

package/src/commands/desktop.js

@@ -1,6 +1,7 @@
 // 命令族：mingdao desktop —— 任意目录启动 Electron 桌面版
 // 定位仓库 → 检查 desktop/node_modules 里的 electron → 拉起；缺依赖给出镜像安装指引。
 import { spawn } from 'node:child_process';
+import { spawnOpts } from '../proc.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { findRepoRoot } from '../update.js';
@@ -32,7 +33,7 @@ export async function handleDesktop(/** @type {any} */ args) {
     return true;
   }
   console.log('正在启动 MingDao Harness 桌面版…（窗口弹出即成功；托盘常驻，关闭窗口 = 最小化到托盘）');
-  const child = spawn(localBin, [desktopDir], { cwd: desktopDir, stdio: 'ignore', detached: true });
+  const child = spawn(localBin, [desktopDir], { cwd: desktopDir, stdio: 'ignore', detached: true, ...spawnOpts({ detached: true }) });
   child.on('error', (err) => {
     console.log('[错误] 启动 Electron 失败：' + (err?.message || err));
     process.exitCode = 1;

package/src/commands/diagnose.js

@@ -6,6 +6,7 @@ import os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { createIO, style, C } from '../ui.js';
 import { mingdaoHome, ensureHome, loadConfig } from '../config.js';
+import { redactConfig } from '../redact.js';
 import { credentialsPath } from '../credentials.js';
 import { listAudit } from '../audit.js';
 import { redactSensitive } from '../redact.js';
@@ -50,7 +51,9 @@ export async function handleDiagnose(/** @type {any} */ _cmd, /** @type {any} */
     push('');
     push('## 配置（config.json，已脱敏）');
     const cfg = loadConfig();
-    push(cfg ? redactSensitive(JSON.stringify(cfg, null, 2)) : '（不存在或读取失败）');
+    // v0.6.2（P2-13）：改用**结构感知**脱敏——按字段名的正则堵不住
+    // `mcpServers.*.env.<自定义名>` 这类值，而诊断包是用户会贴到公开渠道的产物。
+    push(cfg ? JSON.stringify(redactConfig(cfg), null, 2) : '（不存在或读取失败）');
 
     // v0.4.1：模型能力定位——本地模型未声明 contextWindow 会兜底 32k → maxOutput/budget 偏小，
     // 表现为「输出截断/频繁压缩」。此处显式提示，帮用户自诊。
@@ -98,7 +101,13 @@ export async function handleDiagnose(/** @type {any} */ _cmd, /** @type {any} */
     const cwdMem = projectMemoryFile(process.cwd());
     push(`当前目录项目记忆：${redactSensitive(cwdMem)}（${fs.existsSync(cwdMem) ? '存在' : '无'}）`);
 
-    fs.writeFileSync(outFile, L.join('\n') + '\n');
+    // v0.6.2（P2-13）：诊断包按 0600 落盘——它与 config/日志/审计同属敏感产物，
+    // 本仓其它敏感文件（credentials.json 等）一律 0600，只有这里漏了。先写后 chmod，
+    // 因为 mode 只在**创建**时生效，已存在的旧文件不会自动收紧。
+    fs.writeFileSync(outFile, L.join('\n') + '\n', { mode: 0o600 });
+    try {
+      fs.chmodSync(outFile, 0o600);
+    } catch {}
     io.print(style(`✓ 诊断报告已生成：${outFile}`, C.green));
     io.print(style('请把该文件内容贴到反馈渠道排查；密钥/token/私网路径已脱敏。', C.dim));
   } catch (/** @type {any} */ err) {

package/src/commands/ledger.js

@@ -74,13 +74,17 @@ export async function handleLedger(cmd, args) {
 
   if (sub === 'verify') {
     const v = verifyRun(runId);
-    if (v.ok) {
-      io.print(`✅ ${runId} 哈希链完整（${v.total} 条事件未被改动）。`);
+    if (v.ok && v.sealed) {
+      io.print(`✅ ${runId} 校验通过：${v.total} 条事件链内一致，且与封条吻合（未被改动、尾部未被截断）。`);
+    } else if (v.ok) {
+      // 链内一致 ≠ 完整。原实现只报「哈希链完整」，把「尾部被删掉一截」说成了完整。
+      io.print(style(`⚠ ${runId} 链内一致（${v.total} 条事件），但完整性无法确认：${v.warning}。`, C.yellow));
+      process.exitCode = 1;
     } else {
       io.print(style(`❌ ${runId} 校验失败：${v.error}`, C.red));
       process.exitCode = 1;
     }
-    io.print(style('说明：哈希链只能证明「自写入后未被改动」，不含可信时间戳，不等同于审计级不可否认。', C.dim));
+    io.print(style('说明：哈希链 + 封条只能证明「自写入后未被改动、尾部未被截断」，不含可信时间戳，不等同于审计级不可否认。', C.dim));
     return true;
   }
 

package/src/commands/pack.js

@@ -3,13 +3,19 @@
 // 因此可以在没有内核运行时的环境里安全执行。
 import fs from 'node:fs';
 import path from 'node:path';
-import { listPacks, loadPack, validateManifest, coreVersionOf, SUPPORTED_PACK_API, CONSTRAINT_KINDS, packedDirsForHelp } from '../packs.js';
+import { listPacks, loadPack, 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 new <名字>           生成最小可用 Pack 脚手架
   mingdao pack info <名字>          单个 Pack 的贡献面明细
+  mingdao pack trust <项目目录>     信任该项目的 .mingdao/packs（未信任则**不挂载**）
+  mingdao pack untrust <项目目录>   撤销信任
+
+项目级 Pack 默认不挂载：项目里的 pack.mjs 会以完整 Node 权限在本进程内执行，
+不受 permission 模式约束。clone 来的仓库必须先 trust 才会加载（内容一变即自动失效）。
 
 说明：Pack API v${SUPPORTED_PACK_API.join('/')}（契约见 docs/PACK-API.md）。
 约束 kind：${[...CONSTRAINT_KINDS].join(' / ')}`;
@@ -28,7 +34,9 @@ export async function handlePack(cmd, args) {
   }
 
   if (sub === 'list') {
-    const found = listPacks({}, process.cwd());
+    // v0.6.2（代码审计 P2-4）：这里硬传 `{}` 导致**读不到 config.packs 声明的 Pack**——
+    // 用户按文档在 config.json 里声明了目录，`mingdao pack list` 却看不见它（info 同病）。
+    const found = listPacks(loadConfig() || {}, process.cwd());
     if (!found.length) {
       console.log('未发现任何 Pack。');
       console.log(`放置位置（三级遮蔽）：<项目>/.mingdao/packs/ > ${packedDirsForHelp()} > 内置 packs/`);
@@ -37,13 +45,59 @@ export async function handlePack(cmd, args) {
     }
     console.log(`共 ${found.length} 个 Pack（内核 ${coreVersionOf()}）：`);
     for (const p of found) {
-      const status = p.error ? `❌ ${p.error}` : `✅ apiVersion ${p.apiVersion}`;
+      // 未信任的项目级 Pack 会被 mountPacks 跳过——列表里必须**看得出来**，
+      // 否则用户会以为它生效了（这正是原缺陷「静默」的另一半）。
+      const status = p.gate
+        ? `⛔ 未信任（不挂载）——${p.gate === 'changed' ? '信任后内容已变化' : '执行 mingdao pack trust ' + (p.gateDir || '')}`
+        : p.error
+          ? `❌ ${p.error}`
+          : `✅ apiVersion ${p.apiVersion}`;
       console.log(`  ${p.name}${p.displayName ? '（' + p.displayName + '）' : ''} v${p.version || '?'} · 来源 ${p.source} · ${status}`);
       console.log(`      ${p.dir}`);
     }
     return true;
   }
 
+  if (sub === 'trust' || sub === 'untrust') {
+    const dir = String(args[1] || '').trim();
+    if (!dir) {
+      console.log(`[错误] 用法：mingdao pack ${sub} <项目目录>（会作用于该目录下的 .mingdao/packs）`);
+      process.exitCode = 1;
+      return true;
+    }
+    // 传项目目录或 packs 目录都接受：统一解析到 .mingdao/packs
+    const abs = path.resolve(dir);
+    const root = path.basename(abs) === 'packs' && path.basename(path.dirname(abs)) === '.mingdao' ? abs : path.join(abs, '.mingdao', 'packs');
+    if (!fs.existsSync(root)) {
+      console.log(`[错误] 未找到 Pack 目录：${root}`);
+      console.log('        该目录不存在时无需信任（没有项目级 Pack 会被加载）。');
+      process.exitCode = 1;
+      return true;
+    }
+    if (sub === 'untrust') {
+      const r = untrustPack(root);
+      if (r.error) {
+        console.log(`[错误] ${r.error}`);
+        process.exitCode = 1;
+        return true;
+      }
+      console.log(`✓ 已撤销信任：${r.dir}（该项目的 Pack 不再挂载）`);
+      return true;
+    }
+    const st = packTrustState(root);
+    const r = trustPack(root);
+    if (r.error) {
+      console.log(`[错误] ${r.error}`);
+      process.exitCode = 1;
+      return true;
+    }
+    console.log(`✓ 已信任项目级 Pack 目录：${r.dir}`);
+    console.log(`  内容指纹 ${String(r.sha256 || '').slice(0, 16)}…${st.reason === 'changed' ? '（与上次信任时不同，已更新为当前内容）' : ''}`);
+    console.log('  ⚠ 该目录下的 pack.mjs 会以完整 Node 权限在本进程内执行——只信任你自己审过的代码。');
+    console.log('  指纹变化后信任自动失效，需要重新执行本命令。');
+    return true;
+  }
+
   if (sub === 'verify') {
     const dir = String(args[1] || '').trim();
     if (!dir) {
@@ -163,7 +217,7 @@ export function createPack(ctx) {
 
   if (sub === 'info') {
     const name = String(args[1] || '').trim();
-    const found = listPacks({}, process.cwd()).find((p) => p.name === name);
+    const found = listPacks(loadConfig() || {}, process.cwd()).find((p) => p.name === name);
     if (!found) {
       console.log(`[错误] 未发现 Pack "${name}"。可用：mingdao pack list`);
       process.exitCode = 1;