sillyspec 3.28.3 → 3.28.4

package/src/verify-postcheck.js

@@ -25,7 +25,7 @@
 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'
@@ -37,6 +37,7 @@ 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
@@ -115,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 侧的对账不对称——
@@ -162,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}`)
@@ -183,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('   输出（末尾）：')
@@ -1620,6 +1683,9 @@ export function writeRunResult({ specBase, changeName, result, extra = {} }) {
       ...extra,
     }, null, 2) + '\n')
     result.resultPath = resultPath
+    // verify-runs 回收不在此处（ql-20260908-005 已定分野）：变更归属类证据走归档时精确
+    // 回收（pruneArchivedChangeRuntime 按目录内 JSON change 字段归属）；写入侧滚动是
+    // 启发式，不进证据类目录。
   } catch (e) {
     console.warn(`⚠️  verify 实测结果落盘失败: ${e.message}`)
   }
@@ -1877,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 对账跳过' }
   }
@@ -1898,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
@@ -1912,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
@@ -2255,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 })
   }
@@ -2558,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
 }

package/src/verify-probes.js

@@ -11,8 +11,8 @@
  * 探针2（关键词提取半语义）/探针3.4 集成盲区/3.5 断言抽查/探针4（决策追踪语义）留 agent。
  *
  * verify-result.md 骨架：七章节固定结构 + 探针结果机械预填 + 其余章节 <!--TODO--> 占位。
- * 结论章节留「待填」——extractVerifyConclusion 找不到 PASS/FAIL 关键词即判不过，骨架不能
- * 直接过门（与 symbol-impact 骨架同款防偷懒语义）。
+ * 结论走「结论枚举：」固定槽行（刀③）——占位符不含枚举词，槽未填 extractVerifyConclusionSlot
+ * 返回 '' 即判不过，骨架不能直接过门（与 symbol-impact 骨架同款防偷懒语义）。
  * P3b 增量：①章节标题行末尾 claims 层标注（可复跑探针/确定性检查/人工判断，纯后缀不新增行）；
  * ②--init 同步落盘 verify-facts.json 机器底稿（探针命令行 + 首跑关键指标 + 时间戳，CLI 全权写，
  * 供事后独立复跑审计；重复 --init 覆盖为最近一次 init 快照）。
@@ -20,6 +20,9 @@
 import { existsSync, readFileSync, readdirSync, writeFileSync } from 'fs'
 import { join, dirname, basename } from 'path'
 import { gitQuiet } from './git-helper.js'
+import {
+  FACTS_SCHEMA_VERSION, EVIDENCE_SLOT_HEADING, RECEIPT_SLOT_HEADING, parseEvidenceSlots,
+} from './verify-facts-schema.js'
 import { parseFileChangeListDetailed } from './change-list.js'
 import { parseAllowedPaths } from './stages/plan-postcheck.js'
 import { verifyApiParity, _readWorktreeMeta } from './contract-matrix.js'
@@ -310,8 +313,11 @@ export function buildVerifyFacts(result, { changeName, now } = {}) {
   const p3 = (result && result.probe3) || {}
   const p5 = (result && result.probe5) || {}
   const p6 = (result && result.probe6) || {}
+  // v2（2026-09-08-ir-verify-facts）：probes 机器段原样；conclusion/tests/requiredEvidence/
+  // runtimeEvidence/factsConsistency 五段是 slot-backfill/实测回填段（D-001@v2），--init 快照
+  // 不落键（writeVerifyFacts 分段合并时保留既有固化段），由 backfillFactsFromMdAndTests 填。
   return {
-    schemaVersion: 1,
+    schemaVersion: 2,
     change: changeName,
     generatedAt: now || new Date().toISOString(),
     probes: {
@@ -350,37 +356,160 @@ export function buildVerifyFacts(result, { changeName, now } = {}) {
 }
 
 /**
- * verify-probes --init 落盘 verify-facts.json（CLI 全权写）。重复 --init 无条件覆盖——语义是
- * 「最近一次机械预填的审计底稿快照」（骨架已存在跳过时 facts 照样刷新），agent 勿手改：
- * 事后复跑审计的对照快照，防篡改一致性检查的对比基准是 verify-result.md 正文（非本文件）。
+ * verify-probes --init 落盘 verify-facts.json（CLI 全权写）。v2（2026-09-08-ir-verify-facts）改
+ * 分段合并：re-init 刷新机器段（probes/generatedAt），保留既有 slot-backfill/实测固化段
+ * （conclusion/tests/requiredEvidence/runtimeEvidence）——旧「无条件覆盖」会抹掉 --done 回填数据
+ * （设计审查 P1-5）。agent 勿手改：复跑审计的对照快照，防篡改基准是 verify-result.md 正文。
  * @param {string} changeDir 变更目录（spec 根下 changes/<name>）
  * @param {object} result runVerifyProbes 返回值
  * @param {string} changeName 变更名（统一命令行呈现）
  * @returns {{ facts: object, path: string }}
  */
 export function writeVerifyFacts(changeDir, result, changeName) {
-  const facts = buildVerifyFacts(result, { changeName })
+  const fresh = buildVerifyFacts(result, { changeName })
   const factsPath = join(changeDir, 'verify-facts.json')
+  let facts = fresh
+  try {
+    const prev = JSON.parse(readFileSync(factsPath, 'utf8'))
+    if (prev && prev.schemaVersion === FACTS_SCHEMA_VERSION) {
+      facts = {
+        ...fresh,
+        conclusion: prev.conclusion,
+        tests: prev.tests,
+        requiredEvidence: prev.requiredEvidence,
+        runtimeEvidence: prev.runtimeEvidence,
+        factsConsistency: prev.factsConsistency, // 保留至上次对比结论（下次 --done 重算覆盖）
+      }
+    }
+  } catch { /* 首次落盘/v1/损坏 → 全新快照（v1 无固化段，直接升 v2） */ }
   writeFileSync(factsPath, JSON.stringify(facts, null, 2) + '\n')
-  console.log(`📝 已刷新 verify-facts.json 机器底稿: ${factsPath}（CLI 全权写，勿手改）`)
+  console.log(`📝 已刷新 verify-facts.json 机器底稿: ${factsPath}（v2 分段合并，固化段保留；CLI 全权写，勿手改）`)
   return { facts, path: factsPath }
 }
 
+/**
+ * --done 回填（D-001@v2 slot-backfill）：结论枚举槽 + 证据/回执槽解析固化进 facts；
+ * testCheckResult 提供时回填 tests 段（实测在 runValidators 之后 → gates 二次回填，FR-03 次序）。
+ * 机器段（probes/factsConsistency）不经本函数（writeVerifyFacts / checkProbeConsistency 所有）。
+ * fail-soft：facts 缺失时原地升 v2（probes 保留或空）；落盘失败 warn 不抛。
+ * @param {string} factsPath verify-facts.json 路径
+ * @param {{ verifyMd: string, testCheckResult?: object|null }} opts
+ * @returns {{ facts: object, conclusion: string|null, evidenceCount: number, receiptCount: number, testsBackfilled: boolean }}
+ */
+export function backfillFactsFromMdAndTests(factsPath, { verifyMd, testCheckResult = null, conclusion = null }) {
+  let facts = null
+  try { facts = JSON.parse(readFileSync(factsPath, 'utf8')) } catch { /* 缺失见下 */ }
+  // 只固化既有底稿，不无中生有（2026-09-08-ir-verify-facts 接线实证）：无 facts 的存量变更
+  // （未跑过 --init）若被回填凭空建出 facts.json，checkProbeConsistency 的「有 facts 无探针
+  // 子节 → error」判别会把存量兼容 skip 误升 error（run-complete-step-verify e2e 抓出）。
+  // 底稿创建唯一入口是 verify-probes --init。
+  if (!facts) {
+    return { facts: null, skipped: true, conclusion: null, evidenceCount: 0, receiptCount: 0, testsBackfilled: false, reason: '无 verify-facts.json（未跑 --init），回填跳过——底稿创建唯一入口是 --init' }
+  }
+  if (facts.schemaVersion !== FACTS_SCHEMA_VERSION) {
+    facts = { ...facts, schemaVersion: FACTS_SCHEMA_VERSION, probes: (facts && facts.probes) || {} }
+  }
+  const slots = parseEvidenceSlots(verifyMd || '')
+  // conclusion 由调用方传 stage-contract.extractVerifyConclusionSlot(verifyMd) 的结果
+  // （避免 verify-probes → stage-contract 静态 import 的潜在环，分层单向）
+  const conclusionSlot = conclusion || null
+  if (conclusionSlot) facts.conclusion = conclusionSlot
+  if (slots.hasEvidenceSlot && slots.requiredEvidence.length > 0) {
+    facts.requiredEvidence = slots.requiredEvidence.map(e => ({
+      task: e.task, status: e.status, verifiedFiles: e.verifiedFiles,
+      ...(e.exempt ? { exempt: true, exemptionReason: e.exemptionReason } : {}),
+    }))
+  }
+  if (slots.hasReceiptSlot && slots.runtimeEvidence.length > 0) {
+    facts.runtimeEvidence = slots.runtimeEvidence
+  }
+  let testsBackfilled = false
+  if (testCheckResult && testCheckResult.status && testCheckResult.status !== 'skipped') {
+    facts.tests = {
+      command: testCheckResult.command || null,
+      exitCode: typeof testCheckResult.exitCode === 'number' ? testCheckResult.exitCode : null,
+      strategy: testCheckResult.mode || testCheckResult.strategy || null,
+      failedRemaining: testCheckResult.failureNames || testCheckResult.failedTests || [],
+      passedAt: new Date().toISOString(),
+    }
+    testsBackfilled = true
+  }
+  try {
+    writeFileSync(factsPath, JSON.stringify(facts, null, 2) + '\n')
+  } catch (e) {
+    console.warn(`⚠️ facts 回填落盘失败（fail-soft，不阻断）: ${e && e.message ? e.message : e}`)
+  }
+  return { facts, conclusion: conclusionSlot, evidenceCount: slots.requiredEvidence.length, receiptCount: slots.runtimeEvidence.length, testsBackfilled }
+}
+
+/**
+ * md 槽段缺失补齐（--init 段落级补齐，2026-09-08-ir-verify-facts R-02）：已存在的
+ * verify-result.md 缺「证据账/集成验证回执」槽段时仅追加骨架（不触碰既有正文），幂等二跑零改动。
+ * @param {string} mdPath verify-result.md 路径
+ * @param {Array<{task:string,evidence:string[]}>} [requiredEvidenceItems] verify-required-evidence.json items（预填 task 行）
+ * @returns {{ added: string[] }} 追加的槽段标题列表
+ */
+export function backfillMissingEvidenceSlots(mdPath, requiredEvidenceItems = []) {
+  let text = ''
+  try { text = readFileSync(mdPath, 'utf8') } catch { return { added: [] } }
+  const normalized = text.replace(/\r\n/g, '\n')
+  const added = []
+  const blocks = []
+  if (!normalized.includes(EVIDENCE_SLOT_HEADING)) {
+    const lines = [EVIDENCE_SLOT_HEADING, '[层：人工判断——CLI 核验]', '', '<!-- 无 cannot_verify 任务时本节写「无」 -->']
+    if (requiredEvidenceItems.length > 0) {
+      for (const it of requiredEvidenceItems) {
+        lines.push(`- ${it.task}: <待填：三选一> | verifiedFiles: <精确路径，逗号分隔>（satisfied 必填；豁免时填 missing 并加（豁免：<一句话理由>）后缀）`)
+      }
+    } else {
+      lines.push('无（本次变更无 cannot_verify 任务）')
+    }
+    lines.push('')
+    blocks.push(lines.join('\n'))
+    added.push(EVIDENCE_SLOT_HEADING)
+  }
+  if (!normalized.includes(RECEIPT_SLOT_HEADING)) {
+    blocks.push([
+      RECEIPT_SLOT_HEADING, '[层：自述声明——CLI 一致性校验]', '',
+      '<!-- integration-critical/deployment-critical 变更必填；其余写「无」 -->',
+      '- claim: <待填：一句话> | command: <待填：命令> | exit: <待填：0 或非 0> | log: <待填：日志路径>',
+      '',
+    ].join('\n'))
+    added.push(RECEIPT_SLOT_HEADING)
+  }
+  if (added.length > 0) {
+    writeFileSync(mdPath, normalized.replace(/\n?$/, '\n') + blocks.join('\n') + '\n')
+  }
+  return { added }
+}
+
 /**
  * 生成 verify-result.md 骨架（七章节；探针结果机械预填，语义章节 <!--TODO--> 占位）。
- * 结论章节留「待填」——extractVerifyConclusion 无 PASS/FAIL 关键词即判不过，骨架不能直接过门。
+ * 结论走「结论枚举：」固定槽行（刀③，2026-09-08）——占位符不含枚举词（<待填：三选一>），
+ * 槽未填 → extractVerifyConclusionSlot 返回 '' → gate 判不过（fail-closed；旧占位符
+ * `<待填：PASS 或 FAIL>` 含 PASS 字样会被窗口正则误读成已填 PASS，已修）。
  * 章节标题行末尾带 claims 层标注（P3b）：探针结果=可复跑探针 / 测试结果=确定性检查 / 其余=
- * 人工判断——纯渲染层后缀，不新增行，verify gate 结论提取按关键词窗口制不受影响。
+ * 人工判断——纯渲染层后缀，不新增行；结论解析槽优先于标题关键词窗口（存量兼容）。
  * @returns {string|null} 骨架全文；无 design.md/tasks.md（非完整流程变更）→ null
  */
 export function generateVerifyResultSkeleton(result) {
   const L = [
     '# 验证报告（骨架由 `sillyspec verify-probes --change <变更名> --init` 生成）',
     '',
-    '> 探针结果已机械预填；其余章节把 `<!--TODO-->` 替换为真实内容。**结论必须写明 PASS / FAIL**——',
-    '> 留「待填」会被 gate 判不过（fail-closed）。',
+    '> 探针结果已机械预填；其余章节把 `<!--TODO-->` 替换为真实内容。**结论只认「结论枚举：」槽行**——',
+    '> 槽行留「<待填：三选一>」会被 gate 判不过（fail-closed），正文其他位置的 PASS/FAIL 字样不参与判定。',
+    '',
+    '## 结论 [层：人工判断]',
+    '',
+    '结论枚举：`<待填：三选一>`（把尖括号占位整体替换为 PASS / PASS WITH NOTES / FAIL 之一；一句话理由写在枚举后同行或下一行）',
+    '',
+    '## 证据账（cannot_verify 任务） [层：人工判断——CLI 核验]',
+    '<!-- 无 cannot_verify 任务时本节写「无」；有则逐 task 一行 -->',
+    '- task-NN: <待填：三选一> | verifiedFiles: <精确路径，逗号分隔>（satisfied 必填；豁免时填 missing 并加（豁免：<一句话理由>）后缀）',
     '',
-    '## 结论：<待填：PASS 或 FAIL（+一句话理由）> [层：人工判断]',
+    '## 集成验证回执 [层：自述声明——CLI 一致性校验]',
+    '<!-- integration-critical/deployment-critical 变更必填；其余写「无」 -->',
+    '- claim: <待填：一句话> | command: <待填：命令> | exit: <待填：0 或非 0> | log: <待填：日志路径>',
     '',
     '## 任务完成度 [层：人工判断]',
     '<!--TODO: 逐 task 对照 tasks.md 勾选与验收标准，完成/未完成/存疑三态-->',

package/src/workflow.js

@@ -12,6 +12,7 @@
 import { readFileSync, existsSync, readdirSync, writeFileSync, mkdirSync } from 'fs'
 import { join, resolve, basename } from 'path'
 import jsYaml from 'js-yaml'
+import { pruneTimestampedEntries } from './runtime-hygiene.js'
 import { WORKFLOW_STATUS } from './constants.js'
 import { contentNonEmpty, lineCount, missingSections, placeholderLineMatches } from './check-primitives.js'
 import { collectInvalidDocRefs } from './docs-check.js'
@@ -626,6 +627,11 @@ export function saveWorkflowRun(result, options = {}) {
 
   try {
     writeFileSync(filepath, JSON.stringify(record, null, 2), 'utf8')
+    // 写入侧滚动裁剪（runtime-hygiene.js，2026-09-08 系统性回收）：workflow-runs/ 只写不收，
+    // 实证本仓 21 份累积。文件名以零填充时间戳开头，name 字典序 == 时间序。fail-open 静默。
+    try {
+      pruneTimestampedEntries({ dir: runDir, keep: 30 })
+    } catch { /* 卫生动作 fail-open */ }
     return filepath
   } catch (e) {
     console.warn('⚠️ 保存 workflow run 失败:', e.message)