mingdao-harness 0.6.6 → 0.6.7

package/docs/AUDIT-v0.6.1-/347/254/254/344/270/211/346/226/271/346/212/245/345/221/212/347/231/273/350/256/260.md

@@ -1191,3 +1191,62 @@ run-all 的 shell、run-all 的 try/catch、调度切片（源码级）、调度
   第 7 节路线图列的多为已完成项。报告的这条批评**成立**。
 - P2 各项（Pack 沙箱档、成本归因下钻、降级目标自动选择、JSDoc 治理）与报告 §六 横向对比结论，
   仅作输入，不逐条排期。
+
+### 3.40.1 发版现场另外发现的两处发布链路缺陷（v0.6.6 一并修）
+
+这两条不在第三方报告里，是本次发版实操踩出来的，都属于"**门禁自己被骗**"这一形态：
+
+| 位置 | 现象 | 根因 | 处置 |
+| --- | --- | --- | --- |
+| `MingDao-Harness-Site/scripts/harvest-release.mjs`、`scripts/update-downloads.mjs` | Release 附件明明已齐（`releases/<id>/assets` 列出 14 个），脚本却报「没有可采集的附件（是不是构建还没跑完？）」/「缺少安装包」 | `releases/tags/<tag>` 被 GitHub 的 **CDN 缓存**成"创建瞬间的空 assets"（Release 由工作流刚创建时） | 加 cache-buster；为空时按 release id 直连 assets 端点复核 |
+| `scripts/verify-release.mjs`（"防半发布"最后一道闸） | 打出 `✓ GitHub/Release 存在（附件 0 个）`——把一个无法下载、无法收割的 Release 判成通过 | 同上（读了被缓存的空 assets），且**附件数为 0 不影响判定** | 同上修复，并把「GitHub 附件为 0」改判**失败**（Gitee/GitCode 按政策不附附件，故只对 GitHub 判） |
+| `MingDao-Harness-Site/scripts/harvest-release.mjs` | 线上 `/downloads/latest.yml` 自 v0.6.1 起再没更新过（v0.6.4/0.6.5 依次"跳过"，无人察觉） | `latest*.yml` 是**不带版本号的指针文件**、体积都是几百字节，而幂等判据是"已存在且体积一致就跳过" | 指针类文件（`latest(-linux).yml`）一律覆盖——代价几百字节 |
+
+**教训**：这一批四个问题（含第三方的三处）全是"**验证逻辑自身的判据太宽**"——只判"抛不抛错"、
+只判"体积一致"、只判"Release 存在"。**判据要对着"我们真正在意的那件事"写**：
+在意的不是"文件在不在"，而是"它是这一个版本的、且能被下载"。
+
+## 3.41 已修复（v0.6.7 批十二~批十五：三份 v0.6.6 审计报告的收口）
+
+**来源**：三份第三方报告（全量代码审计 58 项 / 第六轮复审 / 安全与质量审计），共同把
+「**同一规则多份实现 → 最弱的那份说了算**」指为本项目安全缺陷的唯一共性根因。
+本批按它们的 v0.6.7 建议范围收口，逐条走「先复现 → 定级 → 修复 → 回归断言 → 变异验证」。
+
+| 批 | 条目 | 报告出处 | 落地 |
+| --- | --- | --- | --- |
+| 十二 | **fetch 工具 SSRF 单一口径**：DNS 复检 fail-open、check/connect 两次解析（DNS rebinding）、元数据只按主机名判 | 报告一 C-1/H-1、报告二 P2-2、报告三 P1（三个报告的头号发现） | 新增 `src/ssrf-guard.js`（判定+钉扎单源）；`runFetch` 整条走 `safeFetchText`；`tools/fetch.js` 只留工具契约并再导出同一函数对象。**行为级复现**：桩解析失败 → 旧路径放行、新路径 fail-closed；桩解析→127.0.0.1 + 不可解析主机名仍能连通（证明连接用的是**钉住的 IP**） |
+| 十二 | **出网闸门盲区**：`safe-fetch` 走 `node:http(s)`，完全绕过只钩 `globalThis.fetch` 的闸门 | 报告三 M1/M2 | net-guard 新增 `guardEgress()`（与 fetch 钩子共用同一入口），safe-fetch 每跳显式过闸+记账；**行为级**：block 档下 skill/registry/模型发现路径被拦且入账 |
+| 十二 | **`fetch(Request, init)` 丢失 Request 语义 → 静默降级成空 GET** | 报告二 P2-3 | 逐字段合并（method/headers/body/signal/duplex + 若干 init 字段），**行为级**：服务端收到 POST + body |
+| 十二 | **跨 origine 只剥三个头（黑名单）**：`x-api-key` 等自定义凭据头原样送给重定向目标 | 报告一 M-4 | 改**反向白名单**（`stripHeadersForCrossOrigin`）；**行为级**：第二跳 `x-api-key`/`authorization` 已剥、`accept`/`user-agent` 保留 |
+| 十三 | **账本结局口径分裂**（返回值 capHit 与 runEnd 不一致、`'max_steps'` 死条件、截断方向反向） | 报告二 P2-1 | runTurn 内新增 `outcome` 单一来源，所有出口 `markOutcome()`，runEnd 与返回值同源；**行为级**：跑满步数时 `run.end.status==='capped' && capHit===true` 且与返回值一致 |
+| 十三 | **费用护栏读失败当 0**（statSync 过、readFileSync 失败 → 静默 ¥0） | 报告一 H-3 | 新增 `listCacheStatsStrict()`（区分 ENOENT 与读失败），护栏走严格读；**行为级（子进程）**：文件存在但 chmod 000 → `todayCost()` 返 **null** 而非 0，且告警一次 |
+| 十三 | **usage 缺失记 ¥0 → 三档护栏失明且无信号** | 报告一 H-4、登记 §3.39①(a) | agent 置 `usageUnknown` 并在有响应无 usage 时告警一次；`recordUsage` 记 `cost:null + usageUnknown`；账本 cost 事件带 `usageUnknown`；护栏给出"今日 N 次用量未知"提示 |
+| 十三 | **Batch 失败/取消路径漏账**、**Batch 不查护栏** | 报告一 M-10、登记 §3.39①(c) | 四条失败路径记「用量未知」；提交前 `checkCostGuard`（block 档拒绝提交，**服务端零请求**——行为级断言） |
+| 十三 | **downgrade 不看在途费用**（降级成免检通道） | 登记 §3.39①(b) | 降级换模型后按在途费用复查，仍超限即停（行为级：`providerCalls === 0`） |
+| 十三 | `run.start.packs` 恒为空数组（取不存在的键） | 报告二 P3-1 | 改取 `mounted.map(p => p.name)`；行为级：挂载 Pack 后账本里能看到它 |
+| 十三 | capHit 口径：Web 标 `done`、worker 标 `failed` | 报告二小项 | 统一为「不算完成」：Web 侧 `'capped'`（前端给明确横幅），worker 维持 `'failed'` |
+| 十四 | **脱敏器不认带引号键**（`{"api_key": …}` / `{'api_key': …}` 明文进审计与诊断包） | 报告一 H-2、登记 §3.39② | 正则允许成对引号包裹键名/值；**测试刻意用无前缀密钥值**（`sk-` 被另一条规则掩掉，拿它测会假绿——变异验证当场指出） |
+| 十四 | **凭证写用宽松读**（损坏时一次 init/WebUI 设 Key 清空其余凭据） | 报告一 M-1（H-8 只修了 key 命令层） | `setStoredKey`/`removeStoredKey` 内置严格读、损坏即拒绝写；三个 WebUI 调用点 + init 向导把失败说出来 |
+| 十四 | **deny 拆段漏命令替换/子 shell/`\r`/续行**；`denyStrict` 被 `sh -c` 绕过 | 报告一 M-2、报告二 P3-6 | 分隔面补全（fail-closed 方向）+ denyStrict 下包装执行直接拒绝并给可操作指引 |
+| 十四 | **bash env 词表漏 `key` 段**（`OPENAI_KEY`/`GITHUB_KEY` 原样透传子进程） | 报告一 M-3 | 与脱敏器共用 `ENV_SECRET_SEGMENTS`（唯一例外 `pwd`，避免剥离 `PWD`） |
+| 十四 | **constraints ReDoS 判定弱于 grep**（`(a|aa)+`/`((a|ab)x)+` 装载即通过） | 报告一 M-5 | 新增 `src/regex-safety.js` 作为单一来源（嵌套量词 + 歧义分支，含嵌套组），grep/constraints/packs 三处共用；刻意不拦 `(a+)?`（`?` 只重复 0/1 次，不会爆炸） |
+| 十四 | `workspaces set` 存**未归一化**路径 → 改链指向即围栏塌陷 | 报告一 H-5、登记 P1-21 | 存 `t2`（realpathDeep 结果），与同文件 add 分支对齐 |
+| 十五 | `redactDeep` 对象键数无界、`/memory add` 裸 appendFileSync（0644/无日期戳）、worker 的 ask 漏对象形态、`pack new` 写进非发现路径、自定义 Provider 模块按 `Date.now()` 无限重载、`clampText` 裸 slice 切代理对、schedule 锁内做进程调用、share-accept 文件写在锁外且非原子、会话 id 同秒碰撞 | 报告一 L-1/L-10/M-6/M-7/M-13、报告二 P3-3/P3-4/P3-5/P3-7 | 逐项落地；**测试基建**：新增 `test/mutate/`（变异验证脚本入库，报告一 S-3② 的欠账——此前"7/7"是手工过程、谁也复现不了） |
+
+**变异验证（本批累计 38 条）**：`node test/mutate/run.mjs`
+（批十二 8/8、批十三 10/10、批十四·十五 10/10，另有 v0.6.5/v0.6.6 的 4+7 条历史条目）。
+过程中被抓出 **3 处假绿**（断言第一版抓不到变异）：
+① 用 `sk-…` 测"带引号的键"——它被前缀规则掩掉了，测不到 H-2；
+② M-13 两次调用落在同一毫秒 → 变异体与修复版表现一致；
+③ 变异验证脚本自身的关键词对不上（失败的断言不是要钉的那条）。
+三条都按"收紧后重验才算数"处理。
+
+**未纳入本批（如实登记，按报告 §五/§八 排期）**：
+- 报告一 **M-8**（sync-server 设备级吊销 / push 配额与限流）、**M-9**（memory 子系统 4 处锁外读-改-写）、
+  **M-11**（逐轮回调计价锚点——本批已随 H-4 一并把 `perf.requestStartAt` 透到 recordUsage，逐轮路径同源）、
+  **L-2/L-4/L-5/L-12/L-15/L-16/L-17** 等低危项；
+- 报告一 **P1-1**（agent.js 拆分，runTurn ~1057 行）、**P1-2**（结构化摘要 + 关键事实钉死）、
+  **P1-3**（预算状态注入上下文）、**P1-4**（出网闸门对 bash curl 的补强）、**P1-5**（ARCHITECTURE.md 重建）、
+  报告二 P3-2 的消费方、报告三 §4 阶段二/三（对抗测试集扩面、容器 CI job、关键模块 TS 迁移、发布状态机）；
+- 报告一 **H-6/L-18**（自更新多镜像取最大版本、install.sh 无校验和）——供应链完整性锚需要发布流程配合，
+  与 `ledger --sign-key`、在线缓存基准（P0-2）同列为 v1.0 前项。

package/docs/RELEASE-CHECKLIST.md

@@ -61,7 +61,7 @@ export MINGDAO_HOME=$(mktemp -d)     # 绝不动真实 ~/.mingdao
 
 npm run typecheck                    # 期望 0 错误
 npm run typecheck:strict             # 期望 当前 0 / 基线 0
-node test/smoke.js                   # 期望 全部通过（当前 153 组断言）
+node test/smoke.js                   # 期望 全部通过（当前 156 组断言）
 node test/e2e-local.js               # 期望 全通过
 node test/e2e-web.js                 # 期望 全通过
 node test/e2e-schedule.js            # 期望 全通过

package/package.json

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

package/src/agent.js

@@ -5,7 +5,7 @@
 import { trimMessages, clampText, messageTokens, approxTokens } from './context.js';
 import { compactConversation } from './compact.js';
 import { buildToolSchemas, dispatch } from './tools/index.js';
-import { modelPreset } from './models.js';
+import { DEFAULT_MODEL, modelPreset } from './models.js';
 import { resolveModelCaps, safeBudget, EDGE_RATIO } from './model-caps.js';
 import { makeTokenCounter } from './tokenizer.js';
 import { createHooks } from './hooks.js';
@@ -383,6 +383,22 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
     /** v0.6.3（M-16）：本回合是否出现过"上游提前关流"（回答可能不完整）。
      * 刻意不叫 truncated——既有 `truncated` 的含义是"步数兜底总结也失败了"，两者必须分开。 */
     let upstreamTruncated = false;
+    // v0.6.7（报告二 P2-1）：**结局判定的单一来源**。
+    // 此前账本 runEnd 在 finally 里拿不到返回值，只能用局部变量 `finish` 重算结局，于是四处口径分裂：
+    //   ① 跑满步数：返回值 capHit:true，账本却记 status='done'、capHit=false；
+    //   ② `finish === 'max_steps'` 是**死条件**（全文件无人赋该值，析取支永不成立）；
+    //   ③ 步数耗尽的另一条分支（末轮仍有正文+工具调用）返回时**根本没有 capHit 字段**，
+    //      与同一 if 的 `break` 分支（capHit:true）自相矛盾；
+    //   ④ `finish === 'length'` 时账本记 capHit:true，而循环跑满的返回值是 truncated:true —— 同一次运行两个说法。
+    // 现在：所有出口都调用 markOutcome 写进同一个 outcome，返回值与 runEnd 都从它取。
+    /** @type {{status: string, capHit: boolean, truncated: boolean, aborted: boolean, upstreamTruncated: boolean, usageUnknown: boolean}} */
+    const outcome = { status: 'done', capHit: false, truncated: false, aborted: false, upstreamTruncated: false, usageUnknown: false };
+    /** 收敛本回合结局（后写覆盖，便于"先默认、后升级"）。
+     * @param {string} status @param {Partial<{capHit: boolean, truncated: boolean, aborted: boolean}>} [extra] */
+    const markOutcome = (status, extra = {}) => {
+      outcome.status = status;
+      Object.assign(outcome, extra);
+    };
     // v0.3.1 自动续跑（长程执行）：跑满 stepLimit 步后不再直接中断，而是注入进度摘要再续跑，
     // 最多 maxRounds 轮（默认 3，可用 cfg.maxRounds 调）；审计/重构等大任务不再「一步中断」。
     const maxRounds = Math.max(1, Number(cfg.maxRounds) || 3);
@@ -406,7 +422,9 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       cwd: workingDir,
       permission: cfg.permission ?? permission?.mode ?? null,
       preset: preset?.name ?? cfg.preset ?? null,
-      packs: getActivePackContext()?.packs ?? [],
+      // v0.6.7（报告二 P3-1）：activeCtx 的形状是 { mounted, warnings, promptSections, constraints, toolCount }，
+      // **没有 `.packs` 键** —— 这里此前恒为 []，账本里"本次运行挂了哪些 Pack"永远记空。
+      packs: (getActivePackContext()?.mounted || []).map((/** @type {any} */ p) => p?.name).filter(Boolean),
     });
     // 回合性能指标（状态栏：LLM 时长 / 工具时长 / 首 token 延迟 / 步数）
     let llmMsTotal = 0;
@@ -430,6 +448,8 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       usedModel: activeModel, // 省钱 B4：本回合实际使用模型（降级后归属它）
       requestStartAt: lastRequestStartAt, // v0.4.6：峰谷计价锚点（请求发起时刻，非落账时刻）
       deliverables: [...deliverables], // v0.3.1：CLI/REPL 续跑检查点复用（此前 artifacts 恒空）
+      // v0.6.7（报告一 H-4）：本回合是否出现过"模型有响应但服务端没回 usage"
+      usageUnknown: outcome.usageUnknown,
     });
     let aborted = false;
     let emptyRounds = 0; // 连续空/截断输出计数（防止无限续写）
@@ -675,7 +695,26 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       // 费用护栏（A2/B4）：每轮开始前按今日实际费用检查；block 暂停本轮；
       // downgrade 自动切换便宜模型继续执行（每回合只切一次，切换即粘滞）
       if (cfg.costGuard) {
-        const guard = checkCostGuard(activeModel);
+        let guard = checkCostGuard(activeModel);
+        // v0.6.7（登记 §3.39①(b)，报告一 §2.5 复核「仍成立」）：**在途费用必须参与降级决策**。
+        // 此前 downgrade 档只看**落账**（checkCostGuard → todayCost），而单看落账要在回合结束后才更新——
+        // 于是长回合里贵模型会一直用到跑完，实测单回合可超日限 9.1×（note=null，用户毫无察觉）。
+        // 现在：若「今日已用 + 本回合在途」已越线，且当前还不在最便宜档，就**当场触发降级**
+        // （不否决降级本身——那等于把这个功能废掉；只是把它触发得更早）。
+        if (!guard && !downgraded) {
+          const g0 = costGuardConfig();
+          if (g0 && String(g0.action) === 'downgrade' && Number(g0.dailyLimitYuan) > 0) {
+            const usedNow = usedTodayWithInflight();
+            if (usedNow != null && usedNow >= Number(g0.dailyLimitYuan)) {
+              guard = {
+                blocked: false,
+                downgrade: true,
+                downgradeModel: String(g0.downgradeModel || DEFAULT_MODEL),
+                message: `⚠ 费用护栏：今日已用（含本回合在途）≈¥${usedNow.toFixed(4)} 已达上限 ¥${Number(g0.dailyLimitYuan).toFixed(2)}——已自动降级到便宜模型继续执行。`,
+              };
+            }
+          }
+        }
         if (guard) {
           if (guard.blocked) {
             stripOrphanCalls();
@@ -765,13 +804,15 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
         io.endTurn();
         if (aborted) {
           stripOrphanCalls();
-          return { text: null, reasoning: '', usage, steps, finish, truncated: false, aborted: true, durationMs: Date.now() - startedAt, perf: perf() };
+          markOutcome('aborted', { aborted: true });
+          return { text: null, reasoning: '', usage, steps, finish, truncated: false, aborted: outcome.aborted, upstreamTruncated, durationMs: Date.now() - startedAt, perf: perf() };
         }
         // MacBook 本地 507 memory_refusal 根因（v0.4.5）：服务端内存拒绝不是「空输出」——
         // 直接终结合合并透出降级提示，不计入空轮、不注入续写重试（内存未释放必再 507，空烧请求）。
         const e = /** @type {any} */ (err);
         if (e?.status === 507 || /memory_refusal|内存不足|内存拒绝/i.test(String(e?.message || ''))) {
           stripOrphanCalls();
+          markOutcome('done');
           return {
             text: null,
             reasoning: '',
@@ -780,6 +821,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
             finish,
             truncated: false,
             aborted: false,
+            upstreamTruncated,
             note: '本地模型内存不足（507 memory_refusal）——请压缩上下文（减小 config.contextBudget 或 /compact）、减少并发子任务，或重启模型服务释放内存后再继续。',
             durationMs: Date.now() - startedAt,
             perf: perf(),
@@ -812,6 +854,23 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       });
       // 省钱 B1：只读阶段中模型文字明确表达写意图 → 下一轮注入全量工具（多一轮，几乎无感）
       if (readOnlyPhase && hasWriteIntent(res.text)) readOnlyPhase = false;
+      if (!res.usage && (res.text || res.toolCalls?.length)) {
+        // v0.6.7（报告一 H-4）：网关/自定义端点不返回 usage 时，此前这回合在账上**不存在**——
+        // warn/block/downgrade 三档护栏全部失明且没有任何信号。这里置位 + 明确告知，
+        // 落账时按"用量未知"处理（cost:null / priced:false），绝不冒充"这次花了 ¥0"。
+        if (!outcome.usageUnknown) {
+          outcome.usageUnknown = true;
+          try {
+            io.print(
+              style(
+                '⚠ 服务端未返回本次调用的用量（usage 缺失）：这一回合无法计费，今日费用护栏会少计这部分消费。\n' +
+                  '  常见于自建网关/中转端点；如需精确护栏，请让网关透传 usage 字段。',
+                C.yellow
+              )
+            );
+          } catch {}
+        }
+      }
       if (res.usage) {
         usage.prompt_tokens += res.usage.prompt_tokens || 0;
         usage.completion_tokens += res.usage.completion_tokens || 0;
@@ -842,7 +901,9 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           if (res.text) {
             const ap = await applyOutputConstraints(res.text, { messages, provider, activeModel, temperature, maxOutput, usage, signal: currentAc?.signal });
             messages.push({ role: 'assistant', content: ap.text });
-            return { text: ap.text, reasoning: res.reasoning || '', usage, steps, finish, truncated: false, aborted: false, upstreamTruncated, note: ap.note || undefined, durationMs: Date.now() - startedAt, perf: perf() };
+            // 步数已耗尽：这一条与下方 `break`（→ 兜底总结/截断收尾）必须是同一口径
+            markOutcome('capped', { capHit: true });
+            return { text: ap.text, reasoning: res.reasoning || '', usage, steps, finish, truncated: false, aborted: false, capHit: outcome.capHit, upstreamTruncated, note: ap.note || undefined, durationMs: Date.now() - startedAt, perf: perf() };
           }
           break;
         }
@@ -1203,6 +1264,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           // 静默空输出（无工具无正文）：同样回填续写提示，避免界面"没动静"（审计 Q1：与截断续写统一护栏）
           emptyRounds += 1;
           if (emptyRounds >= maxEmptyRounds) {
+            markOutcome('done');
             return {
               text: null,
               reasoning: res.reasoning || '',
@@ -1211,6 +1273,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
               finish,
               truncated: false,
               aborted: false,
+              upstreamTruncated,
               note: '模型本轮没有输出正文。',
               durationMs: Date.now() - startedAt,
               perf: perf(),
@@ -1239,14 +1302,16 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           });
           continue;
         }
+        markOutcome(finish === 'length' ? 'capped' : 'done', { capHit: false, truncated: finish === 'length' });
         return {
           text: finalText,
           reasoning: res.reasoning || '',
           usage,
           steps,
           finish,
-          truncated: false,
+          truncated: outcome.truncated,
           aborted: false,
+          upstreamTruncated,
           note: outputNote || undefined,
           durationMs: Date.now() - startedAt,
           perf: perf(),
@@ -1352,16 +1417,19 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           : { text: null, note: null };
         if (wrapApplied.text) messages.push({ role: 'assistant', content: wrapApplied.text });
         // capHit：本轮因步数上限被迫收尾（任务可能未真正完成）→ 供上层落检查点续跑
-        return { text: wrapApplied.text || null, reasoning: wrapRes.reasoning || '', usage, steps, finish, truncated: false, aborted: false, capHit: true, note: wrapApplied.note || undefined, durationMs: Date.now() - startedAt, perf: perf() };
+        markOutcome('capped', { capHit: true });
+        return { text: wrapApplied.text || null, reasoning: wrapRes.reasoning || '', usage, steps, finish, truncated: false, aborted: false, capHit: outcome.capHit, upstreamTruncated, note: wrapApplied.note || undefined, durationMs: Date.now() - startedAt, perf: perf() };
       } catch (/** @type {any} */ err) {
         // v0.4.1：不再静默吞异常——总结失败原因透出，便于定位（此前用户只见「输出截断/无反馈」）
         try { io.print(style(`⚠ 兜底总结失败：${String(err?.message || err)}`, C.yellow)); } catch {}
       }
     }
-    return { text: null, reasoning: '', usage, steps, finish, truncated: true, aborted: false, capHit: true, durationMs: Date.now() - startedAt, perf: perf() };
+    markOutcome('capped', { capHit: true, truncated: true });
+    return { text: null, reasoning: '', usage, steps, finish, truncated: outcome.truncated, aborted: false, capHit: outcome.capHit, upstreamTruncated, durationMs: Date.now() - startedAt, perf: perf() };
     }
     // 理论不可达（for 循环末轮必 return）；给 tsc 一个兜底，保证 runTurn 恒有返回值
-    return { text: null, reasoning: '', usage, steps, finish, truncated: true, aborted: false, capHit: true, durationMs: Date.now() - startedAt, perf: perf() };
+    markOutcome('capped', { capHit: true, truncated: true });
+    return { text: null, reasoning: '', usage, steps, finish, truncated: outcome.truncated, aborted: false, capHit: outcome.capHit, upstreamTruncated, durationMs: Date.now() - startedAt, perf: perf() };
     } catch (/** @type {any} */ err) {
       // 审计 P2-6（v0.4.2）：工具管线异常（hooks.pre / permission.check / prepTool 等）沿大 try 上抛时，
       // assistant tool_calls 已 push 进 messages 却无对应 tool 回填——会话恢复后 API 因孤儿 tool_call_id 400。
@@ -1383,7 +1451,10 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           // 两者单价不同（flash 便宜数倍），于是账本与日费用护栏系统性偏移，
           // 而"降级省钱"恰恰是靠这里体现的。
           const yuan = estimateCost(activeModel, usage.prompt_tokens, usage.completion_tokens, cacheSplit(usage), costDate);
-          const priced = typeof yuan === 'number' && Number.isFinite(yuan);
+          // v0.6.7（H-4）：用量未知时哪怕 0/0 也算出一个真 0（estimateCost(0,0)===0），
+          // 那会把"没记账"伪装成"没花钱"。未知一律 priced:false + yuan:null。
+          const usageKnown = !outcome.usageUnknown && (usage.prompt_tokens > 0 || usage.completion_tokens > 0 || steps === 0);
+          const priced = usageKnown && typeof yuan === 'number' && Number.isFinite(yuan);
           turnLedger.cost({
             // BUG-024：归属同样要用实际计费的模型（run.start 里已记过"用户请求的模型"，
             // 这里再写 modelName 会让"花了钱的那次调用"归属到一个没被调用的模型）
@@ -1391,6 +1462,8 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
             usage,
             yuan: priced ? yuan : null,
             priced,
+            // v0.6.7（H-4）：把"用量未知"作为显式事实落账，事后可区分「没花钱」与「没记账」
+            ...(usageKnown ? {} : { usageUnknown: true }),
             pricing: { requestStartAt: lastRequestStartAt, peak: isPeakHour(costDate) },
           });
           turnLedger.runEnd({
@@ -1398,15 +1471,17 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
             // status 是「这次运行怎么结束的」，与模型层的 finish_reason（stop/tool_calls/length）
             // 不是一回事：前者给人看账本，后者记在 model.round 里。混用会让「status=stop」这种
             // 记录无法回答「这次到底完成了没有」。
-            status: aborted ? 'aborted' : finish === 'length' || finish === 'max_steps' ? 'capped' : 'done',
+            // v0.6.7（P2-1）：一律取自 outcome —— 与返回值**同一个来源**，不可能再分裂
+            status: outcome.status,
             steps,
             rounds: round + 1,
             yuanTotal: priced ? yuan : null,
             priced,
-            // capHit/truncated 的判定与下方返回值保持同一口径：跑到步数上限被迫收尾
-            capHit: Boolean(finish === 'length' || finish === 'max_steps'),
-            truncated: Boolean(finish === 'length'),
-            aborted,
+            capHit: outcome.capHit,
+            truncated: outcome.truncated,
+            aborted: outcome.aborted,
+            // v0.6.7（P3-2）：上游提前关流此前只置位、不落账（"检测到了、传递断了"）
+            upstreamTruncated: Boolean(upstreamTruncated || outcome.upstreamTruncated),
           });
           // v0.6.2（B-WS-1/2）：记账降级必须让用户看见。
           // 此前写账本失败只把 alive 置 false，用户拿到一段「正常」总结却不知道这次运行

package/src/batch.js

@@ -11,6 +11,7 @@ import path from 'node:path';
 import crypto from 'node:crypto';
 import { resolveProviderConfig } from './providers/index.js';
 import { estimateBatchCost, BATCH_DISCOUNT } from './pricing.js';
+import { checkCostGuard } from './cost-guard.js';
 import { recordCacheStats } from './cachestats.js';
 import { approxTokens } from './context.js';
 
@@ -223,6 +224,18 @@ export async function runBatch({ cfg, model, questions, workingDir = process.cwd
     }
   }
 
+  // —— v0.6.7（登记 §3.39①(c)）：Batch 也要过费用护栏 ——
+  // 此前 Batch 通道**完全不查 costGuard**（只认用户显式给的 --max-cost）：一次提交几百条问题，
+  // 恰恰是"烧穿日限"最省事的路径，而护栏在交互通道上却是硬的。这里与交互通道同一口径：
+  // block 档直接拒绝提交，warn/downgrade 档把护栏的话转达给调用方（不静默）。
+  {
+    const guard = checkCostGuard(model);
+    if (guard) {
+      if (guard.blocked) return { error: `费用护栏拦截，未提交批处理：${guard.message}` };
+      onStatus?.(guard.message);
+    }
+  }
+
   // —— 省钱 B2：--max-cost 预算上限（提交前估算拦截）——
   let estimatedCost = /** @type {number|null} */ (0);
   if (maxCost > 0) {
@@ -264,6 +277,34 @@ export async function runBatch({ cfg, model, questions, workingDir = process.cwd
       )
       .join('\n') + '\n';
 
+  /**
+   * 失败/取消路径的**最少诚实记账**（v0.6.7 / 报告一 M-10）。
+   * 批次一旦提交，服务端就可能已经处理并计费，而此前这四条路径（本地取消 / 超 24h / failed /
+   * expired·cancelled）本地**一条记录都不写**——账单在涨、账上却没有这笔。
+   * 拿不到 token 数就如实记「用量未知」（cost:null + usageUnknown + 服务端已处理条数），
+   * 让今日护栏能说出"有 N 次未知消费"，而不是把未知记成 0。
+   * @param {any} j 最近一次批次状态（可能为 null）
+   * @param {string} reason
+   */
+  const recordUnaccountedBatch = (j, reason) => {
+    try {
+      const rc = j?.request_counts || {};
+      const done = rc.completed != null ? `${rc.completed}/${rc.total ?? '?'}` : '未知';
+      recordCacheStats({
+        model,
+        prompt: 0,
+        completion: 0,
+        hit: null,
+        miss: null,
+        cost: null, // 未知：绝不写 0（0 会被读成"没花钱"）
+        saved: null,
+        batch: true,
+        usageUnknown: true,
+        note: `batch ${reason}（服务端已处理 ${done} 条，用量未知）`,
+      });
+    } catch {}
+  };
+
   try {
     onStatus?.('上传输入文件…');
     const fileId = await uploadFile(base, apiKey, jsonl, signal);
@@ -286,6 +327,7 @@ export async function runBatch({ cfg, model, questions, workingDir = process.cwd
       if (signal?.aborted) {
         // 本地取消必须尽力转化为服务端取消，否则用户以为停了、账单照涨
         const cancelled = await cancelServerBatch(base, apiKey, batch.id);
+        recordUnaccountedBatch(null, '本地取消');
         return {
           error: cancelled
             ? '已取消（已请求服务端停止该批次）'
@@ -297,6 +339,7 @@ export async function runBatch({ cfg, model, questions, workingDir = process.cwd
       if (Date.now() - t0 > 24 * 3600 * 1000) {
         // 超窗口同样要尝试停掉，避免留下一个无人接管却在计费的批次
         const cancelled = await cancelServerBatch(base, apiKey, batch.id);
+        recordUnaccountedBatch(null, '超 24h 窗口');
         return {
           error: `批处理超过 24h 窗口${cancelled ? '（已请求服务端停止）' : '（服务端取消失败，批次可能仍在计费）'}`,
           batchId: batch.id,
@@ -309,7 +352,10 @@ export async function runBatch({ cfg, model, questions, workingDir = process.cwd
         failures = 0;
       } catch (err) {
         failures += 1;
-        if (failures >= 10) return { error: `轮询失败：${(/** @type {any} */ (err))?.message || err}（任务仍在服务端，ID ${batch.id}）`, batchId: batch.id };
+        if (failures >= 10) {
+          recordUnaccountedBatch(null, '轮询连续失败');
+          return { error: `轮询失败：${(/** @type {any} */ (err))?.message || err}（任务仍在服务端，ID ${batch.id}）`, batchId: batch.id };
+        }
         await new Promise((r) => setTimeout(r, Math.min(baseInterval * 1.5 ** failures, 30000)));
         continue;
       }
@@ -320,6 +366,7 @@ export async function runBatch({ cfg, model, questions, workingDir = process.cwd
       }
       if (['failed', 'expired', 'cancelled', 'canceled'].includes(st)) {
         const detail = j?.errors?.data?.[0]?.message || j?.errors?.message || '';
+        recordUnaccountedBatch(j, `服务端状态 ${st}`);
         return { error: `批处理失败：${st}${detail ? '（' + detail + '）' : ''}`, batchId: batch.id };
       }
       polls += 1;
@@ -351,12 +398,18 @@ export async function runBatch({ cfg, model, questions, workingDir = process.cwd
       if (!outputs[i]) outputs[i] = { id: String(i), content: '' };
     }
     const usage = { prompt_tokens: prompt, completion_tokens: completion };
-    const cost = estimateBatchCost(model, prompt, completion);
+    // v0.6.7（H-4 的 batch 变体）：结果里没有 usage（网关不回 / 全部条目失败）时，
+    // prompt+completion 恒为 0 —— 那不是"免费"，而是"没有用量数据"，必须区分。
+    const usageUnknown = prompt === 0 && completion === 0;
+    const cost = usageUnknown ? null : estimateBatchCost(model, prompt, completion);
     const outFile = path.join(workingDir, `mingdao-batch-result-${Date.now()}.jsonl`);
     fs.writeFileSync(outFile, outputs.map((o) => JSON.stringify(o)).join('\n') + '\n');
-    recordCacheStats({ model, prompt, completion, hit: null, miss: null, cost, saved: null, batch: true });
+    recordCacheStats({
+      model, prompt, completion, hit: null, miss: null, cost, saved: null, batch: true,
+      ...(usageUnknown ? { usageUnknown: true, note: 'batch 结果未返回 usage（用量未知）' } : {}),
+    });
     onStatus?.(`完成：${outputs.length} 条结果${deduped ? `（去重合并 ${deduped} 条）` : ''}`);
-    return { ok: true, batchId: batch.id, outputFile: outFile, results: outputs, usage, cost, discount: BATCH_DISCOUNT, deduped, estimatedCost };
+    return { ok: true, batchId: batch.id, outputFile: outFile, results: outputs, usage, cost, usageUnknown, discount: BATCH_DISCOUNT, deduped, estimatedCost };
   } catch (err) {
     // 批处理端点不支持（404/405 等）→ 明确告知，不静默
     return { error: `批处理不可用：${(/** @type {any} */ (err))?.message || err}（该服务商可能不支持 Batch API，可用 config.batchBaseUrl 指定支持的网关）` };

package/src/cachestats.js

@@ -68,6 +68,11 @@ export function recordCacheStats(/** @type {any} */ entry) {
       // 这些调用不在 agent 回合 usage 里，单独入账，不与回合级重复计费。
       aux: entry.aux === true ? true : undefined,
       auxReason: entry.auxReason ? String(entry.auxReason) : undefined,
+      // v0.6.7（报告一 H-4 / M-10）：这笔消费**用量未知**（服务端没回 usage、或批次在拿不到
+      // token 数的情况下失败/被取消）。金额按 null 记，但 todayCost 会把条数汇总成可见信号，
+      // 免得"没记账"被读成"没花钱"。
+      usageUnknown: entry.usageUnknown === true ? true : undefined,
+      note: entry.note ? String(entry.note).slice(0, 200) : undefined,
     });
     // v0.6.3（BUG-009）：**追加与轮转共用同一把锁**。
     // 原实现是「锁外追加 + 锁内轮转」，仍留有丢失窗口：A 追加 → B 追加 → A 进锁读整文件、
@@ -146,6 +151,22 @@ export function recordCacheStats(/** @type {any} */ entry) {
 let /** @type {any} */ _statsCache = null;
 
 export function listCacheStats(limit = 2000) {
+  const r = listCacheStatsStrict(limit);
+  return r.ok ? r.entries : [];
+}
+
+/**
+ * 严格读取（v0.6.7 / 报告一 H-3）：区分「文件不存在」与「真的读不出来」。
+ *
+ * 为什么必须区分：`todayCost()` 护栏此前经过**宽松版**读取——`listCacheStats` 内部 `catch → []`，
+ * 于是"statSync 能过、readFileSync 失败"（Windows 杀软锁文件、权限竞态、盘符瞬断）会被当成
+ * **空列表 = 今日消费 ¥0**，护栏据此判定"没超支"并继续放行，且**没有任何告警**——
+ * 与该文件自己写下的「绝不静默当 0」（cost-guard.js）的纪律直接冲突。
+ * 护栏要的是「能不能读到」，不是「读到几条」。
+ * @param {number} [limit]
+ * @returns {{ok: true, entries: any[]} | {ok: false, error: string, code: string}}
+ */
+export function listCacheStatsStrict(limit = 2000) {
   try {
     const file = cacheStatsFile();
     const st = fs.statSync(file);
@@ -160,9 +181,10 @@ export function listCacheStats(limit = 2000) {
       }
       _statsCache = { mtimeMs: st.mtimeMs, size: st.size, limit, lines: out };
     }
-    return _statsCache.lines.slice(-limit);
-  } catch {
-    return [];
+    return { ok: true, entries: _statsCache.lines.slice(-limit) };
+  } catch (/** @type {any} */ err) {
+    // 读失败时**不能**复用旧缓存：这份数据是护栏的判据，宁可说"读不到"也不能给一份过期账
+    return { ok: false, error: String(err?.message ?? err), code: String(err?.code || '') };
   }
 }
 
@@ -198,9 +220,17 @@ export function recordUsage(/** @type {any} */ modelName, /** @type {any} */ usa
   const priceAt = Number(perf?.requestStartAt) > 0 ? new Date(Number(perf.requestStartAt)) : undefined;
   const prompt = usage?.prompt_tokens || 0;
   const completion = usage?.completion_tokens || 0;
+  // v0.6.7（报告一 H-4 / 报告二 S-2「未知 ≠ 0」）：服务端没回 usage 的调用**绝不能**以 ¥0 入账——
+  // 那会让"少计"看起来像"没花钱"，护栏（warn/block/downgrade）随之失明且无信号。
+  // 这里记 cost:null + usageUnknown:true，todayCost 会把它计成"今日有 N 次用量未知"，
+  // 由护栏给出可见告警（金额无法估算，但事实被记下来了）。
+  const usageUnknown = perf?.usageUnknown === true;
   let cost = null;
   let saved = null;
-  if (split) {
+  if (usageUnknown) {
+    cost = null;
+    saved = null;
+  } else if (split) {
     const base = estimateCost(modelName, prompt, completion, null, priceAt);
     cost = estimateCost(modelName, prompt, completion, split, priceAt);
     if (base != null && cost != null) saved = base - cost;
@@ -217,6 +247,8 @@ export function recordUsage(/** @type {any} */ modelName, /** @type {any} */ usa
     miss: split?.miss ?? null,
     cost,
     saved,
+    // v0.6.7（H-4）：显式标记"这次用量未知"，供 todayCost 汇总出可见信号
+    ...(usageUnknown ? { usageUnknown: true } : {}),
     steps: perf?.steps ?? undefined,
     llmMs: perf?.llmMs ?? undefined,
     toolMs: perf?.toolMs ?? undefined,

package/src/commands/pack.js

@@ -172,7 +172,11 @@ export async function handlePack(cmd, args) {
       process.exitCode = 1;
       return true;
     }
-    const dir = path.resolve(process.cwd(), 'packs', name);
+    // v0.6.7（报告二 P3-5）：此前写进 `cwd/packs/<name>` —— 该目录**不在任何发现路径**里
+    // （发现层级：内置 <repo>/packs → ~/.mingdao/packs → 项目 .mingdao/packs（信任门）→ config.packs），
+    // 于是照做的新用户"Pack 不生效且没有任何报错"。默认写到项目级 `.mingdao/packs/`，
+    // 并在下一步提示里给出 trust 命令（项目级必须显式信任才挂载）。
+    const dir = path.resolve(process.cwd(), '.mingdao', 'packs', name);
     if (fs.existsSync(dir)) {
       console.log(`[错误] 目录已存在：${dir}`);
       process.exitCode = 1;
@@ -228,6 +232,7 @@ export function createPack(ctx) {
     console.log(`✓ 已生成脚手架：${dir}`);
     console.log('下一步：');
     console.log(`  1. 编辑 ${path.join(dir, 'pack.json')}（描述/权限）与 pack.mjs（工具/约束）`);
+    console.log(`  2. mingdao pack trust ${path.dirname(path.dirname(dir))}   # 项目级 Pack 必须显式信任才会挂载`);
     console.log(`  2. mingdao pack verify ${dir}`);
     return true;
   }

package/src/commands/repl.js

@@ -425,7 +425,10 @@ export async function runRepl(ctx) {
             io.print('用法：/memory add <内容>');
             continue;
           }
-          fs.appendFileSync(memPath, `- ${text}\n`);
+          // v0.6.7（报告二 P3-3）：此前是**裸 appendFileSync** —— ①没有日期戳（与 appendMemory 的
+          // `- [date] …` 格式不一致，后续 dedupe/检索的日期解析会漏掉这类条目）；
+          // ②文件不存在时按默认 0644 新建，绕过记忆文件 0600 的私有权纪律。改走同一条写路径。
+          appendMemory([String(text)]); // 与 memoryFile() 同一路径（<home>/AGENTS.md，即上面的 memPath）
           io.print(style(`✓ 已追加到用户记忆 ${memPath}（后续会话自动生效）`, C.green));
         } else if (arg === 'extract') {
           io.startSpinner('正在从当前对话提炼记忆…');

package/src/config.js

@@ -181,7 +181,15 @@ export async function runWizard(io) {
     const envDetected = hasEnvKey() ? '（检测到环境变量，回车直接使用）' : '';
     const input = await io.ask(`② ${provider} 的 API Key${envDetected}：`, { hidden: true });
     apiKey = String(input || '').trim();
-    if (apiKey) setStoredKey(provider, apiKey);
+    if (apiKey) {
+      // v0.6.7（M-1）：写函数已 fail-closed，这里必须把失败**说出来**（否则向导会继续往下走、
+      // 用户以为 Key 已保存，而实际什么都没写）。
+      const sk = setStoredKey(provider, apiKey);
+      if (sk && sk.ok === false) {
+        io.print(`[错误] ${sk.error}`); // 不用彩色工具：config.js 不依赖 ui.js 的样式模块（避免循环依赖）
+        continue;
+      }
+    }
     if (!apiKey && !hasEnvKey()) {
       const skipped = await io.confirm('  未输入 API Key，跳过密钥设置？');
       if (!skipped) continue;

package/src/constraints.js

@@ -19,6 +19,8 @@
 /** @typedef {{ id: string, kind: string, pack?: string, tool?: string, pattern?: string, action?: string, fields?: string[], requireArg?: string, arg?: string, onMissing?: string }} Constraint */
 
 /** 合法的输出处置动作 */
+import { hasNestedQuantifier, hasAmbiguousAlternation } from './regex-safety.js'; // v0.6.7（M-5）：ReDoS 判定的单一来源
+
 export const OUTPUT_ACTIONS = new Set(['block', 'block-and-rewrite', 'warn']);
 
 /** 约束支持的 kind（与 packs.js / PACK-API §4 对齐） */
@@ -97,10 +99,11 @@ export function toolMatches(c, toolName) {
  * 比作者本意严得多，且理由里会印出 `/undefined/`，看起来像引擎坏了。
  * @param {any} pattern
  */
-// 经典灾难性回溯形状：**被量词修饰的组，其内部也以量词结尾**——
-// `(a+)+`、`(a*)*`、`(\d+)*`、`(x+){2,}`。这类模式在最坏输入上指数级回溯。
-// 刻意保守：只拦嵌套量词，不动 `(a|b)+`、`(ab)+`、`(a+)?` 这些常见且安全的写法。
-const REDOS_NESTED_QUANT = /\([^()]*[+*]\)(?:[+*]|\{\d*,?\d*\})/;
+// v0.6.7（报告一 M-5 / M-14②）：ReDoS 判定改为**共用 src/regex-safety.js**。
+// 此前这里只看嵌套量词（`(a+)+`），而 grep 侧另有一份"歧义分支"判定——两份都不完整，
+// 于是 `(a|aa)+`、`(a|a?)+`、`((a|ab)x)+` 在**约束引擎**这条路径上装载即通过
+// （约束匹配的是模型输出，报告实测 28 字符即耗时数十秒 → 同步卡死整个进程）。
+// 单一来源同时覆盖 约束装载 / Pack 校验 / grep 工具三处。
 
 /**
  * 约束 pattern 的拒绝原因（null = 可用）。
@@ -123,8 +126,9 @@ export function patternRejectionReason(/** @type {any} */ pattern) {
   } catch (/** @type {any} */ e) {
     return `正则无法编译：${e?.message || e}`;
   }
-  if (REDOS_NESTED_QUANT.test(pattern)) {
-    return 'pattern 含嵌套量词（如 (a+)+、(\\d+)*），在长文本上会指数级回溯——实测 29 字符即耗时数秒；请改写为不含嵌套量词的形式';
+  // 共用判定：嵌套量词 + 歧义分支（含嵌套组），见 src/regex-safety.js
+  if (hasNestedQuantifier(pattern) || hasAmbiguousAlternation(pattern)) {
+    return 'pattern 会灾难性回溯（嵌套量词或歧义分支，如 (a+)+、(a|aa)+、(a|a?)+、((a|ab)x)+）——实测 28–29 字符即耗时数秒到数十秒，会卡死内核；请改写为无歧义、无嵌套量词的形式';
   }
   return null;
 }

package/src/context.js

@@ -145,5 +145,12 @@ export function trimMessages(/** @type {any} */ messages, /** @type {any} */ bud
 export function clampText(/** @type {any} */ text, maxChars = TOOL_RESULT_LIMIT) {
   const s = String(text);
   if (s.length <= maxChars) return s;
-  return s.slice(0, maxChars) + `\n…[输出过长已截断，原文共 ${s.length} 字符]`;
+  // v0.6.7（报告一 L-1）：此前是裸 slice —— 截断点落在**代理对**中间会切出半个 emoji，
+  // 后续序列化/渲染得到 U+FFFD（BUG-079 只修了 safeHead 那条路径）。这里与它同源：回退一个码元。
+  const safeHead = (/** @type {string} */ t, /** @type {number} */ n) => {
+    if (t.length <= n) return t;
+    const c = t.charCodeAt(n - 1);
+    return c >= 0xd800 && c <= 0xdbff ? t.slice(0, n - 1) : t.slice(0, n);
+  };
+  return safeHead(s, maxChars) + `\n…[输出过长已截断，原文共 ${s.length} 字符]`;
 }