sillyspec 3.28.9 → 3.28.11

package/src/verify-postcheck.js

@@ -28,9 +28,10 @@ import { IR_STRICT_SINCE } from './constants.js'
 import { gitQuiet } from './git-helper.js'
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync } from 'fs'
 import { join } from 'path'
-import { verifyApiParity } from './contract-matrix.js'
+import { verifyApiParity, _readWorktreeMeta } from './contract-matrix.js'
+import { reconcileCrossRepoDeclarations } from './cross-repo-reconcile.js'
 import { parseFileChangeListDetailed, pathMatches } from './change-list.js'
-import { filterDeliverableFiles } from './worktree-apply.js'
+import { filterDeliverableFiles, classifyToolScaffold } from './worktree-apply.js'
 // target_files 声明侧解析（Wave 1 已落地）：依赖链已核实无环——plan-postcheck 不反向依赖本模块，
 // 且本模块已经 worktree-apply.js:21 间接依赖 plan-postcheck，此处改直连不引入新环（task-04）
 import { parseTargetFiles, parseRepo } from './stages/plan-postcheck.js'
@@ -367,7 +368,7 @@ function collectPathTokens(text) {
 
 /**
  * 解析 module-impact.md 的「模块影响矩阵」+「未匹配文件」两节，按检查面归类影响证据。
- * 纯机械启发式（确定性：同输入同输出）；矩阵行 <!--TODO--> 未回填 → 保守计行为类
+ * 纯机械启发式（确定性：同输入同输出）；矩阵行 <!--TODO--> 未回填 → 保守计行为类 probe1-noqa
  * （影响面未知时多测不漏测）。矩阵节缺失 / 无数据行 → parseable=false（调用方降级）。
  *
  * @param {string|null} mdText
@@ -392,8 +393,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) {
@@ -413,7 +414,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('|')) {
@@ -605,6 +606,46 @@ function parseFlowValue(flowText, key) {
   return v.length > 0 ? v : null
 }
 
+/**
+ * module 子集测试面的依赖测试自动发现（坑 module-test-face-rot，2026-09-16 本会话 5325f55
+ * 实证：local.yaml modules 的 test 命令是硬编码文件清单，src/verify-probes.js 命中 cli-core
+ * 但其断言测试 verify-probes-facts.test.mjs 不在清单 → quick --done 的 module 收窄实测漏掉
+ * 全量断言，回归漏到合并态才暴露）。发现口径：变更 src 文件的**直接 import 测试**（test/
+ * 下 *.test.* 内含 `../src/<changed>` 引用——静态/动态 import 通吃，子串匹配只可能多跑不漏）
+ * ∪ 变更的 test 文件本身；已被命中模块命令串覆盖的（命令串含该文件名）排除防重复。
+ * @param {{cwd: string, changedFiles: string[], coveredCommands?: string[]}} args
+ * @returns {string[]} 相对 cwd 的测试文件路径（posix 形态，已排序；无可发现 → []）
+ */
+export function discoverModuleDependentTests({ cwd, changedFiles, coveredCommands = [] }) {
+  if (!Array.isArray(changedFiles) || changedFiles.length === 0) return []
+  const norm = (p) => String(p).replace(/\\/g, '/')
+  const changedSrc = [...new Set(changedFiles.map(norm))]
+    .filter(p => p.startsWith('src/') && /\.(js|mjs|cjs|ts)$/.test(p))
+  const changedTests = [...new Set(changedFiles.map(norm))]
+    .filter(p => /^test\//.test(p) && /\.test\.[cm]?js$/.test(p))
+  if (changedSrc.length === 0 && changedTests.length === 0) return []
+  const covered = coveredCommands.filter(Boolean).join(' ')
+  const found = new Set()
+  const testDir = join(cwd, 'test')
+  let entries = []
+  try { entries = readdirSync(testDir) } catch { entries = [] }
+  for (const f of entries) {
+    if (!/\.test\.[cm]?js$/.test(f)) continue
+    if (covered.includes(f)) continue
+    let content = ''
+    try { content = readFileSync(join(testDir, f), 'utf8') } catch { continue }
+    for (const src of changedSrc) {
+      if (content.includes(`../${src}`)) { found.add(`test/${f}`); break }
+    }
+  }
+  for (const t of changedTests) {
+    const fname = t.split('/').pop()
+    if (covered.includes(fname)) continue
+    if (existsSync(join(cwd, t))) found.add(t)
+  }
+  return [...found].sort()
+}
+
 /**
  * 根据变更文件列表 + modules 映射，算出被命中的模块（去重保序）。
  * 文件路径以 module.path 为前缀（含子目录）即视为命中。
@@ -762,7 +803,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
 
@@ -807,8 +862,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`
@@ -1049,20 +1106,20 @@ export function resolveVerifyChangedFiles(cwd, changeName, ctx = null, opts = {}
 
   // 并入 worktree 未提交改动（坑 module-subset-zero-hit-uncommitted，2026-08-21 实证：
   // 子代理默认不 commit，真实改动全在 worktree working-tree——只看 base..HEAD commit diff
-  // 时 module 映射 0 命中直接跳过（frontend/** 变更未命中 frontend 模块）。与
-  // generateTaskReviewDrafts 的并入口径同源：meta.worktreePath 下 status --porcelain 文件
+  // 时 module 映射 0 命中直接跳过（frontend/** 变更未命中 frontend 模块）。口径与
+  // collectWorktreeChangedFiles（task-review.js，D-004@v1 单一真相 helper）同源，但本段是
+  // form A 专属变体（滤网保 .sillyspec/docs/** 交付物）——已知残留 R-09，待下次触碰统一。
   // （排除 .sillyspec/ 运行时产物）。opt-in（默认关）：d drafts 有自己的并入点，避免双并。
   if (includeWorkingTree && mainFiles !== null) {
     try {
-      // P1 修复（2026-09-07）：metaPath 吃 opts.specBase——此前硬编码 join(cwd,'.sillyspec')，
-      // 平台模式（specRoot 与 source_root 分离）下 worktree meta 静默读不到 → 形态 A 并入失效 → ②类假红。
-      // 与下方 resolveMainChangedFiles 的 specBase 兜底同口径。
-      const metaPath = join(opts.specBase || join(cwd, '.sillyspec'), '.runtime', 'worktrees', changeName, 'meta.json')
-      if (changeName && existsSync(metaPath)) {
-        const meta = JSON.parse(readFileSync(metaPath, 'utf8'))
-        const wtGitDir = (meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath))
-          ? meta.worktreePath
-          : cwd
+      // 双根读取（坑 platform-dual-root-form-misjudge，2026-09-15 复盘实证）：P1 修复
+      // （2026-09-07）只吃 opts.specBase 单路径——平台模式（specRoot 与 source_root 分离）下
+      // meta 若落项目侧 .sillyspec/.runtime（resolveRuntimeRoot 的 localSpecBase 兜底形）仍读
+      // 不到 → 形态 A 并入失效 → ②类假红。_readWorktreeMeta 双候选（specBase 优先 +
+      // cwd/.sillyspec 兜底，contract-matrix 既有样板）两形全覆盖。
+      const found = changeName ? _readWorktreeMeta(opts.specBase || null, cwd, changeName) : null
+      if (found) {
+        const wtGitDir = found.gitDir
         const wtStatus = gitQuiet(wtGitDir, ['status', '--porcelain', '--untracked-files=all'], { timeout: 30000, trim: false })
         // P1 修复（2026-09-07）：过滤器改 filterDeliverableFiles 口径（worktree-apply.js 同款）——
         // 此前 `.sillyspec/` 一刀切把 docs 交付物也滤掉，声明了模块文档的 task 在形态 A 下落②类假红
@@ -1152,16 +1209,16 @@ export function resolveVerifyChangedFiles(cwd, changeName, ctx = null, opts = {}
 function resolveMainChangedFiles(cwd, changeName, specBase = null) {
   const sb = specBase || join(cwd, '.sillyspec')
   if (changeName) {
-    const metaPath = join(sb, '.runtime', 'worktrees', changeName, 'meta.json')
-    if (existsSync(metaPath)) {
-      let meta = null
-      try { meta = JSON.parse(readFileSync(metaPath, 'utf8')) } catch {}
+    // 双根读取（坑 platform-dual-root-form-misjudge）：specBase（平台模式=specRoot）单路径在
+    // meta 落项目侧 .sillyspec 时静默 miss → 锚点 diff 整链失效落主仓 fallback。双候选
+    // （specBase 优先 + cwd/.sillyspec 兜底）两形全覆盖；sb 仍作他者声明过滤根（原语义不动）。
+    const found = _readWorktreeMeta(specBase || null, cwd, changeName)
+    if (found) {
+      const meta = found.meta
       // 优先 baselineCommit/actualBaseHash（baseline checkpoint 之后），回退 baseHash
       const diffBase = meta?.baselineCommit || meta?.actualBaseHash || meta?.baseHash
       if (diffBase) {
-        const gitDir = (meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath))
-          ? meta.worktreePath
-          : cwd
+        const gitDir = found.gitDir
         const files = runGitDiffNameOnly(gitDir, `${diffBase}..HEAD`)
         // 坑 verify-evidence-account-diff-misses-committed-changes（2026-09-13 实证）：
         // wt-commit 流程把本变更提交落在**主仓 HEAD**，worktree 分支不前移——仅查 worktree
@@ -1326,7 +1383,7 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
       },
     })
   } else if (action === 'module-subset') {
-    mainResult = runModuleSubset({ cwd, specBase, changeName, hits, knownFailures })
+    mainResult = runModuleSubset({ cwd, specBase, changeName, hits, knownFailures, changedFiles: lastChangedFiles })
   } else if (action === 'module-zero-hit-skip') {
     // module 模式 0 命中：不静默回退注定超时/含预存失败的全量（坑 verify-worktree-... 修复方向 3）。
     // 据 verify-result.md 自报告判定；想跑全量请显式设 test_strategy: full。
@@ -1366,6 +1423,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)
 }
 
@@ -1378,6 +1438,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）。
  *
@@ -1393,9 +1456,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 })
   }
 
@@ -1413,10 +1482,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 返回
@@ -1453,6 +1578,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 = ''
@@ -1657,12 +1811,21 @@ function runFullCommand({ yamlText, localYamlPath, cwd, specBase, changeName, fa
  * 串行跑命中的模块子集，聚合结果。
  * 返回 shape 与 runFullCommand 一致（status/command/exitCode/durationMs/outputTail/reason/resultPath）。
  */
-function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [] }) {
+function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [], changedFiles = [] }) {
   const subsetStartedAt = Date.now()
   const perModule = hits.map(h => runOneModule(h.name, h.test, cwd, knownFailures))
+  // 依赖测试伪模块（module-test-face-rot，2026-09-16 本会话实证）：硬编码模块测试清单不含
+  // 变更 src 文件的直接断言测试 → module 收窄漏全量断言。附加执行「import 变更 src 的测试 ∪
+  // 变更的 test 文件」中未被命中模块命令覆盖的部分；无额外文件零行为（不新增失败面）。
+  const deps = discoverModuleDependentTests({ cwd, changedFiles, coveredCommands: hits.map(h => h.test) })
+  if (deps.length > 0) {
+    perModule.push(runOneModule('deps(auto)', `node --test ${deps.slice(0, 30).join(' ')}`, cwd, knownFailures))
+    console.log(`ℹ️ module 子集已附加依赖测试伪模块 deps(auto)：${deps.length} 个（import 变更 src/变更的 test 本体，未被模块命令串覆盖——治硬编码清单腐烂）`)
+  }
   const status = aggregateStatus(perModule)
 
-  const command = `module[${hits.map(h => h.name).join(',')}]`
+  let command = `module[${hits.map(h => h.name).join(',')}]`
+  if (deps.length > 0) command += `+deps(${Math.min(deps.length, 30)})`
   const exitCode = status === 'passed' ? 0 : 1
   const durationMs = Date.now() - subsetStartedAt
 
@@ -1860,7 +2023,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 */
 }
 
 /**
@@ -2038,6 +2201,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 对账跳过' }
@@ -2094,6 +2285,8 @@ export function runVerifyRequiredEvidenceCheck({ cwd, specBase, changeName = nul
  * 天然不覆盖该类路径，硬要求交集必假红）。verifyStartAt 缺省走 R-05 fallback（design.md
  * created_at 之后宽容 + warning）。status 语义扩 'blocked'（missing 无豁免 / satisfied 核验
  * 不过）——gates 接线（task-03）据此阻断 verify 完成。
+ * 逐文件存在性/mtime 双根取数（坑⑤ / D-005@v1）：候选根 [cwd, worktree 根]——apply 前
+ * 新文件只在 worktree，单查主仓必误报「文件不存在」；meta 缺失/in-place 退单根（零回归）。
  */
 function runRequiredEvidenceCheckV2({ items, slots, cwd, specBase, changeName, verifyStartAt }) {
   const warnings = []
@@ -2121,6 +2314,14 @@ function runRequiredEvidenceCheckV2({ items, slots, cwd, specBase, changeName, v
     changedSet = new Set((changed || []).map(p => String(p).replace(/\\/g, '/')))
   } catch { changedSet = null }
 
+  // ── 候选根解析（坑⑤ / D-005@v1，消费侧双根）：apply 前新文件只在 worktree，逐文件核验
+  // 单查主仓 join(cwd, vf) 必误报「文件不存在」错误阻断 verify。worktree 根口径与
+  // resolveVerifyChangedFiles（~1061 metaPath 段）同源：meta 在场 && 非 in-place-fallback
+  // && worktreePath 目录存在 → roots = [cwd, worktreePath]；任一不满足退 [cwd] 单根
+  // （零回归）。解析异常 fail-open 退单根 + warning（不新增阻断路径）。静默双根——对齐
+  // buildAcceptanceHints（verify-probes.js:223）双根先例，核验明细 root 字段已可辨。──
+  let roots = resolveEvidenceDualRoots({ cwd, specBase, changeName, warnings })
+
   const detailed = []
   let blockedCount = 0
   for (const item of items) {
@@ -2143,11 +2344,17 @@ function runRequiredEvidenceCheckV2({ items, slots, cwd, specBase, changeName, v
       }
       for (const vf of slot.verifiedFiles) {
         const pathClass = classifyVerifiedFile(vf)
-        const abs = join(cwd, vf)
-        const filesExist = existsSync(abs)
+        // 双根取数（坑⑤ / D-005@v1，形态沿 buildAcceptanceHints 双根先例）：任一根存在即
+        // filesExist=true；双根都在取 worktree 根（R-05：新改动所在，主仓旧 mtime 不误判
+        // 过期）——倒序找命中根（roots=[cwd] 时即单根现状；roots=[cwd, wt] 时先试 wt 再回退）。
+        let hitRoot = null
+        for (let i = roots.length - 1; i >= 0; i--) {
+          if (existsSync(join(roots[i], vf))) { hitRoot = roots[i]; break }
+        }
+        const filesExist = hitRoot !== null
         let mtimeOk = null
         if (filesExist && startAt) {
-          try { mtimeOk = statSync(abs).mtimeMs >= startAt - 60_000 } catch { mtimeOk = null }
+          try { mtimeOk = statSync(join(hitRoot, vf)).mtimeMs >= startAt - 60_000 } catch { mtimeOk = null }
         }
         let diffHit = null
         if (pathClass === 'code') {
@@ -2157,7 +2364,7 @@ function runRequiredEvidenceCheckV2({ items, slots, cwd, specBase, changeName, v
         }
         const ok = filesExist && mtimeOk !== false && diffHit !== false
         if (!ok) allOk = false
-        perFile.push({ path: vf, pathClass, filesExist, mtimeOk, diffHit,
+        perFile.push({ path: vf, pathClass, filesExist, mtimeOk, diffHit, root: hitRoot,
           reason: !filesExist ? '文件不存在'
             : (mtimeOk === false ? `mtime 早于 verifyStartAt（${new Date(startAt).toISOString()}）`
             : (diffHit === false ? '不在本变更 git diff 内' : null)) })
@@ -2245,7 +2452,7 @@ function normalizeReviewChangedFile(p) {
  * @returns {{ cardCount: number, declarations: Array<{task:string, path:string, isNew:boolean, raw:string, invalid:string|null}>, crossRepoCards: string[], noDeclarationCount: number }}
  */
 function collectDeclaredTargetFiles(specBase, changeName) {
-  const out = { cardCount: 0, declarations: [], crossRepoCards: [], noDeclarationCount: 0 }
+  const out = { cardCount: 0, declarations: [], crossRepoCards: [], crossRepoDeclarations: {}, noDeclarationCount: 0 }
   const tasksDir = join(specBase, 'changes', changeName, 'tasks')
   if (!existsSync(tasksDir)) return out
   // task-NN.md 过滤 + 排序：与 plan-postcheck / task-review 的枚举口径一致，输出确定性
@@ -2257,7 +2464,18 @@ function collectDeclaredTargetFiles(specBase, changeName) {
     const fm = content.match(/^---\n([\s\S]*?)\n---/)?.[1] || ''
     const task = (fm.match(/^id:\s*(.+)/m)?.[1] || '').trim() || file.replace(/\.md$/, '')
     const repo = parseRepo(content)
-    if (repo) { out.crossRepoCards.push(`${task}（repo: ${repo}）`); continue }
+    if (repo) {
+      out.crossRepoCards.push(`${task}（repo: ${repo}）`)
+      // 跨仓声明留存（坑 cross-repo-reconcile-blindness，2026-09-15 复盘兑现 D-004 分期）：
+      // 主仓对账仍剔除跨仓卡（主仓 actual 永远对不上跨仓声明），但声明不丢弃——
+      // reconcileCrossRepoDeclarations 到各自仓对账（advisory）
+      const crossEntries = parseTargetFiles(content).entries || []
+      if (crossEntries.length > 0) {
+        ;(out.crossRepoDeclarations[repo] = out.crossRepoDeclarations[repo] || [])
+          .push(...crossEntries.map(e => ({ task, path: e.path, isNew: e.isNew })))
+      }
+      continue
+    }
     const { entries, missing } = parseTargetFiles(content)
     if (missing) { out.noDeclarationCount++; continue }
     for (const e of entries) {
@@ -2324,14 +2542,22 @@ function parsePorcelainFilePaths(raw) {
  * resolveMainChangedFiles 同口径，三锚全缺 null）；形态 B 取 merge-base hash（分支不存在/
  * merge-base 不可得 null）；降级返回恒 null。
  *
- * @returns={{ ok: boolean, form: 'worktree'|'post-apply', files: string[], sources: string[], foreignExcluded: number, degradedReason: string|null, baseAnchor: string|null }}
+ * @returns={{ ok: boolean, form: 'worktree'|'post-apply', files: string[], sources: string[], foreignExcluded: number, foreignExcludedFiles: string[], degradedReason: string|null, baseAnchor: string|null }}
  */
 export function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, changeName }) {
-  const metaPath = join(specBase, '.runtime', 'worktrees', changeName, 'meta.json')
-  const form = existsSync(metaPath) ? 'worktree' : 'post-apply'
+  // 形态判定双根化（坑 platform-dual-root-form-misjudge，2026-09-15 复盘实证：平台模式
+  // specBase=specRoot 时项目侧 .sillyspec 的 meta 读不到 → 误判 post-apply → 按主仓 git
+  // 三源对账 → ②类 21 条全量假红阻断 verify 收尾）。_readWorktreeMeta 双候选（specBase
+  // 优先 + cwd/.sillyspec 兜底，contract-matrix 既有样板）为形态判定的唯一权威入口。
+  const wtMeta = _readWorktreeMeta(specBase || null, cwd, changeName)
+  const form = wtMeta ? 'worktree' : 'post-apply'
   const sources = []
   const union = new Set()
   let foreignExcluded = 0
+  // 退栈文件名单（scope-audit-cross-repo-blindness 改进点 3）：原只回计数，scope-audit 侧
+  // 无法区分「真未动」与「已写盘但被退栈」——补名单（仅文件名，owners 不重复携带），
+  // 消费方按「planned ∩ excluded ∩ 盘面存在」标「疑似他者已实现」。
+  const foreignExcludedFiles = []
   let baseAnchor = null
 
   if (form === 'worktree') {
@@ -2339,15 +2565,12 @@ export function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, change
     // working-tree 并入、fail-open 均为该函数既有语义，不另造口径）——
     const files = resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true, specBase })
     if (files === null) {
-      return { ok: false, form, files: [], sources, foreignExcluded,
+      return { ok: false, form, files: [], sources, foreignExcluded, foreignExcludedFiles,
         degradedReason: 'worktree 锚点 diff 与主仓 fallback 均失败（git 不可用 / 非仓库）', baseAnchor: null }
     }
-    // baseAnchor：读同一份 worktree meta.json 锚点（baselineCommit>actualBaseHash>baseHash，
-    // resolveMainChangedFiles 同口径；解析失败/三锚全缺 → null）
-    try {
-      const meta = JSON.parse(readFileSync(metaPath, 'utf8'))
-      baseAnchor = meta?.baselineCommit || meta?.actualBaseHash || meta?.baseHash || null
-    } catch {}
+    // baseAnchor：读形态判定命中的同一份 worktree meta.json 锚点（baselineCommit>
+    // actualBaseHash>baseHash，resolveMainChangedFiles 同口径；三锚全缺 → null）
+    baseAnchor = wtMeta?.meta?.baselineCommit || wtMeta?.meta?.actualBaseHash || wtMeta?.meta?.baseHash || null
     sources.push('worktree:diff-base..HEAD', 'worktree:status-porcelain(uncommitted)')
     for (const f of files) union.add(normalizeReconcilePath(f))
   } else {
@@ -2386,7 +2609,10 @@ export function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, change
       let files = parsePorcelainFilePaths(statusRaw)
       if (files.length > 0) {
         const { own, foreign } = splitOwnVsForeignDiffFiles(cwd, changeName, files, { specBase })
-        if (foreign.length > 0) foreignExcluded = foreign.length
+        if (foreign.length > 0) {
+          foreignExcluded = foreign.length
+          for (const fo of foreign) foreignExcludedFiles.push(normalizeReconcilePath(fo.file))
+        }
         files = own
       }
       for (const f of files) union.add(normalizeReconcilePath(f))
@@ -2403,13 +2629,13 @@ export function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, change
       } catch { /* 兜底源失败 → 忽略 */ }
     }
     if (!diffOk && !statusOk) {
-      return { ok: false, form, files: [], sources, foreignExcluded,
+      return { ok: false, form, files: [], sources, foreignExcluded, foreignExcludedFiles,
         degradedReason: 'merge-base 锚定 diff 未得且主仓 status 失败（git 不可用 / 非仓库 / 无锚点分支）', baseAnchor: null }
     }
   }
 
   const files = [...new Set(filterDeliverableFiles([...union]).filter(Boolean))].sort()
-  return { ok: true, form, files, sources, foreignExcluded, degradedReason: null, baseAnchor }
+  return { ok: true, form, files, sources, foreignExcluded, foreignExcludedFiles, degradedReason: null, baseAnchor }
 }
 
 /**
@@ -2419,13 +2645,15 @@ export function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, change
  * - 归属过滤：run 目录带 change 戳且不等值 → 他变更的 run 跳过（task-NN 跨变更同名，混扫必
  *   错归因；无戳旧 run 保留——向后兼容，task-review.js resolveLatestExecuteRunIdWithTasks 同款）。
  * - runId 形如 exec-YYYY-MM-DD-HHMMSS：字典序倒序 = 新 run 优先（review 以最新执行为准）。
- * - changedFiles 是 agent 手写（注记/相对路径常态），归一后 exact match、首个命中即止——
- *   归因只是③类报告的附注，错比漏代价低，不追求穷举。
+ * - changedFiles 是 agent 手写（注记/相对路径常态），归一后 exact match、全命中收集（多归属，
+ *   坑④ worktree-tick-guard-commit-only：原「首个命中即止」吞掉同文件多 task 的归属）——
+ *   归因只是③类报告的附注，错比漏代价低；同一 taskId 去重，顺序 = 扫描序（run 倒序新优先 +
+ *   task 目录字典序）。
  *
  * @param {string} runtimeRoot .sillyspec/.runtime
  * @param {string} changeName
  * @param {string[]} paths 待归因的③类路径（git 口径的干净路径）
- * @returns {Map<string, string>} normalized(path) → taskId
+ * @returns {Map<string, string[]>} normalized(path) → taskId[]（全命中收集，保序去重）
  */
 function attributeSuspectTasks(runtimeRoot, changeName, paths) {
   const map = new Map()
@@ -2452,7 +2680,10 @@ function attributeSuspectTasks(runtimeRoot, changeName, paths) {
       const taskId = (typeof review.task === 'string' && review.task.trim()) || t
       for (const cf of Array.isArray(review.changedFiles) ? review.changedFiles : []) {
         const n = normalizeReviewChangedFile(cf)
-        if (n && wantSet.has(n) && !map.has(n)) map.set(n, taskId)
+        if (!n || !wantSet.has(n)) continue
+        // 多归属：同文件被多 task 声明时全收集（D-004@v1，坑④）——旧单归属在此吞掉后续 task
+        const list = map.get(n)
+        if (list) { if (!list.includes(taskId)) list.push(taskId) } else map.set(n, [taskId])
       }
     }
   }
@@ -2477,7 +2708,7 @@ function attributeSuspectTasks(runtimeRoot, changeName, paths) {
  *   status: 'ok'|'missing_declared'|'undeclared'|'skipped'|'degraded',
  *   matched: string[],                    // ①交集（唯一路径排序）
  *   missing: Array<{task: string, path: string, isNew?: boolean}>, // ②声明没做（isNew 标 NEW: 声明，剥前缀 path）
- *   undeclared: Array<{path: string, suspectTask?: string}>,       // ③做了没声明（suspectTask=review.json 尽力归因）
+ *   undeclared: Array<{path: string, suspectTask?: string}>,       // ③做了没声明（suspectTask=review.json 尽力归因，多归属 join('、') 后的 string）
  *   skipReason: string|null,              // skipped/degraded 的原因（其余状态为 null）
  *   notes: string[],                      // 跨仓卡剔除 / 并行 WIP 剔除等提示（additive）
  *   form: 'worktree'|'post-apply'|null,   // actual 形态（skipped 无 actual 时为 null；additive）
@@ -2499,8 +2730,24 @@ export function reconcileTargetFiles({ cwd, specBase = null, changeName = null,
 
   // —— 声明侧 ——
   const decl = collectDeclaredTargetFiles(sb, changeName)
-  for (const label of decl.crossRepoCards) {
-    notes.push(`跨仓 task 卡 ${label} 已剔除——跨仓对账不在本变更范围（D-004），其声明留待后续分期`)
+  // —— 跨仓 per-repo 对账（坑 cross-repo-reconcile-blindness，2026-09-15 复盘兑现 D-004 分期：
+  // 此前 22 个跨仓文件在归档表全标「计划未动」、跨仓全靠人工到对应仓解释）——advisory 不阻断：
+  // 锚点是各仓 HEAD~1..HEAD 最近提交窗口（多 task 同仓只反映最近一笔，锚点脆弱期会产②类假
+  // 信号），只报告不翻转主仓状态。结果经 crossRepo 字段（gates 渲染明细）与 notes（摘要随
+  // 各状态出口流动）双通道出口。
+  let crossRepo = []
+  if (decl.crossRepoCards.length > 0) {
+    try {
+      crossRepo = reconcileCrossRepoDeclarations({ specBase: sb, cwd, declarationsByRepo: decl.crossRepoDeclarations })
+    } catch { crossRepo = [] /* 跨仓对账异常不拖垮主仓链（advisory 定位） */ }
+    for (const label of decl.crossRepoCards) {
+      notes.push(`跨仓 task 卡 ${label} 不进主仓对账（主仓 actual 对不上跨仓声明，D-004）——其声明已转 per-repo 对账（见下方跨仓对账段）`)
+    }
+    for (const r of crossRepo) {
+      notes.push(r.degradedReason
+        ? `跨仓 ${r.repo}：${r.degradedReason}`
+        : `跨仓 ${r.repo} 对账：声明 ${r.declaredCount} / 实测 ${r.actualCount} / 对上 ${r.matched.length} / ②缺 ${r.missing.length} / ③多 ${r.undeclared.length}${r.scaffoldCount > 0 ? `（另有 ${r.scaffoldCount} 脚手架已聚合）` : ''}——advisory（锚点=该仓最近提交窗口）`)
+    }
   }
   if (decl.cardCount === 0) {
     return { status: 'skipped', matched, missing, undeclared,
@@ -2514,7 +2761,7 @@ export function reconcileTargetFiles({ cwd, specBase = null, changeName = null,
       && decl.noDeclarationCount === decl.cardCount - decl.crossRepoCards.length) {
       return { status: 'skipped', matched, missing, undeclared,
         skipReason: `严格模式变更（created_at ≥ IR_STRICT_SINCE）主仓 task 卡全部未声明 target_files（${decl.noDeclarationCount}/${decl.cardCount - decl.crossRepoCards.length} 张主仓卡${decl.crossRepoCards.length > 0 ? `，另 ${decl.crossRepoCards.length} 张跨仓卡已剔除` : ''}）`,
-        notes, form: null, sources: [],
+        notes, form: null, sources: [], crossRepo,
         strictViolation: {
           code: 'target_files_all_missing_strict',
           message: `严格模式要求每个主仓 task 卡声明 target_files（计划改动的文件清单，taskcard 骨架已预置字段）——逐卡 Edit 填入：已存在文件写仓根相对精确路径，新建文件加 NEW: 前缀；填毕重跑 --done（进度不丢）`,
@@ -2526,7 +2773,7 @@ export function reconcileTargetFiles({ cwd, specBase = null, changeName = null,
       : `所有 task 卡均未声明 target_files（${decl.noDeclarationCount}/${decl.cardCount} 张无声明` +
         `${decl.crossRepoCards.length > 0 ? `，另 ${decl.crossRepoCards.length} 张跨仓卡已剔除` : ''}）` +
         `——存量卡可忽略；新卡请补：每条为仓根相对精确文件路径，不存在的文件加 NEW: 前缀`
-    return { status: 'skipped', matched, missing, undeclared, skipReason: reason, notes, form: null, sources: [] }
+    return { status: 'skipped', matched, missing, undeclared, skipReason: reason, notes, form: null, sources: [], crossRepo }
   }
 
   // —— actual 侧（三源并集，两形态）——
@@ -2538,7 +2785,7 @@ export function reconcileTargetFiles({ cwd, specBase = null, changeName = null,
     // 降级（fail-soft 不误红）：git 全部不可用 → actual 不可得，不产生 missing/undeclared
     return { status: 'degraded', matched, missing, undeclared,
       skipReason: `git 全部不可用，actual 不可得，对账降级跳过——${actual.degradedReason}`,
-      notes, form: actual.form, sources: actual.sources }
+      notes, form: actual.form, sources: actual.sources, crossRepo }
   }
 
   // —— 三类差集 ——
@@ -2567,17 +2814,36 @@ export function reconcileTargetFiles({ cwd, specBase = null, changeName = null,
       missing.push(d.isNew ? { task: d.task, path: d.path, isNew: true } : { task: d.task, path: d.path })
     }
   }
-  // ③做了没声明（scope creep，WARNING）：actual − 声明集；suspectTask 尽力归因仅报告（D-002）
+  // ③做了没声明（scope creep，WARNING）：actual − 声明集；suspectTask 尽力归因仅报告（D-002）。
+  // 归因多归属（attributeSuspectTasks 返 string[]，坑④）：组装边界 join('、') 成 string——
+  // gates.js / archive-delta.js 等下游渲染零改动（suspectTask 对外形态保持 string）。
   const suspect = attributeSuspectTasks(rt, changeName, actual.files.filter(p => !declaredKeySet.has(pathKey(p))))
+  // 脚手架软桶（坑 reconcile-undeclared-scaffold-flood，2026-09-15 复盘实证：worktree baseline
+  // 拷入的 .claude/skills、attachments 等设施文件 58 条逐条进③类、每轮 verify 重复刷屏）：
+  // classifyToolScaffold（worktree-apply / scope-audit 同款口径）命中的工具/平台设施文件聚合
+  // 为一行 note——环境设施面非交付物，逐条列③类只会淹没真 scope creep。全为脚手架时③类
+  // 判 ok（脚手架不构成 scope creep 语义）。
+  const scaffoldBuckets = { platform: 0, tool: 0 }
+  const scaffoldSamples = []
   for (const path of actual.files) {
     if (declaredKeySet.has(pathKey(path))) continue
+    const bucket = classifyToolScaffold(path)
+    if (bucket) {
+      scaffoldBuckets[bucket] = (scaffoldBuckets[bucket] || 0) + 1
+      if (scaffoldSamples.length < 5) scaffoldSamples.push(path)
+      continue
+    }
     const s = suspect.get(normalizeReviewChangedFile(path))
-    undeclared.push(s ? { path, suspectTask: s } : { path })
+    undeclared.push(Array.isArray(s) && s.length > 0 ? { path, suspectTask: s.join('、') } : { path })
+  }
+  const scaffoldTotal = scaffoldBuckets.platform + scaffoldBuckets.tool
+  if (scaffoldTotal > 0) {
+    notes.push(`③类另有 ${scaffoldTotal} 个工具/平台脚手架文件（platform ${scaffoldBuckets.platform} / tool ${scaffoldBuckets.tool}，如 ${scaffoldSamples.join('、')}${scaffoldTotal > scaffoldSamples.length ? ' 等' : ''}）已聚合不逐条列——非交付物（scope-audit 设施桶同口径）`)
   }
 
   // 状态聚合：②在场即 ERROR 态优先（gates 阻断语义靠它兑现）；仅③ → WARNING 态
   const status = missing.length > 0 ? 'missing_declared' : (undeclared.length > 0 ? 'undeclared' : 'ok')
-  return { status, matched, missing, undeclared, skipReason: null, notes, form: actual.form, sources: actual.sources }
+  return { status, matched, missing, undeclared, undeclaredScaffold: scaffoldTotal, skipReason: null, notes, form: actual.form, sources: actual.sources, crossRepo }
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -2613,6 +2879,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 补写内容天然落在本子节定界之外，其
@@ -2643,27 +2924,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),
@@ -2671,6 +2965,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),
   }
 }
 
@@ -2719,7 +3016,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' →
@@ -2740,7 +3043,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
  * }}
  */
@@ -2856,6 +3159,37 @@ 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 刷新预填段' })
+  }
+
   // —— facts 基线对比（2026-09-08-ir-verify-facts FR-05 / task-05）：重跑指标 vs
   // verify-facts.json probes 快照（init 时点）。md 锚点对账查「正文没被改」，本维度查
   // 「md 被手改对齐新代码后 facts 底稿过期」（P3d 数据源保鲜）。分级沿用现实现口径：
@@ -2888,8 +3222,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,
     }