mingdao-harness 0.6.3 → 0.6.4

package/src/atomic-write.js

@@ -19,6 +19,7 @@
 // 零依赖：仅 node:fs / node:path / node:crypto / node:async_hooks / Atomics.wait / timers/promises。
 
 import fs from 'node:fs';
+import { pidOwnedBy } from './proc.js';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -39,6 +40,41 @@ export function atomicWriteFileSync(/** @type {string} */ target, /** @type {str
   }
 }
 
+// ---------------------------------------------------------------------------
+// 「私有文件」写入（v0.6.3，审计 H-1）
+//
+// 背景：会话/记忆/任务/调度/工作空间/索引这些文件此前直接 appendFileSync / 原子写**不带 mode**，
+// 默认 umask 下是 0644——而会话原文会原样记录用户粘贴的 sk-*、PEM、JWT，同机其它用户可读。
+// 同仓的账本/审计/凭据早已 0600，属于「同模块两套口径」。
+//
+// 两条纪律：
+//   ① 创建时带 mode: 0o600；
+//   ② **每次写都补一次 chmod 自愈**——mode 只在创建时生效，对旧版本留下的 0644 文件不起作用
+//      （凭据/审计早已这么做，这里收敛成共享助手，避免八处各写一遍再漂移）。
+// ---------------------------------------------------------------------------
+
+/**
+ * 追加写入并保证 0600（对已存在文件收权自愈）。
+ * @param {string} file @param {string|Buffer} data
+ */
+export function appendFilePrivateSync(file, data) {
+  fs.appendFileSync(file, data, { mode: 0o600 });
+  try {
+    fs.chmodSync(file, 0o600);
+  } catch {}
+}
+
+/**
+ * 原子写入并保证 0600（对已存在文件收权自愈）。
+ * @param {string} file @param {string|Buffer} data
+ */
+export function atomicWritePrivateSync(file, data) {
+  atomicWriteFileSync(file, data, { mode: 0o600 });
+  try {
+    fs.chmodSync(file, 0o600);
+  } catch {}
+}
+
 export function atomicWriteJsonSync(/** @type {string} */ target, /** @type {any} */ value, { mode = 0o600 } = {}) {
   atomicWriteFileSync(target, JSON.stringify(value, null, 2) + '\n', { mode });
 }
@@ -72,7 +108,19 @@ function tryAcquire(lockPath) {
     throw err;
   }
   try {
-    fs.writeSync(fd, JSON.stringify({ pid: process.pid, at: Date.now() }));
+    // v0.6.3（M-11）：锁内容额外记下本进程的**入口脚本**，作为 pid 的身份凭据。
+    // 起因：陈旧回收只看「持有者 pid 是否存活」，而 pid 会被复用——复用给一个活进程后
+    // `procAlive` 恒真，这把锁**永不回收**，所有写方等到超时失败（死锁）。
+    // 有了 cmd（argv[1]），回收方可以用既有的 pidOwnedBy() 校验"活着的这个 pid 还是不是原来那个进程"。
+    // v0.6.3（M-11）：锁内容额外记下入口脚本的**文件名**作为 pid 的身份凭据。
+    // 起因：陈旧回收只看「持有者 pid 是否存活」，而 pid 会被复用——复用给一个活进程后
+    // `procAlive` 恒真，这把锁**永不回收**，所有写方等到超时失败（死锁）。
+    //
+    // 为什么是 basename 而不是 argv[1]：`ps` 显示的是**输入时的形态**，而 Node 把 argv[1]
+    // 解析成绝对路径——`node test/smoke.js` 在 ps 里就是 `node test/smoke.js`。
+    // 第一版存 argv[1]，于是"同进程内的并发任务"也被判成 pid 复用 → **把活锁抢走**，
+    // 既有的并发串行断言当场抓到（3 次自增只剩 1）。basename 在两种形态下都出现，是稳妥的交集。
+    fs.writeSync(fd, JSON.stringify({ pid: process.pid, at: Date.now(), cmd: path.basename(process.argv[1] || process.execPath) }));
   } finally {
     fs.closeSync(fd);
   }
@@ -105,10 +153,22 @@ function reclaimIfStale(lockPath, staleMs) {
     return true; // 锁文件刚被释放：立刻重试
   }
   let holderPid = 0;
+  let holderCmd = '';
   try {
-    holderPid = Number(JSON.parse(fs.readFileSync(lockPath, 'utf8'))?.pid) || 0;
+    const meta = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+    holderPid = Number(meta?.pid) || 0;
+    holderCmd = String(meta?.cmd || '');
   } catch {}
-  const holderAlive = holderPid > 0 ? procAlive(holderPid) : null;
+  let holderAlive = holderPid > 0 ? procAlive(holderPid) : null;
+  // M-11：pid 存活 ≠ 原持有者还活着。用命令行归属校验识破 pid 复用：
+  //   · pidOwnedBy 返回 false → 这个 pid 现在跑的是**别的**程序 → 原持有者已死，可以回收；
+  //   · 返回 true（同一入口脚本，可能是也可能不是原进程）或 null（Windows/取不到命令行）→ 保持"活着"。
+  // 这一层是**严格改进**：原先这种情况一律不回收，现在只有"能确证不是原进程"时才回收。
+  if (holderAlive === true && holderCmd) {
+    try {
+      if (pidOwnedBy(holderPid, holderCmd) === false) holderAlive = false;
+    } catch {}
+  }
   const reclaimable = holderAlive === false || (holderAlive === null && Date.now() - st.mtimeMs > staleMs);
   if (!reclaimable) return false;
   // TOCTOU 防护（OfficeACE 报告）：unlink 前读锁内容并二次 stat 比对，

package/src/audit.js

@@ -8,7 +8,7 @@ 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';
+import { atomicWriteFileSync, withFileLockSync } from './atomic-write.js';
 
 // v0.6.2（第三方代码审计 P2-2）：截断触发改为看**文件大小**。
 // 原判据 `auditCount > 20000` 是**进程内**计数：CLI 每次会话只 append 几次、进程结束即归零，
@@ -40,10 +40,28 @@ export function writeAudit(/** @type {any} */ entry) {
   try {
     ensureHome();
     const file = auditFile();
-    fs.appendFileSync(file, JSON.stringify(entry) + '\n');
-    try {
-      fs.chmodSync(file, 0o600);
-    } catch {}
+    // v0.6.3（M-20）：**追加与轮转必须在同一把锁里**。原实现是「锁外追加 + 锁外读改写轮转」，
+    // 丢失窗口很实在：A 追加 → B 追加 → A 读到含 A 的快照 → A 原子写回 → B 那一行消失。
+    // 审计是合规证据，"少一行"等于证据链有洞，而且不报错。锁的范围含 append：代价是每次
+    // 工具调用多一次毫秒级文件锁（审计本就每工具调用一条，不在热路径上）。
+    let appended = false;
+    withFileLockSync(file + '.lock', () => {
+      fs.appendFileSync(file, JSON.stringify(entry) + '\n');
+      appended = true;
+      try {
+        fs.chmodSync(file, 0o600);
+      } catch {}
+      // 低频截断：statSync 廉价，只有真的超过阈值才整文件读一次并重写
+      if (fs.statSync(file).size > MAX_BYTES) {
+        const lines = fs.readFileSync(file, '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(file, lines.slice(-KEEP_LINES).join('\n') + '\n', { mode: 0o600 });
+        }
+      }
+    });
 
   } catch (err) {
     // v0.6.2（B-WS-1/2 第八处）：仍然「不影响会话」（审计不能反过来打断用户干活），
@@ -60,19 +78,6 @@ export function writeAudit(/** @type {any} */ entry) {
     }
     return;
   }
-  // 低频截断：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 {}
 }
 
 export function listAudit(limit = 20) {

package/src/cachestats.js

@@ -5,7 +5,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { mingdaoHome, ensureHome } from './config.js';
 import { estimateCost, cacheSplit, beijingDayStart, beijingParts } from './pricing.js';
-import { withFileLockSync, atomicWriteFileSync } from './atomic-write.js';
+import { withFileLockSync, atomicWriteFileSync, appendFilePrivateSync } from './atomic-write.js';
 
 export function cacheStatsFile() {
   return path.join(mingdaoHome(), 'cache-stats.jsonl');
@@ -69,63 +69,73 @@ export function recordCacheStats(/** @type {any} */ entry) {
       aux: entry.aux === true ? true : undefined,
       auxReason: entry.auxReason ? String(entry.auxReason) : undefined,
     });
-    fs.appendFileSync(cacheStatsFile(), line + '\n');
-  } 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 多进程并发轮转时，
-      // 读与写之间他人追加的行会被覆写丢失；锁内重读再瘦身，写用原子替换。
+    // v0.6.3（BUG-009）：**追加与轮转共用同一把锁**。
+    // 原实现是「锁外追加 + 锁内轮转」，仍留有丢失窗口：A 追加 → B 追加 → A 进锁读整文件、
+    // 算出瘦身结果、原子替换 —— B 那一行若落在 A 的「读」与「写」之间，就被整文件替换覆盖掉。
+    // 丢的是费用明细，而费用明细正是日费用护栏的依据（少计 → 超支而不自知）。
+    let appended = false;
+    try {
       withFileLockSync(cacheStatsFile() + '.lock', () => {
-        const raw = fs.readFileSync(cacheStatsFile(), 'utf8');
-        const lines = raw.split('\n').filter(Boolean);
-        if (lines.length > MAX_LINES) {
-          // v0.4.6 P2 修复：轮转必须保留**当天全部**记录。此前只保留最后 KEEP_LINES 行——
+        appendFilePrivateSync(cacheStatsFile(), line + '\n');
+        appended = true;
+        if (fs.statSync(cacheStatsFile()).size > MAX_BYTES) {
+          // 审计 P2-3（v0.4.2）：轮转的 read-modify-write 同样有并发窗口，现在它与追加在同一锁内。
+          // v0.4.6 P2：轮转必须保留**当天全部**记录。此前只保留最后 KEEP_LINES 行——
           // 单进程写满 2 万条后，当天早先的费用会被裁掉，todayCost() 随之变小，
           // 日费用护栏被静默重置（用户可再次超支而不自知）。当天行（最多 MAX_LINES 条）
           // 与最近 KEEP_LINES 行取并集，去重且保持原顺序。
-          const dayStart = beijingDayStart().getTime();
-          const todayLines = lines.filter((/** @type {string} */ l) => {
-            try {
-              return (JSON.parse(l).at || 0) >= dayStart;
-            } catch {
-              return false;
-            }
-          });
-          const tail = lines.slice(-KEEP_LINES);
-          const tailSet = new Set(tail);
-          const todayCapped = todayLines.length > MAX_LINES ? todayLines.slice(-MAX_LINES) : todayLines;
-          const todaySet = new Set(todayCapped);
-          const merged = [...todayCapped, ...tail.filter((l) => !todaySet.has(l))];
-          // 顺序按原文件恢复（避免打乱 byDay 折线的时间序）
-          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');
+          const raw = fs.readFileSync(cacheStatsFile(), 'utf8');
+          const rows = raw.split('\n').filter(Boolean);
+          if (rows.length > MAX_LINES) {
+            const dayStart = beijingDayStart().getTime();
+            const todayLines = rows.filter((/** @type {string} */ l) => {
+              try {
+                return (JSON.parse(l).at || 0) >= dayStart;
+              } catch {
+                return false;
+              }
+            });
+            const tail = rows.slice(-KEEP_LINES);
+            const tailSet = new Set(tail);
+            const todayCapped = todayLines.length > MAX_LINES ? todayLines.slice(-MAX_LINES) : todayLines;
+            const todaySet = new Set(todayCapped);
+            const merged = [...todayCapped, ...tail.filter((l) => !todaySet.has(l))];
+            // 顺序按原文件恢复（避免打乱 byDay 折线的时间序）
+            const order = new Map(rows.map((l, k) => [l, k]));
+            merged.sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
+            atomicWriteFileSync(cacheStatsFile(), merged.join('\n') + '\n');
+          }
         }
       });
+    } catch (err) {
+      const msg = String(/** @type {any} */ (err)?.message ?? err);
+      lastWriteError = msg;
+      if (!appended) {
+        // 只提示一次：写不进去通常是持续性问题（磁盘满/权限），每回合刷屏反而让人忽略它
+        if (!writeWarned) {
+          writeWarned = true;
+          console.warn(
+            `[MingDao] ⚠ 费用明细写入失败：${msg}\n` +
+              `  今日费用护栏会**少计**这部分消费（可能超支而不知）；请检查 ${cacheStatsFile()} 的磁盘空间与权限。`
+          );
+        }
+        return { ok: false, error: msg, phase: 'append' };
+      }
+      // 追加已成功、只有轮转失败：丢的不是账，而是文件会持续增长
+      if (!rotateWarned) {
+        rotateWarned = true;
+        console.warn(`[MingDao] ⚠ 费用明细轮转失败：${msg}\n  ${cacheStatsFile()} 会持续增长（不影响计费，但请检查磁盘空间/权限）。`);
+      }
+      return { ok: false, error: msg, phase: 'rotate' };
     }
   } catch (err) {
-    // 轮转失败与追加失败是两件事：这里丢的不是账，而是文件会持续增长
     const msg = String(/** @type {any} */ (err)?.message ?? err);
     lastWriteError = msg;
-    if (!rotateWarned) {
-      rotateWarned = true;
-      console.warn(`[MingDao] ⚠ 费用明细轮转失败：${msg}\n  ${cacheStatsFile()} 会持续增长（不影响计费，但请检查磁盘空间/权限）。`);
+    if (!writeWarned) {
+      writeWarned = true;
+      console.warn(`[MingDao] ⚠ 费用明细写入失败：${msg}\n  今日费用护栏会**少计**这部分消费（可能超支而不知）；请检查 ${cacheStatsFile()} 的磁盘空间与权限。`);
     }
-    return { ok: false, error: msg, phase: 'rotate' };
+    return { ok: false, error: msg, phase: 'append' };
   }
   return { ok: true, error: null, phase: null };
 }

package/src/cli.js

@@ -7,7 +7,7 @@ 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';
+import { loadConfig, saveConfig, runWizard, ensureHome, mingdaoHome, readConfigStrict, quarantineCorruptConfig } from './config.js';
 import { helpLines } from './help.js';
 import { modelPreset, PROVIDERS } from './models.js';
 import { maskKey, getStoredKey } from './credentials.js';
@@ -231,7 +231,7 @@ async function main() {
   if (opts.prompt[0] === 'schedule-daemon') {
     const home0 = ensureHome();
     const { listSchedules, runSleeper, sleeperAlive, procAlive, daemonPidFile, writeSchedule } = await import('./schedule.js');
-    const { readTask } = await import('./tasks.js');
+    const { readTask, taskWorkerAlive } = await import('./tasks.js');
     const handled = new Set();
     const supervising = new Set(); // 本 daemon 正在监督的任务（防崩溃恢复误判正在执行的任务）
     const nonce = String(opts.prompt[1] || '');
@@ -261,7 +261,16 @@ async function main() {
             // v0.4.7（P2 T15）：先看「跑这个任务的宿主进程」是否仍存活。存活说明它正在跑
             // （可能还没写 lastTaskId），**等它**——否则「本 daemon 刚接管 + 旧 daemon 在途」
             // 会被当成崩溃残留 → 重置 pending → 并发重跑同一任务。
-            if (procAlive(j.runnerPid)) continue;
+            //
+            // v0.6.3（P1-5）：但「宿主就是自己」时必须例外——markRunning 写的 runnerPid 就是
+            // 本 daemon 的 pid，于是 `procAlive(自己)` 恒真 → `continue` → 这条 job **永久跳过**：
+            // 面板一直转圈、既不重跑也不收尾，用户只能 daemon stop + 删 pidfile 自愈。
+            // 同理：宿主只是"标记"，真正在跑的是 detached worker，绝不能凭宿主死活就重排。
+            const runnerIsSelf = Number(j.runnerPid) === process.pid;
+            if (!runnerIsSelf && procAlive(j.runnerPid)) continue;
+            // worker 仍活着（宿主被 SIGKILL 但 detached worker 还在跑）→ **绝不重排**，
+            // 否则同一个任务会跑第二遍；等它收尾，下一轮恢复会走「t.status !== running」的定案分支。
+            if (t && t.status === 'running' && taskWorkerAlive(t)) continue;
             if (!t) {
               await writeSchedule(home0, { ...j, status: 'pending' });
               continue;
@@ -292,7 +301,14 @@ async function main() {
           handled.add(j.id);
           supervising.add(j.id);
           runSleeper(home0, j.id, { shouldStop: () => leaseLost })
-            .catch(() => {})
+            // v0.6.3（P1-5）：不能静默吞。协程一次异常（锁超时/写盘失败）此前**无痕**消失，
+            // 于是 job 停在 running、下一轮恢复又因 runnerPid 指向自己而跳过 → 永久卡住。
+            // 现在至少留一条可诊断的日志（用户能在 daemon 日志里看到"为什么没跑"）。
+            .catch((/** @type {any} */ e) => {
+              try {
+                console.error(`[MingDao] ⚠ 调度协程异常（任务 ${j.id}）：${e?.message || e}`);
+              } catch {}
+            })
             .finally(() => {
               handled.delete(j.id);
               supervising.delete(j.id);
@@ -341,6 +357,11 @@ async function main() {
     return;
   }
   const home = ensureHome();
+  // v0.6.3（H-7）：进向导**之前**先分清「没有配置」与「配置读不出来」。
+  // 后者若被当成首次运行，向导会用全新对象整文件覆盖掉用户配置（customModels/mcpServers/
+  // sync/net/costGuard 全丢）且不备份。这里先把损坏文件改名备份并告警，再继续走首次向导。
+  const cfgStrict = readConfigStrict();
+  if (cfgStrict.exists && !cfgStrict.ok) quarantineCorruptConfig(cfgStrict.error || '未知原因');
   let cfg = loadConfig();
   if (!cfg || opts.init) {
     const wio = createIO();

package/src/commands/diagnose.js

@@ -112,6 +112,9 @@ export async function handleDiagnose(/** @type {any} */ _cmd, /** @type {any} */
     io.print(style('请把该文件内容贴到反馈渠道排查；密钥/token/私网路径已脱敏。', C.dim));
   } catch (/** @type {any} */ err) {
     io.print(style('[错误] ' + (err?.message || err), C.red));
+    // v0.6.3（M-21）：诊断包生成失败必须体现在退出码上——脚本化收集诊断信息时
+    // 「打印了错误但退 0」会让调用方以为拿到了报告。
+    process.exitCode = 1;
   } finally {
     io.close();
   }

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');