sillyspec 3.28.2 → 3.28.4

package/src/verify-postcheck.js

@@ -23,8 +23,9 @@
  */
 
 import { execSync, spawnSync } from 'child_process'
+import { IR_STRICT_SINCE } from './constants.js'
 import { gitQuiet } from './git-helper.js'
-import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'fs'
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync } from 'fs'
 import { join } from 'path'
 import { verifyApiParity } from './contract-matrix.js'
 import { parseFileChangeListDetailed, pathMatches } from './change-list.js'
@@ -36,10 +37,30 @@ import { parseTargetFiles, parseRepo } from './stages/plan-postcheck.js'
 // fs/path/git-helper/change-list/plan-postcheck/contract-matrix/foreign-declared/run-shared，
 // 不反向依赖本模块，此处直连不引入循环
 import { runVerifyProbes } from './verify-probes.js'
+import { parseEvidenceSlots, classifyVerifiedFile } from './verify-facts-schema.js'
 
 // 测试命令最长执行时间；超时视为失败（防止 CLI 被挂起的测试卡死）
 const TEST_TIMEOUT_MS = Number(process.env.SILLYSPEC_TEST_TIMEOUT_MS) || 10 * 60 * 1000
 const OUTPUT_TAIL_CHARS = 4000
+// 判账失败行台账上限（坑 verify-test-reconcile-tail-blindspot）：对账按完整输出判、tail 只存
+// 末 4000 字符 → 失败行落在盲区时只剩 reason 里 5 行×120 字符采样，归因必须全量复跑。修法是
+// 判账行集（remaining/exempted 全量原文）随结果透传落盘/打印；台账只防病态体量——单行截
+// 300 字符、行数截 200，超出注明计数。judge 判账仍用全量行集，不受此截断影响。
+const FAILURE_LEDGER_MAX_LINES = 200
+const FAILURE_LEDGER_MAX_CHARS = 300
+
+/** 失败行台账截断（落盘/展示用；判账本身不受影响）。export 供 test 验证截断语义 */
+export function capFailureLedger(lines) {
+  if (!Array.isArray(lines) || lines.length === 0) return []
+  const out = lines.slice(0, FAILURE_LEDGER_MAX_LINES).map(l => {
+    const s = String(l)
+    return s.length > FAILURE_LEDGER_MAX_CHARS ? s.slice(0, FAILURE_LEDGER_MAX_CHARS) + '…' : s
+  })
+  if (lines.length > FAILURE_LEDGER_MAX_LINES) {
+    out.push(`…（共 ${lines.length} 行，仅列前 ${FAILURE_LEDGER_MAX_LINES} 行；判账按全量行集不受此截断影响）`)
+  }
+  return out
+}
 
 /**
  * 行尾归一（坑 verify-modules-crlf-blanket-fallback，2026-08-20 实证）：Windows 仓的
@@ -95,6 +116,36 @@ function extractLintCommand(yamlText) {
   return null
 }
 
+/**
+ * lint advisory 观察期计数（刀③，2026-09-08）：advisory 失败不阻断，但「观察期后升级硬门」
+ * 需要失败率数据支撑（更硬 vs 更吵的决策依据——硬门误伤纯文档/跨平台路径会制造新噪音）。
+ * 每次非 skipped 实测追加计数进 <specBase>/.runtime/verify-lint-tally.json（passed/failed
+ * 都记，分母同要）；history 截尾 20 条。写失败静默降级——计数器不许反向阻断 verify。
+ */
+function recordVerifyLintTally({ specBase, result }) {
+  try {
+    const runtimeDir = join(specBase, '.runtime')
+    mkdirSync(runtimeDir, { recursive: true })
+    const tallyPath = join(runtimeDir, 'verify-lint-tally.json')
+    let tally = { totalRuns: 0, failedRuns: 0, history: [] }
+    try {
+      tally = { ...tally, ...JSON.parse(readFileSync(tallyPath, 'utf8')) }
+    } catch { /* 首跑/文件损坏 → 重置重新累计 */ }
+    tally.totalRuns += 1
+    if (result.status === 'failed') tally.failedRuns += 1
+    tally.lastRunAt = new Date().toISOString()
+    tally.lastStatus = result.status
+    tally.history = [
+      ...(Array.isArray(tally.history) ? tally.history : []),
+      { at: tally.lastRunAt, status: result.status, reason: result.reason || null },
+    ].slice(-20)
+    writeFileSync(tallyPath, JSON.stringify(tally, null, 2))
+    return { failedRuns: tally.failedRuns, totalRuns: tally.totalRuns }
+  } catch {
+    return null
+  }
+}
+
 /**
  * verify --done 实测跑 local.yaml commands.lint（2026-08-21 审查 CLI-1）。
  * 此前 lint 全靠 agent 自跑自报（"我跑过 lint 了"纯口头），与 test 侧的对账不对称——
@@ -142,18 +193,36 @@ export function runVerifyLintCheck({ cwd, specBase }) {
   }
   const durationMs = Date.now() - startedAt
   const outputTail = output.length > OUTPUT_TAIL_CHARS ? '…' + output.slice(-OUTPUT_TAIL_CHARS) : output
+  const status = exitCode === 0 ? 'passed' : 'failed'
+  const finalReason = exitCode === 0 ? null : reason
+  const tally = recordVerifyLintTally({ specBase, result: { status, reason: finalReason } })
 
   return {
-    status: exitCode === 0 ? 'passed' : 'failed',
+    status,
     command,
     exitCode,
     durationMs,
     outputTail,
-    reason: exitCode === 0 ? null : reason,
+    reason: finalReason,
+    tally, // { failedRuns, totalRuns } | null——观察期失败率，升级硬门的决策依据
   }
 }
 
-/** 打印 lint 实测结果（advisory：失败不阻断，只把口头汇报对上账） */
+/**
+ * lint 硬门决策（2026-09-09 升硬，外部数据驱动）：观察期 tally 14 次 5 败全真阳性零误伤，
+ * 且 pre-push 钩子本就硬拦——verify 侧硬门只是同一标准 fail-fast 前移。
+ * 逃生档：SILLYSPEC_VERIFY_LINT_GATE=advisory（审计留痕，对齐 quick 门 skip env 先例）。
+ * @returns {boolean} failed 且非逃生档 → true（调用方 rollback）
+ */
+export function shouldBlockVerifyLint(lintCheck, env = process.env) {
+  if (!lintCheck || lintCheck.status !== 'failed') return false
+  return env.SILLYSPEC_VERIFY_LINT_GATE !== 'advisory'
+}
+
+/**
+ * 打印 lint 实测结果（2026-09-09 起按 shouldBlockVerifyLint 分支）：硬门档「已阻断」+
+ * 逃生 env 指引（rollback 由 gates 接线侧执行）；advisory 档保留旧观察期措辞。
+ */
 export function printVerifyLintCheck(result) {
   if (result.status === 'skipped') {
     console.warn(`\n⚠️  Verify lint 实测跳过：${result.reason}`)
@@ -163,8 +232,22 @@ export function printVerifyLintCheck(result) {
     console.log(`\n✅ Verify lint 实测通过：\`${result.command}\` 退出码 0（${(result.durationMs / 1000).toFixed(1)}s）`)
     return
   }
-  console.error(`\n⚠️  Verify lint 实测失败（advisory，不阻断本次完成）：\`${result.command}\` — ${result.reason}`)
-  console.error('   agent 的 lint 自报告与实测不符时以实测为准；请修复后重跑，避免格式债推迟到 commit 被 pre-commit hook 拦截。')
+  // 文案随门禁档位分支（2026-09-09 复核修正 P2：硬门档下旧「不阻断/观察期」措辞与
+  // gates 的 rollback 行为打架，agent 会误判 CLI 抽风）——rollback 本体在 gates 接线侧。
+  if (shouldBlockVerifyLint(result)) {
+    console.error(`\n❌ Verify lint 实测失败——verify 完成已阻断（2026-09-09 起硬门）：\`${result.command}\` — ${result.reason}`)
+    console.error('   agent 的 lint 自报告与实测不符时以实测为准；修复后重跑 --done（进度不丢）。')
+    if (result.tally) {
+      console.error(`   📊 累计 ${result.tally.failedRuns}/${result.tally.totalRuns} 次（.runtime/verify-lint-tally.json）。`)
+    }
+    console.error('   确认要跳过实测：SILLYSPEC_VERIFY_LINT_GATE=advisory（审计留痕）。')
+  } else {
+    console.error(`\n⚠️  Verify lint 实测失败（advisory 档，不阻断本次完成）：\`${result.command}\` — ${result.reason}`)
+    console.error('   agent 的 lint 自报告与实测不符时以实测为准；请修复后重跑，避免格式债推迟到 commit 被 pre-commit hook 拦截。')
+    if (result.tally) {
+      console.error(`   📊 lint advisory 失败累计 ${result.tally.failedRuns}/${result.tally.totalRuns} 次（数据落 .runtime/verify-lint-tally.json）。`)
+    }
+  }
   if (result.outputTail) {
     const tail = result.outputTail.split('\n').slice(-15).join('\n')
     console.error('   输出（末尾）：')
@@ -586,24 +669,37 @@ export function extractKnownFailures(yamlText) {
   if (inline) {
     return inline[1].split(',').map(s => s.trim().replace(/^['"]|['"]$/g, '')).filter(Boolean)
   }
-  // 坑 verify-known-failures-comment-line-truncation（2026-08-28 连续踩两次）：块内注释行/空行
-  // 打断「连续列表项」的捕获链 → 只取到注释前的项，注释后的项静默丢失 → 清单残缺、
-  // verify 实测 remaining>0 假红。块定义放行注释行与空行（提取侧本就只认 `- ` 项行，
-  // 吸收进块的注释不影响结果）。
-  const block = yaml.match(/^known_failures:\s*\n((?:[ \t]+-[ \t].+\n?|[ \t]*#[^\n]*\n?|[ \t]*\n)+)/m)
-  if (block) {
-    return (block[1].match(/^[ \t]+-[ \t]+(.+)/gm) || [])
-      .map(s => {
-        const item = s.replace(/^[ \t]+-[ \t]+/, '').trim()
-        const full = item.match(/^(['"])(.*)\1$/)
-        if (full) return full[2] // 整体引号值原样保留（内部 # 不是注释）
-        const stripped = item.replace(/[ \t]+#.*$/, '').trim() // 行尾注释须 # 前有空白（YAML 语义），裸 # 不截
-        const q2 = stripped.match(/^(['"])(.*)\1$/)
-        return q2 ? q2[2] : stripped
-      })
-      .filter(Boolean)
-  }
-  return []
+  // 坑 verify-known-failures-comment-line-truncation（2026-08-28 连续踩两次）→ 坑
+  // verify-known-failures-block-fragile-chain（2026-09-07 工具复盘升级修复）：块式捕获曾要求
+  // 「- 项行 / 注释行 / 空行」**连续成链**（(...)+），任何一行不合形态——手改残留的缩进杂行、
+  // 空项 `  -`、误删半截的段残迹——链条即断，其后所有条目**静默丢失**（实证形态：G/H 注释段
+  // 踩着 F 段残迹重写，F 段遗留行断链 → G/H 条目全丢 → 清单残缺 → verify 假红，且丢得多静默
+  // 就多难归因）。改为逐行扫描：块 = known_failures: 头之后连续的「缩进行 / 注释行（任意缩进，
+  // 含列首）/ 空行」，首个列首正文行收块；块内杂行一律容忍，`- ` 项行无论隔着什么都提取——
+  // 只有 YAML 本就不合法的形态（列首裸 `- 项`）才不取，不再因断链静默丢项。
+  const lines = yaml.split('\n')
+  const headIdx = lines.findIndex(l => /^known_failures:\s*(?:#.*)?$/.test(l))
+  if (headIdx === -1) return []
+  const itemRe = /^[ \t]+-[ \t]+(.+)$/
+  const items = []
+  for (let i = headIdx + 1; i < lines.length; i++) {
+    const l = lines[i]
+    if (l.trim() === '') continue // 空行：块内分隔，放行
+    if (/^[ \t]*#/.test(l)) continue // 注释行（任意缩进含列首）：段头/归因注记，放行
+    if (!/^[ \t]/.test(l)) break // 列首正文行：下一个顶层键，收块
+    const m = l.match(itemRe) // 其余缩进行一律留在块内；项行才提取（杂行不提取但不断链）
+    if (m) items.push(m[1])
+  }
+  return items
+    .map(s => {
+      const item = s.trim()
+      const full = item.match(/^(['"])(.*)\1$/)
+      if (full) return full[2] // 整体引号值原样保留（内部 # 不是注释）
+      const stripped = item.replace(/[ \t]+#.*$/, '').trim() // 行尾注释须 # 前有空白（YAML 语义），裸 # 不截
+      const q2 = stripped.match(/^(['"])(.*)\1$/)
+      return q2 ? q2[2] : stripped
+    })
+    .filter(Boolean)
 }
 
 // 单条失败行标记（跨 pytest/jest/vitest/go/generic）。大小写不敏感。
@@ -698,11 +794,15 @@ export function partitionFailures(output, knownFailures) {
     if (ENV_NOISE_RE.test(bare)) continue
     if (PER_TEST_FAIL_RE.test(bare) && !SUMMARY_LINE_RE.test(bare)) failureLines.push(l)
   }
-  const pats = (knownFailures || []).map(p => String(p).toLowerCase()).filter(Boolean)
+  // 豁免匹配同样在剥 ANSI 后的行上做（坑 verify-known-failures-ansi-exemption-split，2026-09-07
+  // 工具复盘）：TTY 捕获的失败行里色码把可见词拦腰拆开（`× \x1b[31mtests/foo.test.ts\x1b[0m > case`
+  // 连不成 `tests/foo.test.ts > case`），同一行被迫拆成两段各配一条模式才能豁免。模式侧同步剥
+  // ANSI（从原始输出誊抄来的模式可能自带码）；返回仍保留原文（remaining/exempted 展示不变形）。
+  const pats = (knownFailures || []).map(p => String(p).replace(ANSI_RE, '').toLowerCase()).filter(Boolean)
   const exempted = []
   const remaining = []
   for (const l of failureLines) {
-    const ll = l.toLowerCase()
+    const ll = l.replace(ANSI_RE, '').toLowerCase()
     if (pats.some(p => ll.includes(p))) exempted.push(l)
     else remaining.push(l)
   }
@@ -718,19 +818,28 @@ export function partitionFailures(output, knownFailures) {
  *       有未豁免失败行 / 检测不到失败行（保守）→ failed
  * fail-safe：检测不到失败行绝不自动 pass（避免解析盲区导致假 PASS）。
  *
- * @returns {{ status: 'passed'|'failed', reason: string|null, exemptedCount: number }}
+ * 判账行集全量随结果返回（坑 verify-test-reconcile-tail-blindspot）：对账按完整输出判，但
+ * outputTail 只留末 OUTPUT_TAIL_CHARS 字符——失败行落在盲区时 reason 采样不足以归因，只能
+ * 全量复跑。remainingLines/exemptedLines（全量原文行）由调用方透传到 test-result.json 与
+ * 控制台明细，盲区归因不再依赖复跑；passed 分支同样带 exemptedLines（豁免披露复核需要）。
+ *
+ * @returns {{ status: 'passed'|'failed', reason: string|null, exemptedCount: number,
+ *             remainingLines: string[], exemptedLines: string[] }}
  */
 export function judgeWithKnownFailures(exitCode, output, baseReason, knownFailures) {
-  if (exitCode === 0) return { status: 'passed', reason: baseReason, exemptedCount: 0 }
+  if (exitCode === 0) return { status: 'passed', reason: baseReason, exemptedCount: 0, remainingLines: [], exemptedLines: [] }
+  const { failureLines, exempted, remaining } = partitionFailures(output, knownFailures || [])
   if (!knownFailures || knownFailures.length === 0) {
-    return { status: 'failed', reason: baseReason, exemptedCount: 0 }
+    // 无清单分支同样带行集：豁免与否都不该丢判账依据（tail 盲区归因同权）
+    return { status: 'failed', reason: baseReason, exemptedCount: 0, remainingLines: remaining, exemptedLines: [] }
   }
-  const { failureLines, exempted, remaining } = partitionFailures(output, knownFailures)
   if (failureLines.length > 0 && remaining.length === 0) {
     return {
       status: 'passed',
       reason: `全部 ${failureLines.length} 个失败行命中 known_failures 已豁免（${exempted.length} 条）— 请人工复核豁免清单是否过宽`,
       exemptedCount: exempted.length,
+      remainingLines: [],
+      exemptedLines: exempted,
     }
   }
   // 剩余未豁免失败行：列出具体行 + 预存债指引（坑 verify-known-failures-stale-list）。
@@ -742,7 +851,9 @@ export function judgeWithKnownFailures(exitCode, output, baseReason, knownFailur
       const t = String(l).trim()
       return t.length > 120 ? t.slice(0, 120) + '…' : t
     })
-    const more = remaining.length > 5 ? `\n     …（其余 ${remaining.length - 5} 行见上方测试输出）` : ''
+    // 指针改指台账（坑 verify-test-reconcile-tail-blindspot）：原「见上方测试输出」只对 tail
+    // 窗口内的行成立，盲区行必须指向完整台账（控制台明细段 + test-result.json 的 failure_remaining）
+    const more = remaining.length > 5 ? `\n     …（其余 ${remaining.length - 5} 行完整清单见下方「未豁免失败行」明细，已全量落盘 test-result.json 的 failure_remaining——不受输出 tail 截断影响）` : ''
     detail = `${remaining.length} 个失败行未命中 known_failures 清单：\n     - ${sample.join('\n     - ')}${more}\n   → 若是预存债（变更前就失败），加入 local.yaml 的 known_failures 清单；若是本次变更引入的真实失败，请修复`
   } else {
     detail = '失败输出未检测到可豁免的失败行（保守判 fail）'
@@ -751,6 +862,8 @@ export function judgeWithKnownFailures(exitCode, output, baseReason, knownFailur
     status: 'failed',
     reason: baseReason ? `${baseReason}（${detail}）` : detail,
     exemptedCount: exempted.length,
+    remainingLines: remaining,
+    exemptedLines: exempted,
   }
 }
 
@@ -814,6 +927,8 @@ function runOneModule(name, testCommand, cwd, knownFailures = []) {
     outputTail,
     reason: judged.reason,
     exemptedCount: judged.exemptedCount,
+    failureRemaining: judged.remainingLines,
+    failureExempted: judged.exemptedLines,
   }
 }
 
@@ -1062,6 +1177,13 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
 
   const rawStrategy = extractTestStrategy(yamlText)
   const knownFailures = extractKnownFailures(yamlText)
+  if (knownFailures.length > 0) {
+    // 豁免清单加载可见性（坑 verify-known-failures-block-fragile-chain 的观测面）：条数即时报出
+    // ——清单被块内残迹截断/误删段时「N 条」与预期不符一眼可见，不必等假红再反推。
+    // 走 stderr（console.warn）：本模块运行期叙述统一不碰 stdout（machine-interface 调用时
+    // stdout 留给机器可读输出）
+    console.warn(`📋 known_failures 豁免清单已加载：${knownFailures.length} 条模式（local.yaml）`)
+  }
 
   // —— evidence-auto 生效策略解析（D-005@v2 / task-11）——
   // 按变更目录 module-impact.md 影响面取生效策略（行为→module、纯文档/门禁→skip、
@@ -1304,6 +1426,8 @@ function runCrossRepoFullTest(entry) {
     mode: 'cross-repo-full',
     repoKey: entry.repoKey,
     exemptedCount: judged.exemptedCount,
+    failureRemaining: judged.remainingLines,
+    failureExempted: judged.exemptedLines,
   }
 }
 
@@ -1327,6 +1451,9 @@ function mergeResultStatus({ status, mainResult, crossResults, reason }) {
     resultPath: mainResult.resultPath,
     mode: 'cross-repo-merged',
     fallbackReason: mainResult.fallbackReason || null,
+    // 判账行集跨仓合并（坑 verify-test-reconcile-tail-blindspot）：mergedTail 截断不影响台账
+    failureRemaining: [...(mainResult.failureRemaining || []), ...crossResults.flatMap(r => r.result.failureRemaining || [])],
+    failureExempted: [...(mainResult.failureExempted || []), ...crossResults.flatMap(r => r.result.failureExempted || [])],
   }
 }
 
@@ -1457,6 +1584,8 @@ function runFullCommand({ yamlText, localYamlPath, cwd, specBase, changeName, fa
     mode: 'full',
     fallbackReason,
     exemptedCount: judged.exemptedCount,
+    failureRemaining: judged.remainingLines,
+    failureExempted: judged.exemptedLines,
   }
 
   writeRunResult({ specBase, changeName, result, extra: fallbackReason ? { fallback_reason: fallbackReason } : {} })
@@ -1500,6 +1629,10 @@ function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [] }
     mode: 'module-subset',
     fallbackReason: null,
     exemptedCount: perModule.reduce((n, r) => n + (r.exemptedCount || 0), 0),
+    // 判账行集聚合（坑 verify-test-reconcile-tail-blindspot）：合并 tail 会二次截断，行集不截——
+    // 每模块台账另见 extra.modules[].failure_remaining（带模块归属）
+    failureRemaining: perModule.flatMap(r => r.failureRemaining || []),
+    failureExempted: perModule.flatMap(r => r.failureExempted || []),
   }
 
   writeRunResult({
@@ -1515,6 +1648,8 @@ function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [] }
         duration_ms: r.durationMs,
         output_tail: r.outputTail,
         reason: r.reason,
+        ...(r.failureRemaining && r.failureRemaining.length ? { failure_remaining: capFailureLedger(r.failureRemaining) } : {}),
+        ...(r.failureExempted && r.failureExempted.length ? { failure_exempted: capFailureLedger(r.failureExempted) } : {}),
       })),
     },
   })
@@ -1523,9 +1658,9 @@ function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [] }
 
 /**
  * 结果落盘到 .runtime/verify-runs/<ts>/test-result.json（供追溯与 SillyHub 消费）。
- * 多模块时 extra.modules 描述各模块明细。
+ * 多模块时 extra.modules 描述各模块明细。export 供 test 验证台账落盘形状。
  */
-function writeRunResult({ specBase, changeName, result, extra = {} }) {
+export function writeRunResult({ specBase, changeName, result, extra = {} }) {
   try {
     const ts = new Date().toISOString().slice(0, 19).replace(/[-T:]/g, '')
     const runDir = join(specBase, '.runtime', 'verify-runs', ts)
@@ -1538,11 +1673,19 @@ function writeRunResult({ specBase, changeName, result, extra = {} }) {
       status: result.status,
       duration_ms: result.durationMs,
       output_tail: result.outputTail,
+      // 判账失败行台账（坑 verify-test-reconcile-tail-blindspot）：按完整输出判账的行集全量
+      // 落盘（受 capFailureLedger 防病态体量截断）——失败行落在 output_tail 盲区时归因读这里，
+      // 不再需要全量复跑。空集不落键（成功/跳过运行不添噪声）。
+      ...(result.failureRemaining && result.failureRemaining.length ? { failure_remaining: capFailureLedger(result.failureRemaining) } : {}),
+      ...(result.failureExempted && result.failureExempted.length ? { failure_exempted: capFailureLedger(result.failureExempted) } : {}),
       reason: result.reason,
       ran_at: new Date().toISOString(),
       ...extra,
     }, null, 2) + '\n')
     result.resultPath = resultPath
+    // verify-runs 回收不在此处（ql-20260908-005 已定分野）：变更归属类证据走归档时精确
+    // 回收（pruneArchivedChangeRuntime 按目录内 JSON change 字段归属）；写入侧滚动是
+    // 启发式，不进证据类目录。
   } catch (e) {
     console.warn(`⚠️  verify 实测结果落盘失败: ${e.message}`)
   }
@@ -1565,11 +1708,30 @@ export function printVerifyTestCheck(result) {
     if (result.exemptedCount > 0) {
       console.log(`\n✅ Verify 实测通过（含 ${result.exemptedCount} 个 known_failures 豁免）：\`${result.command}\` — ${result.reason}`)
       console.warn('   ⚠️  本次 PASS 依赖 known_failures 豁免清单——请人工复核清单是否过宽（避免误豁免本变更引入的真实失败）。')
+      // 豁免披露明细（坑 verify-test-reconcile-tail-blindspot）：被豁免的失败行同样可能落在
+      // tail 盲区——复核"清单是否过宽"不能只看 tail。前 10 条样例进控制台，全量台账在
+      // test-result.json 的 failure_exempted。
+      if (result.failureExempted && result.failureExempted.length) {
+        console.warn(`   已豁免失败行（共 ${result.failureExempted.length} 行，前 10 条；全量见 test-result.json 的 failure_exempted）：`)
+        for (const line of capFailureLedger(result.failureExempted).slice(0, 10)) console.warn(`   ~ ${line}`)
+      }
     } else {
       console.log(`\n✅ Verify 实测通过：\`${result.command}\` 退出码 0（${(result.durationMs / 1000).toFixed(1)}s）`)
     }
   } else {
     console.error(`\n❌ Verify 实测失败：\`${result.command}\` — ${result.reason}`)
+    // 未豁免失败行台账（坑 verify-test-reconcile-tail-blindspot）：判账按完整输出、下方 tail
+    // 只留末段——失败行落在盲区时 tail 里看不到，归因靠本段全量行集（≤30 条样例进控制台，
+    // 全量落盘 failure_remaining），不再需要全量复跑定位。
+    if (result.failureRemaining && result.failureRemaining.length) {
+      const ledger = capFailureLedger(result.failureRemaining)
+      const shown = ledger.slice(0, 30)
+      console.error(`   未豁免失败行（按完整输出判账，不受 tail 截断影响；共 ${result.failureRemaining.length} 行）：`)
+      for (const line of shown) console.error(`   ! ${line}`)
+      if (ledger.length > shown.length) {
+        console.error(`   ! …（其余 ${ledger.length - shown.length} 行全量见 test-result.json 的 failure_remaining）`)
+      }
+    }
     if (result.outputTail) {
       const tail = result.outputTail.split('\n').slice(-20).join('\n')
       console.error('   输出（末尾）：')
@@ -1781,7 +1943,7 @@ export function printVerifyDeletionCheck(result) {
  * @param {{cwd:string, specBase:string, changeName?:string}} args
  * @returns {{status:'skipped'|'passed'|'warning', items:Array, unacknowledged:Array, summary:string, reason:string|null}}
  */
-export function runVerifyRequiredEvidenceCheck({ cwd, specBase, changeName = null }) {
+export function runVerifyRequiredEvidenceCheck({ cwd, specBase, changeName = null, verifyStartAt = null }) {
   if (!changeName) {
     return { status: 'skipped', items: [], unacknowledged: [], summary: '', reason: '无 changeName（quick 等无关联变更场景），evidence 对账跳过' }
   }
@@ -1802,6 +1964,13 @@ export function runVerifyRequiredEvidenceCheck({ cwd, specBase, changeName = nul
   const verifyResultPath = join(specBase, 'changes', changeName, 'verify-result.md')
   const report = existsSync(verifyResultPath) ? readFileSync(verifyResultPath, 'utf8') : ''
 
+  // ── v2 槽优先（2026-09-08-ir-verify-facts FR-02）：「## 证据账」槽段在场走分类核验；
+  // 无槽（存量）降级 legacy 子串提及对账——行为等同旧版（D-001@v2，warning 不阻断）。──
+  const slots = parseEvidenceSlots(report)
+  if (slots.hasEvidenceSlot) {
+    return runRequiredEvidenceCheckV2({ items, slots, cwd, specBase, changeName, verifyStartAt })
+  }
+
   const unacknowledged = []
   for (const item of items) {
     const task = item && item.task
@@ -1816,16 +1985,115 @@ export function runVerifyRequiredEvidenceCheck({ cwd, specBase, changeName = nul
   }
 
   if (unacknowledged.length > 0) {
-    return { status: 'warning', items, unacknowledged,
+    return { status: 'warning', items, unacknowledged, legacy: true,
       summary: `${items.length} 个 cannot_verify evidence 任务中 ${unacknowledged.length} 个未在 verify-result.md 体现`, reason: null }
   }
-  return { status: 'passed', items, unacknowledged: [],
+  return { status: 'passed', items, unacknowledged: [], legacy: true,
     summary: `${items.length} 个 cannot_verify evidence 任务均在 verify-result.md 体现（满足度由 agent 自报告）`, reason: null }
 }
 
-/** 打印 required-evidence 对账结果（advisory，不阻断 verify 完成） */
+/**
+ * v2 分类核验（design Phase 2，FR-02）：证据账槽行状态 + verifiedFiles 逐文件核验。
+ * code 类（classifyVerifiedFile）：存在 × mtime ≥ verifyStartAt × git diff 交集三核验；
+ * artifact 类（.runtime/日志/文档）：存在 × mtime（diff 交集豁免——resolveVerifyChangedFiles
+ * 天然不覆盖该类路径，硬要求交集必假红）。verifyStartAt 缺省走 R-05 fallback（design.md
+ * created_at 之后宽容 + warning）。status 语义扩 'blocked'（missing 无豁免 / satisfied 核验
+ * 不过）——gates 接线（task-03）据此阻断 verify 完成。
+ */
+function runRequiredEvidenceCheckV2({ items, slots, cwd, specBase, changeName, verifyStartAt }) {
+  const warnings = []
+  let startAt = verifyStartAt ? new Date(verifyStartAt).getTime() : null
+  if (!startAt) {
+    // R-05 fallback：DB 不可得/接线间隙（W2→W3）——design.md created_at 之后即宽容
+    try {
+      const designPath = join(specBase, 'changes', changeName, 'design.md')
+      if (existsSync(designPath)) {
+        const fm = readFileSync(designPath, 'utf8').match(/^---\r?\n([\s\S]*?)\r?\n---/)
+        const cm = fm && fm[1].match(/^created_at:\s*(.+)$/m)
+        if (cm) {
+          const t = new Date(cm[1].trim()).getTime()
+          if (!Number.isNaN(t)) { startAt = t; warnings.push('verifyStartAt 未提供，走 design.md created_at 宽容基准（R-05 fallback）') }
+        }
+      }
+    } catch { /* fallback 的 fallback：不设基准（只核存在性） */ }
+    if (!startAt) warnings.push('verifyStartAt 与 design created_at 均不可得——mtime 核验降级为仅存在性')
+  }
+
+  // git diff 集合（code 类交集核验用；fail-soft 拿不到 → diffHit 记 null 不判红）
+  let changedSet = null
+  try {
+    const changed = resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true, specBase })
+    changedSet = new Set((changed || []).map(p => String(p).replace(/\\/g, '/')))
+  } catch { changedSet = null }
+
+  const detailed = []
+  let blockedCount = 0
+  for (const item of items) {
+    const task = item && item.task
+    if (!task) continue
+    const slot = slots.requiredEvidence.find(e => e.task === task) || null
+    if (!slot) {
+      detailed.push({ task, verdict: item.verdict || 'cannot_verify', status: 'missing', exempt: false,
+        verification: null, reason: `cannot_verify 任务 ${task} 未在证据账槽段登记（逐 task 一行：状态三选一 + verifiedFiles）` })
+      blockedCount++
+      continue
+    }
+    const perFile = []
+    let allOk = true
+    if (slot.status === 'satisfied' || slot.status === 'partial') {
+      if (slot.verifiedFiles.length === 0) {
+        allOk = false
+        perFile.push({ path: null, pathClass: null, filesExist: false, mtimeOk: null, diffHit: null,
+          reason: `${slot.status} 但 verifiedFiles 为空（精确路径必填）` })
+      }
+      for (const vf of slot.verifiedFiles) {
+        const pathClass = classifyVerifiedFile(vf)
+        const abs = join(cwd, vf)
+        const filesExist = existsSync(abs)
+        let mtimeOk = null
+        if (filesExist && startAt) {
+          try { mtimeOk = statSync(abs).mtimeMs >= startAt - 60_000 } catch { mtimeOk = null }
+        }
+        let diffHit = null
+        if (pathClass === 'code') {
+          diffHit = changedSet === null ? null : changedSet.has(vf)
+        } else {
+          diffHit = true // artifact 类豁免 diff（design Phase 2：日志/文档天然不在 diff）
+        }
+        const ok = filesExist && mtimeOk !== false && diffHit !== false
+        if (!ok) allOk = false
+        perFile.push({ path: vf, pathClass, filesExist, mtimeOk, diffHit,
+          reason: !filesExist ? '文件不存在'
+            : (mtimeOk === false ? `mtime 早于 verifyStartAt（${new Date(startAt).toISOString()}）`
+            : (diffHit === false ? '不在本变更 git diff 内' : null)) })
+      }
+    }
+    const failed = (slot.status === 'satisfied' && !allOk) || (slot.status === 'missing' && !slot.exempt)
+    if (failed) blockedCount++
+    detailed.push({
+      task, verdict: item.verdict || 'cannot_verify', status: slot.status, exempt: slot.exempt,
+      verification: perFile.length > 0 ? perFile : null,
+      reason: failed
+        ? (slot.status === 'missing' ? 'missing 且无（豁免：<理由>）后缀——cannot_verify 未闭环'
+          : (slot.status === 'satisfied' ? 'satisfied 核验不过（见 verification 明细）' : 'partial 但 verifiedFiles 全部核验不过'))
+        : (slot.exempt ? `missing 已豁免：${slot.exemptionReason}`
+          : (slot.status === 'partial' ? 'partial（部分核验通过，理由见槽行括注）' : '核验通过')),
+    })
+  }
+
+  if (blockedCount > 0) {
+    return { status: 'blocked', items, detailed, warnings,
+      unacknowledged: detailed.filter(d => d.status === 'missing' && !d.exempt && !d.verification).map(d => ({ task: d.task, reason: d.reason })),
+      summary: `${items.length} 个 cannot_verify 任务中 ${blockedCount} 个未闭环（missing 无豁免或核验不过）`, reason: null }
+  }
+  return { status: 'passed', items, detailed, unacknowledged: [], warnings,
+    summary: `${items.length} 个 cannot_verify 任务证据账全部闭环（状态 + 分类核验通过）`, reason: null }
+}
+
+/** 打印 required-evidence 对账结果（v2：blocked 由 gates 阻断；legacy warning 不阻断） */
 export function printVerifyRequiredEvidenceCheck(result) {
   if (result.status === 'skipped') return  // 静默：无 evidence 文件 / 无 changeName / 解析失败
+  if (result.status === 'blocked') return  // 阻断明细由 gates 接线侧统一输出（本函数不重复打印）
   if (result.status === 'passed') {
     console.log(`\n✅ required-evidence 对账通过：${result.summary}`)
     return
@@ -2101,7 +2369,7 @@ function attributeSuspectTasks(runtimeRoot, changeName, paths) {
  *   sources: string[],                    // actual 实际用到的源（诊断可见性；additive）
  * }}
  */
-export function reconcileTargetFiles({ cwd, specBase = null, changeName = null, runtimeRoot = null }) {
+export function reconcileTargetFiles({ cwd, specBase = null, changeName = null, runtimeRoot = null, strictMode = false }) {
   const matched = []
   const missing = []
   const undeclared = []
@@ -2124,6 +2392,19 @@ export function reconcileTargetFiles({ cwd, specBase = null, changeName = null,
       skipReason: `变更 ${changeName} 无 task 卡（tasks/ 缺失或为空），target_files 对账跳过`, notes, form: null, sources: [] }
   }
   if (decl.declarations.length === 0) {
+    // IR 严格档（2026-09-07-ir-hardening D-003@v1，FR-01）：主仓卡全部零声明 → strictViolation。
+    // 判据（Grill P2-④修订）：noDeclarationCount > 0 且 == cardCount - 跨仓卡数——跨仓卡不参与
+    // 计数也不充当豁免（防「塞一张跨仓卡让全部主仓卡免检」绕过）。部分主仓卡已声明 → 不触发（灰度 WARNING）。
+    if (strictMode && decl.noDeclarationCount > 0
+      && 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: [],
+        strictViolation: {
+          code: 'target_files_all_missing_strict',
+          message: `严格模式要求每个主仓 task 卡声明 target_files（计划改动的文件清单，taskcard 骨架已预置字段）——逐卡 Edit 填入：已存在文件写仓根相对精确路径，新建文件加 NEW: 前缀；填毕重跑 --done（进度不丢）`,
+        } }
+    }
     // 存量零红门禁：全部卡无声明 / 全部跨仓 → WARNING 语义跳过，不产生 missing/undeclared
     const reason = decl.noDeclarationCount === 0
       ? `本变更 task 卡全部为跨仓卡（${decl.crossRepoCards.length} 张），主仓 target_files 对账跳过`
@@ -2146,24 +2427,35 @@ export function reconcileTargetFiles({ cwd, specBase = null, changeName = null,
   }
 
   // —— 三类差集 ——
-  const actualSet = new Set(actual.files)
+  // 对账键（2026-09-08 用户反馈⑥：计划文件名 vs 实测文件名的字面差脆）：声明侧 task 卡是
+  // agent 手写（大小写随手、尾部注记、./ 前缀残留），actual 侧是 git 机器产出——字面相等
+  // 判定下这些形态差全部落②类假红（missing_declared，ERROR 态阻断 verify）。统一 canonical
+  // key 再比对：normalizeReviewChangedFile 归一（./ 前缀/尾部注记/行内注释/反斜杠）+
+  // win32/darwin 大小写折叠（默认文件系统大小写不敏感，两形指同一文件；Linux 保持敏感）。
+  // 报告侧仍用原始字面串（用户按自己写的名字找到声明处）。
+  const foldCase = process.platform === 'win32' || process.platform === 'darwin';
+  const pathKey = (p) => {
+    const n = normalizeReviewChangedFile(p);
+    return foldCase ? n.toLowerCase() : n;
+  };
+  const actualKeySet = new Set(actual.files.map(pathKey));
   const declaredPaths = [...new Set(decl.declarations.map(d => d.path))].sort()
-  const declaredSet = new Set(declaredPaths)
+  const declaredKeySet = new Set(declaredPaths.map(pathKey))
   // ①交集（计数进 evidence）：唯一路径口径（多卡声明同文件只计一次）
   for (const path of declaredPaths) {
-    if (actualSet.has(path)) matched.push(path)
+    if (actualKeySet.has(pathKey(path))) matched.push(path)
   }
   // ②声明没做（计划落空，ERROR）：逐卡逐条报 task-NN + path；NEW: 声明的取剥前缀 path、带
-  // isNew 标（“新建文件没建”与“存量文件没动”的修复指引不同）
+  // isNew 标（"新建文件没建"与"存量文件没动"的修复指引不同）
   for (const d of decl.declarations) {
-    if (!actualSet.has(d.path)) {
+    if (!actualKeySet.has(pathKey(d.path))) {
       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）
-  const suspect = attributeSuspectTasks(rt, changeName, actual.files.filter(p => !declaredSet.has(p)))
+  const suspect = attributeSuspectTasks(rt, changeName, actual.files.filter(p => !declaredKeySet.has(pathKey(p))))
   for (const path of actual.files) {
-    if (declaredSet.has(path)) continue
+    if (declaredKeySet.has(pathKey(path))) continue
     const s = suspect.get(normalizeReviewChangedFile(path))
     undeclared.push(s ? { path, suspectTask: s } : { path })
   }
@@ -2337,7 +2629,20 @@ function detectHeadAdvanceSinceFacts(cwd, facts) {
  *     // 诊断（additive）：探针子节在场性；报告未读到的早期 skip 为 null
  * }}
  */
-export function checkProbeConsistency({ cwd, specBase = null, changeName = null, runtimeRoot = null }) {
+/**
+ * IR 严格模式判别（change: 2026-09-07-ir-hardening，D-001@v1）：
+ * changes.created_at ≥ IR_STRICT_SINCE → true（严格档：P3b 探针段缺失 / P3a 主仓卡全零声明 ERROR）。
+ * fail-open：读不到 created_at（无行/db 异常/pm 缺失）→ false，落存量豁免不误伤。
+ * @param {{ getChangeCreatedAt?: Function }} opts.pm - ProgressManager（或含同名方法的对象）
+ */
+export function isStrictChange({ pm, cwd, changeName } = {}) {
+  if (!pm || typeof pm.getChangeCreatedAt !== 'function' || !changeName) return false
+  const createdAt = pm.getChangeCreatedAt(cwd, changeName)
+  if (!createdAt || typeof createdAt !== 'string') return false
+  return createdAt >= IR_STRICT_SINCE
+}
+
+export function checkProbeConsistency({ cwd, specBase = null, changeName = null, runtimeRoot = null, strictMode = false }) {
   if (!changeName) {
     return { status: 'skipped', severity: null, mismatches: [],
       skipReason: '无 changeName（quick 等无关联变更场景），探针一致性抽查跳过', subsections: null }
@@ -2370,8 +2675,20 @@ export function checkProbeConsistency({ cwd, specBase = null, changeName = null,
         note: 'verify-facts.json 在场而正文探针子节全缺——疑似 agent 删除机械预填段（对比基准是正文，删 facts.json 绕不过防护）',
       }], null)
     }
+  if (strictMode) {
+    // IR 严格档（2026-09-07-ir-hardening D-002@v1，FR-01）：闸门后变更不跑 verify-probes --init
+    // 即零子节——不再是「存量兼容 skip」而是 ERROR（可绕过口收紧）。文案必须带可执行指引（R-02）。
+    return finish('mismatch', 'error', [{
+      probe: 'prefill',
+      code: 'probe_prefill_missing_strict',
+      expected: '#### 探针 预填子节在场',
+      actual: '全部缺失',
+      severity: 'error',
+      note: '严格模式变更（created_at ≥ IR_STRICT_SINCE）的 verify-result.md 缺探针预填子节——先跑 sillyspec verify-probes --change <变更名> --init 生成九章节骨架并如实填写，再重跑 --done',
+    }], null)
+  }
     return finish('skipped', null, [],
-      'verify-result.md 无 #### 探针 子节且无 verify-facts.json（存量旧格式报告），探针一致性抽查跳过')
+      'verify-result.md 无 #### 探针 子节且无 verify-facts.json（存量旧格式报告，闸门前变更），探针一致性抽查跳过')
   }
 
   // —— 重跑探针取当前指标（specDir 显式传 sb：根口径由调用方给定，不做祖先推断/漂移锚定） ——
@@ -2424,7 +2741,62 @@ export function checkProbeConsistency({ cwd, specBase = null, changeName = null,
       note: 'contract gap（missing backend）行数与重跑不符（探针5 扫描根/缓存口径环境敏感，WARNING 不阻断）' })
   }
 
-  if (mismatches.length === 0) return finish('ok', null, [], null)
+  // —— facts 基线对比（2026-09-08-ir-verify-facts FR-05 / task-05）：重跑指标 vs
+  // verify-facts.json probes 快照（init 时点）。md 锚点对账查「正文没被改」，本维度查
+  // 「md 被手改对齐新代码后 facts 底稿过期」（P3d 数据源保鲜）。分级沿用现实现口径：
+  // probe1/6=ERROR、probe3/5=WARNING；probe6 继承 HEAD-advance 降级（R-06）。——
+  const factsSnapshot = readVerifyFacts(changeDir)
+  let factsConsistency = null
+  if (factsSnapshot && factsSnapshot.probes) {
+    const fm = []
+    const adv = detectHeadAdvanceSinceFacts(cwd, factsSnapshot)
+    const snap1 = (((factsSnapshot.probes.probe1 || {}).metrics) || {}).matches
+    if (typeof snap1 === 'number' && snap1 !== curProbe1Hits) {
+      fm.push({ probe: 'probe1', snapshot: snap1, rerun: curProbe1Hits, severity: 'error',
+        note: 'facts 快照命中数与重跑不符——md 疑已手改对齐新代码而 facts 底稿过期（修复：verify-probes --init 刷新 facts + 按新结果同步 md 探针段）' })
+    }
+    const snap6 = (((factsSnapshot.probes.probe6 || {}).metrics) || {}).deletions
+    if (!curProbe6.unavailable && typeof snap6 === 'number' && snap6 !== curProbe6Deletions && !adv) {
+      // adv（HEAD 前移）时豁免：同一漂移已由 md 锚点维度的 probe6 WARNING 报出（R-06 继承，
+      // 双维度重复报同一信号是噪音）；非 adv 的不符 = facts 底稿被手改对齐——ERROR
+      fm.push({ probe: 'probe6', snapshot: snap6, rerun: curProbe6Deletions, severity: 'error',
+        note: 'facts 快照删除数与重跑不符——底稿疑似过期（修复：verify-probes --init 刷新 facts + 同步 md 探针段）' })
+    }
+    const snap3 = (((factsSnapshot.probes.probe3 || {}).metrics) || {}).hasTest
+    if (typeof snap3 === 'number' && snap3 !== curProbe3HasTest) {
+      fm.push({ probe: 'probe3', snapshot: snap3, rerun: curProbe3HasTest, severity: 'warning',
+        note: 'facts 快照 hasTest 数与重跑不符（测试布局环境敏感，WARNING）' })
+    }
+    const snap5 = (((factsSnapshot.probes.probe5 || {}).metrics) || {}).backendEndpoints
+    const cur5 = (current.probe5 || {}).backendCount
+    if (typeof snap5 === 'number' && typeof cur5 === 'number' && snap5 !== cur5) {
+      fm.push({ probe: 'probe5', snapshot: snap5, rerun: cur5, severity: 'warning',
+        note: 'facts 快照 backend 端点数与重跑不符（扫描根口径环境敏感，WARNING）' })
+    }
+    factsConsistency = {
+      checked: fm.length === 0 ? ['probe1', 'probe3', 'probe5', 'probe6'] : [...new Set(fm.map(x => x.probe))],
+      verdict: fm.length === 0 ? 'match' : 'mismatch',
+      detail: fm.length === 0 ? null : fm,
+    }
+    for (const x of fm) {
+      mismatches.push({ probe: `facts:${x.probe}`, expected: x.rerun, actual: x.snapshot, severity: x.severity, note: x.note })
+    }
+    // 固化 factsConsistency（fail-soft；不动 probes 快照语义——probes 归 --init 所有）
+    try {
+      const factsPath2 = join(changeDir, 'verify-facts.json')
+      const f2 = JSON.parse(readFileSync(factsPath2, 'utf8'))
+      f2.factsConsistency = factsConsistency
+      writeFileSync(factsPath2, JSON.stringify(f2, null, 2) + '\n')
+    } catch { /* 固化失败不阻断对账 */ }
+  }
+
+  if (mismatches.length === 0) {
+    const okResult = finish('ok', null, [], null)
+    okResult.factsConsistency = factsConsistency
+    return okResult
+  }
   const severity = mismatches.some(m => m.severity === 'error') ? 'error' : 'warning'
-  return finish('mismatch', severity, mismatches, null)
+  const mismatchResult = finish('mismatch', severity, mismatches, null)
+  mismatchResult.factsConsistency = factsConsistency
+  return mismatchResult
 }