sillyspec 3.28.10 → 3.28.12

package/src/verify-postcheck.js

@@ -37,8 +37,10 @@ import { filterDeliverableFiles, classifyToolScaffold } from './worktree-apply.j
 import { parseTargetFiles, parseRepo } from './stages/plan-postcheck.js'
 // 探针重跑（P3b task-02 一致性抽查）：依赖方向已核实无环——verify-probes 只依赖
 // fs/path/git-helper/change-list/plan-postcheck/contract-matrix/foreign-declared/run-shared，
-// 不反向依赖本模块，此处直连不引入循环
-import { runVerifyProbes } from './verify-probes.js'
+// 不反向依赖本模块，此处直连不引入循环。smoke 机器段一致性（2026-09-17-api-coverage-smoke
+// task-02）复用同向 import：记录读取/态推导/标记扫描解析单点在 verify-probes
+// （readSmokeResultRecord/deriveSmokeSectionState/scanSmokeReceiptSection，与 ensure 注入同源）。
+import { runVerifyProbes, readSmokeResultRecord, deriveSmokeSectionState, scanSmokeReceiptSection } from './verify-probes.js'
 import { parseEvidenceSlots, classifyVerifiedFile } from './verify-facts-schema.js'
 
 // 测试命令最长执行时间；超时视为失败（防止 CLI 被挂起的测试卡死）
@@ -368,7 +370,7 @@ function collectPathTokens(text) {
 
 /**
  * 解析 module-impact.md 的「模块影响矩阵」+「未匹配文件」两节，按检查面归类影响证据。
- * 纯机械启发式（确定性：同输入同输出）；矩阵行 <!--TODO--> 未回填 → 保守计行为类
+ * 纯机械启发式（确定性：同输入同输出）；矩阵行 <!--TODO--> 未回填 → 保守计行为类 probe1-noqa
  * （影响面未知时多测不漏测）。矩阵节缺失 / 无数据行 → parseable=false（调用方降级）。
  *
  * @param {string|null} mdText
@@ -393,8 +395,8 @@ function classifyModuleImpactEvidence(mdText) {
       const tok = IMPACT_BEHAVIORAL_TOKENS.find((w) => rowText.includes(w))
       if (tok) { out.behavioral.push(`（影响类型：${tok}）`); classified++ }
     }
-    // 矩阵行 <!--TODO--> 未回填 → 影响面未知，保守计行为类
-    if (String(rowText).includes('<!--TODO')) { out.behavioral.push('<!--TODO--> 未回填行'); classified++ }
+    // 矩阵行 <!--TODO--> 未回填 → 影响面未知，保守计行为类 /* probe1-noqa */
+    if (String(rowText).includes('<!--TODO')) { out.behavioral.push('<!--TODO--> 未回填行'); classified++ } /* probe1-noqa */
     return classified
   }
   for (const line of lines) {
@@ -414,7 +416,7 @@ function classifyModuleImpactEvidence(mdText) {
       matrixRows++
       consumeRow(trimmed)
     } else if (section === 'unmatched') {
-      // 骨架产出 `- \`path\` <!--TODO-->` 列表行；手写形态可能是 `| 文件 | 处置说明 |` 表行
+      // 骨架产出 `- \`path\` <!--TODO-->` 列表行；手写形态可能是 `| 文件 | 处置说明 |` 表行 /* probe1-noqa */
       const bullet = trimmed.match(/^-\s+(.+)$/)
       if (bullet) { consumeRow(bullet[1]); continue }
       if (trimmed.startsWith('|')) {
@@ -803,7 +805,21 @@ const PY_TEST_ID_RE = /^\S+::\S+$/
 // 通过行用例名恰含这些字样（如「✓ … 超时后 syncStatus=failed」）会被误判失败行——
 // 2710 用例套件 382 个"失败行"里 378 假阳性，known_failures 无法逐条枚举而实质失效。
 // 框架输出里通过行恒以通过标记开头、失败行恒以失败标记开头，行首判定即足以分离两类。
-const PASS_LINE_RE = /^\s*(?:[✓√✔]|PASS\b)/
+// ✅ 补入标记集（2026-09-16-friction5-hardening verify 移交项②实证）：本仓自定义 harness 用
+// 「✅ PASS: <断言名>」打印通过行，断言名高频含 fail-closed/failed/×3（乘号）——✅ 不在集内时
+// 整行落 \bFAIL\b/×/failed 子串命中成假失败行（一轮 verify 实测 20/27 未豁免行为此噪声）。
+const PASS_LINE_RE = /^\s*(?:[✓√✔✅]|PASS\b)/
+// CLI advisory 行（行首 emoji 前缀，剥 ANSI 后判定）：⚠️ warn / ℹ️ info / 🔄 进度是工具自身的
+// 提示通道（如 gate-snapshot 的「⚠️ 快照 overlay 冒烟：…import 失败」——warn 正文含 ModuleNotFoundError，
+// 被子串命中成失败行）。测试框架的失败行恒以 ✕✗✘×/FAIL/--- FAIL 开头，不用这些 emoji 前缀——
+// 行首判定零误伤；漏检风险由 judgeWithKnownFailures 的 fail-safe（检测不到失败行不判 pass）兜底。
+const ADVISORY_LINE_RE = /^[ \t]*(?:⚠️?|ℹ️?|🔄)/
+// 工具词汇 fail-<x> 复合词中和（判账前从行内剥除，2026-09-16 verify 移交项②）：fail-closed/
+// fail-open/fail-soft/fail-safe/fail-loud/fail-fast 是本工具的行为契约词汇，PER_TEST_FAIL_RE 的
+// \bFAIL\b（i 标志）会把「（fail-closed）」「--- 1.3 fail-open 三态 ---」整行误收；剥除后再测，
+// 行内其余真失败词（FAILED/assertionerror/error: 等）不受影响（如 AssertionError 断言消息里
+// 出现 fail-closed 仍照常命中）。
+const FAIL_COMPOUND_NEUTRALIZE_RE = /fail-(?:closed|open|soft|safe|loud|fast)/gi
 // ANSI 色码剥离（分类用）：TTY 捕获的输出里 ✓/× 前缀可能被色码包裹，行首锚定会失配。
 const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g
 
@@ -848,8 +864,10 @@ export function partitionFailures(output, knownFailures) {
       else pyWarnCtx = false
     }
     if (PASS_LINE_RE.test(bare)) continue
+    if (ADVISORY_LINE_RE.test(bare)) continue
     if (ENV_NOISE_RE.test(bare)) continue
-    if (PER_TEST_FAIL_RE.test(bare) && !SUMMARY_LINE_RE.test(bare)) failureLines.push(l)
+    // fail-<x> 工具词汇中和后再测（见 FAIL_COMPOUND_NEUTRALIZE_RE 注释）：真失败词不被剥除
+    if (PER_TEST_FAIL_RE.test(bare.replace(FAIL_COMPOUND_NEUTRALIZE_RE, '')) && !SUMMARY_LINE_RE.test(bare)) failureLines.push(l)
   }
   // 豁免匹配同样在剥 ANSI 后的行上做（坑 verify-known-failures-ansi-exemption-split，2026-09-07
   // 工具复盘）：TTY 捕获的失败行里色码把可见词拦腰拆开（`× \x1b[31mtests/foo.test.ts\x1b[0m > case`
@@ -1407,6 +1425,9 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
   // 跨仓仓不参与 module 子集策略，只跑 full npm test（design §6 + §5.4）；
   // 跨仓仓无 package.json → 跳过 + warn 不阻断（design §9 兼容策略）。
   // 任一跨仓仓 fail → 整体 fail（合并语义）。
+  // 主仓 skipped（test_strategy: skip / evidence-auto 推荐跳过 / module 0 命中）→ 进短路档：
+  // 未自配 commands.test 的跨仓不再 fallback npm test 假败（task-05 / FR-07，见
+  // runCrossRepoTestUnderMainSkip 逐仓三态）。
   return mergeCrossRepoResults(mainResult, ctx)
 }
 
@@ -1419,6 +1440,9 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
  *   - 跨仓仓无 package.json → 跳过 + console.warn（不阻断 verify）
  *   - 跨仓仓只跑 full npm test，不参与 module 子集策略（module 映射主仓强相关）
  *   - 任一仓 fail → 整体 fail；主仓 skipped + 跨仓仓 passed → 整体 passed（跨仓仓有测试即有效）
+ *   - 主仓 skipped → 短路档（task-05 / FR-07）：未自配 commands.test 的跨仓随主仓 skip 短路
+ *     （不跑 fallback npm test 假败），自配了 commands.test 的仍跑，own test_strategy: skip
+ *     的单独 skip（runCrossRepoTestUnderMainSkip 逐仓三态）
  *
  * 单仓 ctx（无跨仓 entry）→ 直接返主仓结果，零行为变化（GOAL-2）。
  *
@@ -1434,9 +1458,15 @@ function mergeCrossRepoResults(mainResult, ctx) {
   }
   if (crossEntries.length === 0) return mainResult
 
+  // 主仓 skip 短路档（task-05 / FR-07 / design §5）：主仓 skipped（test_strategy: skip /
+  // evidence-auto 推荐跳过 / module 0 命中）时，未自配 commands.test 的跨仓不再 fallback
+  // `npm test`（无 test script 的仓必 exit 1 → npm missing-script 假败打回整批）——随主仓
+  // skip 短路；自配了 commands.test 的跨仓仍跑（用户显式意图，主仓 skip 不连带豁免）；own
+  // local.yaml 配 test_strategy: skip 的跨仓单独 skip（逐仓生效）。主仓 passed/failed 零变化。
+  const mainSkipped = !!(mainResult && mainResult.status === 'skipped')
   const crossResults = []
   for (const entry of crossEntries) {
-    const crossResult = runCrossRepoFullTest(entry)
+    const crossResult = mainSkipped ? runCrossRepoTestUnderMainSkip(entry) : runCrossRepoFullTest(entry)
     crossResults.push({ repoKey: entry.repoKey, projectRoot: entry.projectRoot, result: crossResult })
   }
 
@@ -1454,10 +1484,66 @@ function mergeCrossRepoResults(mainResult, ctx) {
   return mergeResultInfo(mainResult, crossResults)
 }
 
+/**
+ * 主仓 skip 短路档下跑单个跨仓仓测试（task-05 / FR-07，逐仓三态判定）：
+ *   - own local.yaml（<projectRoot>/.sillyspec/local.yaml）配 test_strategy: skip → 该仓
+ *     单独 skip（逐仓生效，独立于主仓策略）
+ *   - own local.yaml 配 commands.test → 仍走 runCrossRepoFullTest 执行（用户显式意图，
+ *     主仓 skip 不连带豁免实测）
+ *   - 未自配 commands.test（无 local.yaml / 读取失败 / 无 commands.test）→ 随主仓 skip
+ *     短路，不跑 fallback `npm test`（无 test script 的仓必 exit 1 → npm missing-script
+ *     假败，与坑 cross-repo-no-test-script 同族的环境性假红——但那是主仓非 skip 时的豁免
+ *     通道，语义不动）。出路注记：配 own local.yaml 的 commands.test 即可纳入实测。
+ *
+ * 合并语义（上游 mergeCrossRepoResults）：跨仓全 skipped → 整体保持主仓 skipped（reason
+ * 带短路与出路注记）；自配 commands.test 的跨仓 failed → 整体 fail（真败非假败，合理打回）。
+ *
+ * @param {object} entry - RepoEntry（isMain=false）
+ * @returns {object} 结果 shape 对齐 runCrossRepoFullTest 返回
+ */
+function runCrossRepoTestUnderMainSkip(entry) {
+  const crossLocalYaml = join(entry.projectRoot, '.sillyspec', 'local.yaml')
+  let yamlText = null
+  if (existsSync(crossLocalYaml)) {
+    try { yamlText = readFileSync(crossLocalYaml, 'utf8') } catch { yamlText = null }
+  }
+  if (yamlText) {
+    // own test_strategy: skip → 该仓单独 skip（显式声明优先于 commands.test）
+    if (extractTestStrategy(yamlText) === 'skip') {
+      return {
+        status: 'skipped',
+        command: null,
+        exitCode: null,
+        durationMs: null,
+        outputTail: null,
+        reason: `跨仓 repo "${entry.repoKey}" own local.yaml test_strategy: skip，该仓单独跳过测试（逐仓生效）`,
+        resultPath: null,
+        mode: 'cross-repo-skip-strategy',
+        repoKey: entry.repoKey,
+      }
+    }
+    // 自配 commands.test → 仍执行（原路径原语义）
+    if (extractTestCommand(yamlText)) return runCrossRepoFullTest(entry)
+  }
+  // 未自配 → 随主仓 skip 短路（不再 fallback npm test 假败）
+  console.warn(`⚠️  主仓 test_strategy skip 短路档：跨仓 repo "${entry.repoKey}"（${entry.projectRoot}）未自配 commands.test，不跑 fallback npm test（假败消除）。如需纳入实测：在 ${crossLocalYaml} 配 commands.test。`)
+  return {
+    status: 'skipped',
+    command: null,
+    exitCode: null,
+    durationMs: null,
+    outputTail: null,
+    reason: `主仓 skip 短路：跨仓 repo "${entry.repoKey}" 未自配 commands.test，随主仓跳过（可配 own local.yaml commands.test 纳入实测）`,
+    resultPath: null,
+    mode: 'cross-repo-main-skip',
+    repoKey: entry.repoKey,
+  }
+}
+
 /**
  * 在单个跨仓仓根跑 full npm test（跨仓仓不参与 module 子集，只跑 full）。
  * 跨仓仓 own local.yaml 若存在且配 commands.test → 用之；否则 fallback `npm test`。
- * 跨仓仓无 package.json → 跳过 + warn。
+ * 跨仓仓无 package.json，或有 package.json 但无 test 脚本（未被 own local.yaml 覆盖）→ 跳过 + warn。
  *
  * @param {object} entry - RepoEntry（isMain=false）
  * @returns {object} 结果 shape 对齐 runFullCommand 返回
@@ -1494,6 +1580,35 @@ function runCrossRepoFullTest(entry) {
     } catch { /* 读取失败 fallback npm test */ }
   }
 
+  // 跨仓仓有 package.json 但无 test 脚本，且未被 own local.yaml 覆盖 → 降级跳过 + warn
+  // （坑 cross-repo-no-test-script，2026-09-15 wp EHS 会话实证：spdemo 无 test script，
+  // fallback `npm test` 必 exit 1（npm missing-script）→ verify-test 环境性假红，agent 被迫
+  // 手工给该仓造 .sillyspec/local.yaml + 冒烟脚本。测试基建缺失是仓常态，非代码回归——
+  // 与「无 package.json」同款 skip 处理，hint 指向 own local.yaml 配置通道）。
+  // own local.yaml 显式配了命令 → 无条件执行（用户显式意图，即使无 test script 也跑）。
+  // package.json 解析失败 → 按原行为跑 `npm test`（fail-visible，不静默吞）。
+  if (command === 'npm test') {
+    let hasTestScript = true
+    try {
+      const pkg = JSON.parse(readFileSync(join(projectRoot, 'package.json'), 'utf8'))
+      hasTestScript = !!(pkg && pkg.scripts && Object.prototype.hasOwnProperty.call(pkg.scripts, 'test'))
+    } catch { /* 解析失败维持 npm test 原行为 */ }
+    if (!hasTestScript) {
+      console.warn(`⚠️  跨仓 repo "${entry.repoKey}"（${projectRoot}）package.json 无 test 脚本，跳过该仓测试（非代码回归，不阻断 verify）。如需纳入实测：在 ${join(projectRoot, '.sillyspec', 'local.yaml')} 配 commands.test（如轻量冒烟检查）。`)
+      return {
+        status: 'skipped',
+        command: null,
+        exitCode: null,
+        durationMs: null,
+        outputTail: null,
+        reason: `跨仓 repo "${entry.repoKey}" package.json 无 test 脚本，跳过测试（可配 own local.yaml commands.test 纳入）`,
+        resultPath: null,
+        mode: 'cross-repo-no-test-script',
+        repoKey: entry.repoKey,
+      }
+    }
+  }
+
   const startedAt = Date.now()
   let exitCode = 0
   let output = ''
@@ -1910,7 +2025,7 @@ export function printVerifyParityCheck(result) {
     console.warn('   ⚠️  本次 scope 为 full-repo（diff 与 apply-pathspec 均不可得时的兜底）——missing 大概率是口径错配噪音而非真实 contract gap。')
     console.warn('      先收窄复跑：sillyspec verify-probes --change <变更名>（change-diff/apply-pathspec 口径）再判定。')
   }
-  console.warn('   提示：检查是否后端漏实现，或前端调用了尚未实现的端点。确认无误可在 design.md 标注豁免。')
+  console.warn('   提示：检查是否后端漏实现，或前端调用了尚未实现的端点。确认无误可在 design.md 标注豁免。') /* probe1-noqa */
 }
 
 /**
@@ -2088,6 +2203,34 @@ export function trackVerifyResultRegression(specBase, changeName, absPath) {
  * @param {{cwd:string, specBase:string, changeName?:string}} args
  * @returns {{status:'skipped'|'passed'|'warning', items:Array, unacknowledged:Array, summary:string, reason:string|null}}
  */
+/**
+ * evidence 核验双根解析（坑⑤ / D-005@v1 消费侧双根 + 坑 platform-dual-root-fourth-consumer
+ * 2026-09-16 hunt）：apply 前新文件只在 worktree，逐文件核验单查主仓必误报「文件不存在」。
+ * meta 双候选定位（平台模式 specBase=specRoot 时主仓 worktree meta 在项目侧 <cwd>/.sillyspec，
+ * 单查 specBase 必落空——对齐 contract-matrix._readWorktreeMeta 双候选样板）；meta 在场 &&
+ * 非 in-place-fallback && worktreePath 目录存在 → [cwd, worktreePath]，否则 [cwd]。
+ * 解析异常 fail-open 退单根 + warning（不新增阻断路径）。导出供统一双根夹具测试。
+ */
+export function resolveEvidenceDualRoots({ cwd, specBase, changeName, warnings = [] }) {
+  let roots = [cwd]
+  try {
+    const metaCandidates = [...new Set([specBase, join(cwd, '.sillyspec')].filter(Boolean))]
+    const metaPath = metaCandidates
+      .map(b => join(b, '.runtime', 'worktrees', changeName, 'meta.json'))
+      .find(p => existsSync(p))
+    if (metaPath) {
+      const meta = JSON.parse(readFileSync(metaPath, 'utf8'))
+      if (meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath)) {
+        roots = [cwd, meta.worktreePath]
+      }
+    }
+  } catch (e) {
+    roots = [cwd]
+    warnings.push(`worktree meta 解析失败（${e.message}），evidence 双根核验退主仓单根`)
+  }
+  return roots
+}
+
 export function runVerifyRequiredEvidenceCheck({ cwd, specBase, changeName = null, verifyStartAt = null }) {
   if (!changeName) {
     return { status: 'skipped', items: [], unacknowledged: [], summary: '', reason: '无 changeName（quick 等无关联变更场景），evidence 对账跳过' }
@@ -2179,19 +2322,7 @@ function runRequiredEvidenceCheckV2({ items, slots, cwd, specBase, changeName, v
   // && worktreePath 目录存在 → roots = [cwd, worktreePath]；任一不满足退 [cwd] 单根
   // （零回归）。解析异常 fail-open 退单根 + warning（不新增阻断路径）。静默双根——对齐
   // buildAcceptanceHints（verify-probes.js:223）双根先例，核验明细 root 字段已可辨。──
-  let roots = [cwd]
-  try {
-    const metaPath = join(specBase || join(cwd, '.sillyspec'), '.runtime', 'worktrees', changeName, 'meta.json')
-    if (existsSync(metaPath)) {
-      const meta = JSON.parse(readFileSync(metaPath, 'utf8'))
-      if (meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath)) {
-        roots = [cwd, meta.worktreePath]
-      }
-    }
-  } catch (e) {
-    roots = [cwd]
-    warnings.push(`worktree meta 解析失败（${e.message}），evidence 双根核验退主仓单根`)
-  }
+  let roots = resolveEvidenceDualRoots({ cwd, specBase, changeName, warnings })
 
   const detailed = []
   let blockedCount = 0
@@ -2750,6 +2881,21 @@ export const PROBE5_MISSING_ROW_RE = /^\| ❌ missing \|/
  *  unavailable 行 / 无删除行 / ℹ️ note 行天然区分——后三者均无「反引号路径+状态尾缀」形态） */
 export const PROBE6_DELETION_LINE_RE = /^- (?:✅ 合规|❌ 高风险|⚠️ 未声明删除)[^`]* `[^`]+`（git 状态/
 
+/** probe8 契约外载荷键汇总行：`- ⚠️ 契约外载荷键 N 条（design 契约面未见，…）：…`
+ *  （renderProbe8Lines，verify-probes.js；N 条计数段与段内其它 ⚠️ 行（疑似字段错位配对/
+ *  NOT NULL 列前端未见）区分——契约行是汇总行非逐条行，锚点取行内 N 而非行计数） */
+export const PROBE8_CONTRACT_ORPHANS_LINE_RE = /^- ⚠️ 契约外载荷键 (\d+) 条/
+
+/** probe8 契约必填漏发汇总行：`- ⚠️ 契约必填漏发 N 条（契约 required 前端载荷未见，…）：…`
+ *  （同上汇总行口径，行内 N 为锚） */
+export const PROBE8_MISSING_REQUIRED_LINE_RE = /^- ⚠️ 契约必填漏发 (\d+) 条/
+
+/** probe9 守卫不一致汇总行：`- ⚠️ 守卫不一致实体组 N 个（同实体有守卫/无守卫并存——…）`
+ *  （renderProbe9Lines，verify-probes.js；同 probe8 契约行汇总行口径——锚点取行内 N 而非
+ *  逐条实体组行计数；`实体组 N 个` 计数段与段内逐条行 `- ⚠️ 实体 X：有守卫 […] / 无守卫 […]`
+ *  及其它 ⚠️ 行（NOT NULL 列等）形态区分） */
+export const PROBE9_INCONSISTENT_LINE_RE = /^- ⚠️ 守卫不一致实体组 (\d+) 个/
+
 /**
  * `#### 探针 N` 子节定界（G8/R-05）：子节 = 标题行起、下一任意 markdown 标题（下一探针
  * 子节 / `##` 章 / `#` 题）前止。探针 2/4 的 agent 补写内容天然落在本子节定界之外，其
@@ -2780,27 +2926,40 @@ function extractProbeSubsections(text) {
  * 导出供渲染→解析 round-trip 测试直接消费（R-01）。
  * @param {string} text verify-result.md 全文
  * @returns {{
- *   subsections: { probe1: boolean, probe3: boolean, probe5: boolean, probe6: boolean, any: boolean },
+ *   subsections: { probe1: boolean, probe3: boolean, probe5: boolean, probe6: boolean, probe8: boolean, probe9: boolean, any: boolean },
  *   probe1Hits: number,          // probe1 命中行计数（对比 probe1.matches.length）
  *   probe3HasTest: number,       // probe3 hasTest 行计数（对比 tasks.filter(hasTest).length）
  *   probe5SummaryPresent: boolean, // probe5 summary 锚行存在性（pass 形态锚）
  *   probe5Missing: number,       // `| ❌ missing |` 行计数（fail 形态锚，对比 missingBackend.length）
  *   probe6Deletions: number,     // probe6 删除条目行计数（对比 deletions.length）
+ *   probe8ContractOrphans: number, // probe8 契约外载荷键汇总行内 N 求和（无行=0；对比 contractOrphans.length）
+ *   probe8MissingRequired: number, // probe8 契约必填漏发汇总行内 N 求和（无行=0；对比 missingRequired.length）
+ *   probe9InconsistentGroups: number, // probe9 守卫不一致汇总行内 N 求和（无行=0；对比 inconsistentGroups.length）
  * }}
  */
 export function parseProbePrefillAnchors(text) {
   const sections = extractProbeSubsections(text)
   const count = (lines, re) => lines.reduce((n, l) => n + (re.test(l) ? 1 : 0), 0)
+  // 汇总行锚点（probe8 契约行/probe9 守卫行是「一行含总数」非逐条行）：提取行内 N 求和，无行 → 0
+  // （渲染面恒只输出一行，重复撞形行累加——重复本身就会撞出 mismatch，同子节合并口径）
+  const sumGroupCount = (lines, re) => lines.reduce((n, l) => {
+    const m = l.match(re)
+    return n + (m ? Number(m[1]) : 0)
+  }, 0)
   const s1 = sections['1'] || []
   const s3 = sections['3'] || []
   const s5 = sections['5'] || []
   const s6 = sections['6'] || []
+  const s8 = sections['8'] || []
+  const s9 = sections['9'] || []
   return {
     subsections: {
       probe1: '1' in sections,
       probe3: '3' in sections,
       probe5: '5' in sections,
       probe6: '6' in sections,
+      probe8: '8' in sections,
+      probe9: '9' in sections,
       any: Object.keys(sections).length > 0,
     },
     probe1Hits: count(s1, PROBE1_HIT_LINE_RE),
@@ -2808,6 +2967,9 @@ export function parseProbePrefillAnchors(text) {
     probe5SummaryPresent: count(s5, PROBE5_SUMMARY_LINE_RE) > 0,
     probe5Missing: count(s5, PROBE5_MISSING_ROW_RE),
     probe6Deletions: count(s6, PROBE6_DELETION_LINE_RE),
+    probe8ContractOrphans: sumGroupCount(s8, PROBE8_CONTRACT_ORPHANS_LINE_RE),
+    probe8MissingRequired: sumGroupCount(s8, PROBE8_MISSING_REQUIRED_LINE_RE),
+    probe9InconsistentGroups: sumGroupCount(s9, PROBE9_INCONSISTENT_LINE_RE),
   }
 }
 
@@ -2856,7 +3018,13 @@ function detectHeadAdvanceSinceFacts(cwd, facts) {
  *    - HEAD 前进子案（R-06）：facts.generatedAt 之后有新 commit 时 probe6 的 `git diff HEAD`
  *      口径整体漂移 → 该 mismatch 降 WARNING 提示重跑 --init；
  *    - probe3 hasTest 数 / probe5 锚（summary 行存在性 + missing 行数）不符 = WARNING
- *      （测试文件布局与 parity 扫描根环境敏感）。
+ *      （测试文件布局与 parity 扫描根环境敏感）；
+ *    - probe8 契约锚（契约外载荷键/契约必填漏发汇总行内 N）不符 = WARNING（2026-09-16
+ *      task-02：契约面解析随 design 形态与清单文件读取环境敏感；重跑降级（fail-soft catch
+ *      兜底无契约键）时跳过该维度不误报）；
+ *    - probe9 守卫锚（守卫不一致实体组汇总行内 N）不符 = WARNING（2026-09-16
+ *      guard-consistency-probe task-02：聚类/信号比对随 design 清单与 Java 文件读取环境
+ *      敏感；重跑降级时跳过该维度不误报）。
  *
  * 接线约定（task-03，gates.js）：status='mismatch' 且 severity='error' → 阻断回滚；
  * 'mismatch'+'warning' → 放行告警（envelope probe_consistency_drift）；'skipped'/'degraded' →
@@ -2877,7 +3045,7 @@ function detectHeadAdvanceSinceFacts(cwd, facts) {
  *   mismatches: Array<{probe: string, expected: *, actual: *, severity: 'error'|'warning', note: string}>,
  *     // expected = 当前重跑指标（应然），actual = 正文锚点解析值（agent 可篡改侧）
  *   skipReason: string|null,
- *   subsections: {probe1: boolean, probe3: boolean, probe5: boolean, probe6: boolean, any: boolean}|null,
+ *   subsections: {probe1: boolean, probe3: boolean, probe5: boolean, probe6: boolean, probe8: boolean, probe9: boolean, any: boolean}|null,
  *     // 诊断（additive）：探针子节在场性；报告未读到的早期 skip 为 null
  * }}
  */
@@ -2894,6 +3062,69 @@ export function isStrictChange({ pm, cwd, changeName } = {}) {
   return createdAt >= IR_STRICT_SINCE
 }
 
+/**
+ * smoke 回执槽机器段一致性对比（2026-09-17-api-coverage-smoke task-02 / FR-03 / Grill #6 /
+ * R-06）：机器段唯一事实源 = .runtime/verify-quality-scan-<change>.json 的 smokeResult 段
+ * （verify-probes ensure 注入的同源记录），md 侧 agent 只可追加段、不可改写/删除机器段。
+ * 时序保障：backfillFactsFromMdAndTests 的 ensure 注入（gates verify 收尾前置 + 二次回填）
+ * 先于本对比（checkProbeConsistency 在 gates 后段），此刻仍不符 = 机器段被改写/删除/冒充。
+ * 对比口径（全 ERROR——数值面防篡改，非环境敏感维度）：
+ * - 记录 passed：md 须有标记回执条目（无 = 被删除）；每条 command/exit/log 与记录逐字段比对
+ *   （trim 后严格相等——ensure 注入原样、解析侧 trim，正常链路恒一致），任一不符 = 被改写；
+ * - 记录 not-configured / not-ran：md 出现标记回执条目 = 冒充（未配置/未绿跑却有绿回执行）；
+ *   缺态注释行在场但态与记录不符 = 被改写；
+ * - 无记录：md 出现任何 CLI 标记行（回执条目或缺态注释）= 冒充——标记行唯一合法来源是
+ *   ensure，而 ensure 只在有记录时注入。
+ * export 说明（2026-09-17-api-coverage-smoke task-07）：供 test/smoke-gate.test.mjs
+ * 直接断言（task-02 偏离①挂账的接线正主——checkProbeConsistency 内部消费不变）。
+ * @param {string} reportText verify-result.md 全文
+ * @param {string} specBase .sillyspec 根
+ * @param {string} changeName 变更名
+ * @returns {{ state: string|null, absentState: string|null, machineCount: number, mismatches: Array<{probe:string,expected:*,actual:*,severity:'error',note:string}> }}
+ */
+export function auditSmokeReceiptConsistency(reportText, specBase, changeName) {
+  const smoke = readSmokeResultRecord(specBase, changeName)
+  const state = deriveSmokeSectionState(smoke)
+  const scan = scanSmokeReceiptSection(reportText)
+  const mismatches = []
+  const push = (expected, actual, note) =>
+    mismatches.push({ probe: 'smoke-receipt', expected, actual, severity: 'error', note })
+  const fixHint = '机器段唯一事实源是 .runtime/verify-quality-scan 记录 json 的 smokeResult（R-06），禁止手改——记录已过期则重跑 verify 质量扫描步（sillyspec run verify），CLI 会重新 ensure 机器段'
+  if (!state) {
+    if (scan.machineEntries.length > 0) {
+      push('无 smokeResult 记录（无 CLI 标记行）', `md 回执槽 ${scan.machineEntries.length} 条 source=cli-noai-smoke 标记条目`, `无 quality-scan smokeResult 记录而回执槽出现 CLI 机器段标记行——标记行唯一合法来源是 CLI ensure 注入（ensure 只在有记录时注入），疑似 agent 手写冒充。${fixHint}`)
+    } else if (scan.absentState) {
+      push('无 smokeResult 记录（无 CLI 标记行）', `缺态注释行 ${scan.absentState}`, `无 quality-scan smokeResult 记录而回执槽出现 CLI 缺态标注行——疑似 agent 手写冒充。${fixHint}`)
+    }
+    return { state, absentState: scan.absentState, machineCount: scan.machineEntries.length, mismatches }
+  }
+  if (state === 'passed') {
+    if (scan.machineEntries.length === 0) {
+      push('passed 机器段在场（command/exit/log 实录）', '回执槽无 source=cli-noai-smoke 标记条目', `quality-scan 记录 smokeResult.status='passed' 而回执槽机器段缺失/被删除（ensure 已在 backfill 时点先行注入，此刻仍缺 = 正文被改）。${fixHint}`)
+    }
+    for (const [i, e] of scan.machineEntries.entries()) {
+      const cmdOk = String((smoke && smoke.command) || '').trim() === String(e.command || '').trim()
+      const exitOk = (typeof (smoke && smoke.exitCode) === 'number' ? smoke.exitCode : null)
+        === (typeof e.exitCode === 'number' ? e.exitCode : null)
+      const logOk = String((smoke && smoke.logPath) || '').trim() === String(e.logPath || '').trim()
+      if (!cmdOk || !exitOk || !logOk) {
+        push(
+          `command=${smoke.command} / exit=${smoke.exitCode} / log=${smoke.logPath}`,
+          `第 ${i + 1} 条标记条目 command=${e.command} / exit=${e.exitCode} / log=${e.logPath}`,
+          `机器段数值与 quality-scan 记录 smokeResult 不符（command/exit/log 任一字段被改写即打回；多出的重复标记条目按同口径逐条比对）。${fixHint}`)
+      }
+    }
+  } else {
+    if (scan.machineEntries.length > 0) {
+      push(`缺态标注 ${state}（无绿跑机器段）`, `${scan.machineEntries.length} 条 source=cli-noai-smoke 标记回执条目`, `quality-scan 记录为 ${state}（未配置/未绿跑）而回执槽出现 CLI 机器段标记回执行——疑似 agent 手写冒充绿回执（ensure 已按记录态对齐，此刻仍在 = 正文被改）。${fixHint}`)
+    }
+    if (scan.absentState && scan.absentState !== state) {
+      push(`缺态标注 ${state}`, `缺态注释行 ${scan.absentState}`, `缺态注释行态与 quality-scan 记录不符——疑似被改写。${fixHint}`)
+    }
+  }
+  return { state, absentState: scan.absentState, machineCount: scan.machineEntries.length, mismatches }
+}
+
 export function checkProbeConsistency({ cwd, specBase = null, changeName = null, runtimeRoot = null, strictMode = false }) {
   if (!changeName) {
     return { status: 'skipped', severity: null, mismatches: [],
@@ -2993,6 +3224,46 @@ export function checkProbeConsistency({ cwd, specBase = null, changeName = null,
       note: 'contract gap（missing backend）行数与重跑不符（探针5 扫描根/缓存口径环境敏感，WARNING 不阻断）' })
   }
 
+  // probe8 契约锚（WARNING——2026-09-16 task-02：契约外载荷键/契约必填漏发汇总行内 N 对比
+  // 重跑数组长度；契约面解析随 design 形态与清单文件读取环境敏感，不阻断。fail-soft：重跑
+  // 降级（runVerifyProbes 的 catch 兜底对象无契约键）时 curP8*=null 跳过对比不误报）
+  const curProbe8 = current.probe8 || {}
+  const curP8Orphans = Array.isArray(curProbe8.contractOrphans) ? curProbe8.contractOrphans.length : null
+  const curP8MissingRequired = Array.isArray(curProbe8.missingRequired) ? curProbe8.missingRequired.length : null
+  if (curP8Orphans !== null && anchors.probe8ContractOrphans !== curP8Orphans) {
+    mismatches.push({ probe: 'probe8', expected: curP8Orphans, actual: anchors.probe8ContractOrphans, severity: 'warning',
+      note: '契约外载荷键条数与重跑不符（探针8 契约面解析对 design/清单文件形态环境敏感，WARNING 不阻断）——建议重跑 sillyspec verify-probes --change <变更名> --init 刷新预填段' })
+  }
+  if (curP8MissingRequired !== null && anchors.probe8MissingRequired !== curP8MissingRequired) {
+    mismatches.push({ probe: 'probe8', expected: curP8MissingRequired, actual: anchors.probe8MissingRequired, severity: 'warning',
+      note: '契约必填漏发条数与重跑不符（探针8 契约面解析对 design/清单文件形态环境敏感，WARNING 不阻断）——建议重跑 sillyspec verify-probes --change <变更名> --init 刷新预填段' })
+  }
+
+  // probe9 守卫锚（WARNING——2026-09-16 guard-consistency-probe task-02：守卫不一致实体组
+  // 汇总行内 N 对比重跑数组长度；聚类启发式与信号比对随 design 清单及 Java 文件读取环境
+  // 敏感，不阻断。fail-soft：重跑降级（runVerifyProbes 的 catch 兜底）时 probe9 兜底对象与
+  // probe8 不同——inconsistentGroups 恒为数组（[]），Array.isArray 判别失效，改以「探针 9
+  // 执行失败」注记判降级跳过对比，不误报）
+  const curProbe9 = current.probe9 || {}
+  const curP9Degraded = (curProbe9.notes || []).some(n => typeof n === 'string' && n.includes('探针 9 执行失败'))
+  const curP9Inconsistent = Array.isArray(curProbe9.inconsistentGroups) && !curP9Degraded
+    ? curProbe9.inconsistentGroups.length : null
+  const curP9GroupCount = typeof curProbe9.groupCount === 'number' && !curP9Degraded
+    ? curProbe9.groupCount : null
+  if (curP9Inconsistent !== null && anchors.probe9InconsistentGroups !== curP9Inconsistent) {
+    mismatches.push({ probe: 'probe9', expected: curP9Inconsistent, actual: anchors.probe9InconsistentGroups, severity: 'warning',
+      note: '守卫不一致实体组数与重跑不符（探针9 聚类/信号比对对 design 清单与 Java 文件形态环境敏感，WARNING 不阻断）——建议重跑 sillyspec verify-probes --change <变更名> --init 刷新预填段' })
+  }
+
+  // —— smoke 回执槽机器段一致性（ERROR——2026-09-17-api-coverage-smoke task-02 / FR-03 /
+  //    Grill #6 / R-06）：现 parseProbePrefillAnchors 只对比探针子节计数、不覆盖回执槽，
+  //    本维度补回执槽机器段防篡改——md 标记条目（source=cli-noai-smoke）command/exit/log
+  //    对 quality-scan 记录 json smokeResult 逐字段比对，agent 改写/删除/冒充 → ERROR 打回
+  //    （时序：backfill ensure 已先行注入/态对齐）。解析与记录读取单点在 verify-probes
+  //    （auditSmokeReceiptConsistency），与 ensure 注入同源不二算。——
+  const smokeAudit = auditSmokeReceiptConsistency(reportText, sb, changeName)
+  for (const sm of smokeAudit.mismatches) mismatches.push(sm)
+
   // —— facts 基线对比（2026-09-08-ir-verify-facts FR-05 / task-05）：重跑指标 vs
   // verify-facts.json probes 快照（init 时点）。md 锚点对账查「正文没被改」，本维度查
   // 「md 被手改对齐新代码后 facts 底稿过期」（P3d 数据源保鲜）。分级沿用现实现口径：
@@ -3025,8 +3296,45 @@ export function checkProbeConsistency({ cwd, specBase = null, changeName = null,
       fm.push({ probe: 'probe5', snapshot: snap5, rerun: cur5, severity: 'warning',
         note: 'facts 快照 backend 端点数与重跑不符（扫描根口径环境敏感，WARNING）' })
     }
+    // probe8 契约指标（2026-09-16 task-02，WARNING 同 md 锚点维度口径；metrics fail-soft
+    // 少列键（旧 facts 无 probe8）或重跑降级时不对账不列 checked，不误报）
+    const snap8Metrics = (((factsSnapshot.probes.probe8 || {}).metrics) || {})
+    const p8MetricsAvailable = typeof snap8Metrics.contractOrphans === 'number' || typeof snap8Metrics.missingRequired === 'number'
+    const p8RerunAvailable = curP8Orphans !== null || curP8MissingRequired !== null
+    if (typeof snap8Metrics.contractOrphans === 'number' && curP8Orphans !== null
+      && snap8Metrics.contractOrphans !== curP8Orphans) {
+      fm.push({ probe: 'probe8', snapshot: snap8Metrics.contractOrphans, rerun: curP8Orphans, severity: 'warning',
+        note: 'facts 快照契约外载荷键数与重跑不符（契约面解析环境敏感，WARNING）——建议 verify-probes --init 刷新 facts + 同步 md 探针段' })
+    }
+    if (typeof snap8Metrics.missingRequired === 'number' && curP8MissingRequired !== null
+      && snap8Metrics.missingRequired !== curP8MissingRequired) {
+      fm.push({ probe: 'probe8', snapshot: snap8Metrics.missingRequired, rerun: curP8MissingRequired, severity: 'warning',
+        note: 'facts 快照契约必填漏发数与重跑不符（契约面解析环境敏感，WARNING）——建议 verify-probes --init 刷新 facts + 同步 md 探针段' })
+    }
+    // probe9 守卫指标（2026-09-16 guard-consistency-probe task-02，WARNING 同 md 锚点维度口径；
+    // 双指标 = inconsistentGroups（命中面，同 md 锚点维度）+ groupCount（聚类组面，design 清单
+    // Java 文件内容变更的漂移信号）。javaFileCount 不入对账——文件读取受 worktree 存活态等
+    // 环境维度影响（R-02 同款排除口径，probe1 排除 worktreeHits 先例）；metrics fail-soft 少列
+    // 键（旧 facts 无 probe9）或重跑降级（curP9*=null）时不对账不列 checked，不误报）
+    const snap9Metrics = (((factsSnapshot.probes.probe9 || {}).metrics) || {})
+    const p9MetricsAvailable = typeof snap9Metrics.inconsistentGroups === 'number' || typeof snap9Metrics.groupCount === 'number'
+    const p9RerunAvailable = curP9Inconsistent !== null || curP9GroupCount !== null
+    if (typeof snap9Metrics.inconsistentGroups === 'number' && curP9Inconsistent !== null
+      && snap9Metrics.inconsistentGroups !== curP9Inconsistent) {
+      fm.push({ probe: 'probe9', snapshot: snap9Metrics.inconsistentGroups, rerun: curP9Inconsistent, severity: 'warning',
+        note: 'facts 快照守卫不一致组数与重跑不符（聚类/信号比对环境敏感，WARNING）——建议 verify-probes --init 刷新 facts + 同步 md 探针段' })
+    }
+    if (typeof snap9Metrics.groupCount === 'number' && curP9GroupCount !== null
+      && snap9Metrics.groupCount !== curP9GroupCount) {
+      fm.push({ probe: 'probe9', snapshot: snap9Metrics.groupCount, rerun: curP9GroupCount, severity: 'warning',
+        note: 'facts 快照同实体变更方法组数与重跑不符（聚类面随 design 清单 Java 文件内容漂移，WARNING）——建议 verify-probes --init 刷新 facts + 同步 md 探针段' })
+    }
     factsConsistency = {
-      checked: fm.length === 0 ? ['probe1', 'probe3', 'probe5', 'probe6'] : [...new Set(fm.map(x => x.probe))],
+      checked: fm.length === 0
+        ? ['probe1', 'probe3', 'probe5', 'probe6',
+          ...((p8MetricsAvailable && p8RerunAvailable) ? ['probe8'] : []),
+          ...((p9MetricsAvailable && p9RerunAvailable) ? ['probe9'] : [])]
+        : [...new Set(fm.map(x => x.probe))],
       verdict: fm.length === 0 ? 'match' : 'mismatch',
       detail: fm.length === 0 ? null : fm,
     }
@@ -3042,13 +3350,23 @@ export function checkProbeConsistency({ cwd, specBase = null, changeName = null,
     } catch { /* 固化失败不阻断对账 */ }
   }
 
+  // smoke 机器段诊断（additive，factsConsistency 同款先例：状态/条目计数随结果透传，供
+  // gates 侧 envelope 落盘与排查；不参与判定——判定由上方 mismatches 收集完成）
+  const smokeConsistency = {
+    state: smokeAudit.state, absentState: smokeAudit.absentState,
+    machineCount: smokeAudit.machineCount,
+    verdict: smokeAudit.mismatches.length === 0 ? 'match' : 'mismatch',
+  }
+
   if (mismatches.length === 0) {
     const okResult = finish('ok', null, [], null)
     okResult.factsConsistency = factsConsistency
+    okResult.smokeConsistency = smokeConsistency
     return okResult
   }
   const severity = mismatches.some(m => m.severity === 'error') ? 'error' : 'warning'
   const mismatchResult = finish('mismatch', severity, mismatches, null)
   mismatchResult.factsConsistency = factsConsistency
+  mismatchResult.smokeConsistency = smokeConsistency
   return mismatchResult
 }