sillyspec 3.31.0 → 3.32.1

package/src/run/verify-quality-scan.js

@@ -118,6 +118,10 @@ export function storeQualityScan({ specBase, cwd, changeName, testResult, lintRe
       // RERUN 失败签名（r5l 方案 4）：dedupKey × 测试面 × 环境探针；同样 additive——存量
       // 记录无此键 → RERUN 签名闸判无签名放行一次（同 no-dedup-key 先例口径）
       rerunSignature: computeRerunSignature({ cwd, specBase, dedupKey, env: process.env }),
+      // passed 幂等闸键（2026-09-30-quality-scan-passed-idempotent）：dedupKey × 非文档脏集
+      // 内容键——内容敏感（dedupKey 文件集口径对同文件未提交修改是盲的，闸会吞真实代码
+      // 修改）；additive——存量记录无此键 → 闸判 no-passed-key 保守重跑一次后携带
+      passedKey: computeQualityScanPassedKey({ cwd, specBase }),
       usedSnapshot: Boolean(usedSnapshot),
       ranAt: new Date().toISOString(),
       testResult,
@@ -208,6 +212,42 @@ export function computeRerunSignature({ cwd, specBase, dedupKey = null, env = pr
     .digest('hex')
 }
 
+/**
+ * 非文档脏文件内容键（2026-09-30-quality-scan-passed-idempotent）：对 porcelain 非文档脏集
+ * 逐文件取内容哈希。存在理由：指纹/dedupKey 的脏集是**文件集**口径（对齐 --done 复用面——
+ * verify 窗口内合法产出=文档，代码交付经 apply/commit 进 HEAD，同文件未提交内容修改的盲区
+ * 历史无害）；passed 幂等闸直接终止本步骤执行，盲区会吞真实代码修改（实证：fixture 同文件
+ * 翻转失败版，dedupKey 全等闸误命中）——闸键必须内容敏感。单文件读不到（rename 行/删除中/
+ * 权限）按 '<unreadable>' 占位（状态变化即键变化，恒占位也稳定）；git 不可用 → null。
+ */
+export function computeQualityScanDirtyContentKey({ cwd }) {
+  // trim:false 保 porcelain 行首状态位（git() 缺省 trim 会吃掉首行前导空格，` M x` → `M x`，
+  // slice(3) 路径错位恒读不到文件——实证：fixture 单文件脏集 digest 恒 <unreadable>）
+  const porcelain = gitQuiet(cwd, ['status', '--porcelain'], { trim: false })
+  if (porcelain === null) return null
+  const paths = porcelainCodeLines(porcelain)
+  const parts = []
+  for (const p of paths) {
+    let digest = '<unreadable>'
+    try {
+      digest = createHash('sha256').update(readFileSync(join(cwd, p)).toString('latin1')).digest('hex')
+    } catch { /* 读不到按占位（内容敏感方向保守） */ }
+    parts.push(p + '\n' + digest)
+  }
+  return createHash('sha256').update(parts.join('\n==\n')).digest('hex')
+}
+
+/**
+ * passed 幂等闸键：dedupKey（配置×豁免面×HEAD×文件集）× 非文档脏集内容键 的合成。
+ * 任一分量不可得 → null（fail-closed：无键即无闸，保守真跑）。
+ */
+export function computeQualityScanPassedKey({ cwd, specBase }) {
+  const dedup = computeQualityScanDedupKey({ cwd, specBase })
+  const content = computeQualityScanDirtyContentKey({ cwd })
+  if (!dedup || !content) return null
+  return createHash('sha256').update(dedup + '\n##dirty-content##\n' + content).digest('hex')
+}
+
 /**
  * 读回最近一条扫描记录（不论成败）——失败去重重放用。loadReusableQualityScan 拒绝
  * failed 记录（复用是优化不是正确性依赖），去重恰恰要消费 failed 态；schema/source/
@@ -242,6 +282,31 @@ export function shouldReuseLastFailedScan({ lastRecord, currentDedupKey, planned
   return { reuse: true, reason: null }
 }
 
+/**
+ * passed 幂等闸（2026-09-30-quality-scan-passed-idempotent，与 shouldReuseLastFailedScan 对称）：
+ * 上次质量扫描 test passed 且 lint 非 failed、passedKey 全等（dedupKey × 非文档脏集内容键
+ * ——dedupKey 的文件集口径对同文件未提交内容修改是盲的，闸直接终止本步骤执行会吞真实代码
+ * 修改，故键必须内容敏感）、快照口径一致 → 免重跑。实证：multi-agent-platform 2026-09-30
+ * verify 收敛循环里 agent 修 verify-result.md 文档反复重入本步，码态恒定（零 commit）下质量
+ * 扫描 11 轮 ×~290s 全量真跑——失败有签名闸防假红重试循环，passed 反而无幂等闸。同键 + 同
+ * 快照口径 ⇒ 测试输入完全相同 ⇒ 重跑结果确定性相同，纯等待。
+ * lint failed 记录不入闸：真跑时 lint 失败会让本步骤 throw 不完成，幂等命中直接完成会吞
+ * 掉 lint 阻断发声——lint 债场景须重跑（修债/加豁免即 dedupKey 失配自动重测，闭环不堵）。
+ */
+export function shouldReuseLastPassedScan({ lastRecord, currentPassedKey, plannedSnapshot, forceRerun = false }) {
+  if (forceRerun) return { reuse: false, reason: 'force-rerun（逃生阀 SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN）' }
+  if (!lastRecord || !lastRecord.testResult || lastRecord.testResult.status !== 'passed') {
+    return { reuse: false, reason: 'no-passed-record' }
+  }
+  if (lastRecord.lintResult && lastRecord.lintResult.status === 'failed') {
+    return { reuse: false, reason: 'lint-failed（lint 阻断语义须重跑发声；修债/加豁免即失配自动重测）' }
+  }
+  if (!lastRecord.passedKey || !currentPassedKey) return { reuse: false, reason: 'no-passed-key（存量记录 / git 不可用——保守重跑一次后记录即携带）' }
+  if (lastRecord.passedKey !== currentPassedKey) return { reuse: false, reason: 'passed-key-mismatch（代码内容/文件集/配置/豁免面/HEAD 已变化）' }
+  if (Boolean(lastRecord.usedSnapshot) !== Boolean(plannedSnapshot)) return { reuse: false, reason: 'snapshot-scope-changed' }
+  return { reuse: true, reason: null }
+}
+
 /**
  * 伪影分诊编排（ql-20260920-010 修复一 a）：测试失败 → classify 分类 → 命中且本次是
  * 快照口径 → 主树口径单点复跑对照。复跑过 = 伪影坐实：返回主树结果 + artifactTriage
@@ -589,6 +654,25 @@ export async function executeVerifyQualityScan({ cwd, specBase, changeName, plat
       throw new Error(`noAI 质量扫描复用上次失败结果（失败签名未变，跳过重跑）——${(t.reason || '测试失败').split('\n')[0]}。修复后重跑 sillyspec run verify${changeName ? ` --change ${changeName}` : ''}，或按上方出路处置。`)
     }
   }
+  // ── passed 幂等闸（2026-09-30-quality-scan-passed-idempotent，与失败签名闸对称）──
+  // 上次 passed 且 passedKey（dedupKey × 非文档脏集内容键——内容敏感，同文件未提交修改
+  // 即失配）/快照口径全等 → 免重跑直接完成本步骤（verify 收敛循环里 agent 修文档反复重入
+  // 本步，码态未变时快照构建+测试+lint 的 ~分钟级全量重跑是纯等待——实证 11 轮 ×~290s）。
+  // 复用只做披露，不重写记录（ranAt 不动，--done 读侧 loadReusableQualityScan 口径不变）；
+  // 逃生阀与失败闸同款 RERUN=1/force。
+  if (rerunMode !== '1' && rerunMode !== 'force') {
+    const lastRecord = loadLastQualityScanRecord({ specBase, changeName })
+    const passedVerdict = shouldReuseLastPassedScan({
+      lastRecord,
+      currentPassedKey: computeQualityScanPassedKey({ cwd, specBase }),
+      plannedSnapshot: !process.env.SILLYSPEC_VERIFY_GATE_SNAPSHOT_OFF,
+    })
+    if (passedVerdict.reuse) {
+      console.log(`\n♻️ noAI 质量扫描幂等命中：上次实测 passed 且代码指纹/配置/豁免面/快照口径全等${lastRecord.ranAt ? `（实测于 ${lastRecord.ranAt}）` : ''}——本轮免重跑，--done 对账继续复用该记录；确需重跑设 SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN=1。`)
+      console.log(`\n✅ noAI 质量扫描全绿（幂等复用）——本步骤自动完成；代码/配置/豁免面任一变化即 dedupKey 失配自动重测。`)
+      return
+    }
+  }
   // ── 隔离快照定向跑（2026-09-11 驾驭第十二批，用户第三次撞上：noAI 质量扫描是 verify 的
   // 第一实测执行点，第八批只接了 gates.js verify 块——本步仍跑 main 工作区，并行 WIP 在此弄红
   // 无辜变更）。与 gates.js 同款：createVerifyGateSnapshot（HEAD + 本变更文件集，native worktree

package/src/scan-facts.js

@@ -18,6 +18,7 @@ import { join, relative } from 'node:path'
 import { scanBackendEndpoints, scanFrontendApiCalls } from './endpoint-extractor.js'
 import { estimateSourceSize } from './run/scan-profile.js'
 import { safeGit } from './git-helper.js'
+import { toWallClock } from './datetime.js'
 
 /** 底稿各清单的上限（防大仓把底稿撑爆反而变成新的 token 黑洞） */
 const MAX_ENDPOINTS = 60
@@ -98,7 +99,7 @@ export function collectScanFacts({ cwd, projectPath = null }) {
     : manifest.manifests.includes('Cargo.toml') ? 'rust'
     : 'generic'
   return {
-    generatedAt: new Date().toISOString().replace('T', ' ').slice(0, 19),
+    generatedAt: toWallClock(new Date()),
     projectPath,
     type,
     pkgName: manifest.pkgName,

package/src/scope-audit.js

@@ -267,6 +267,72 @@ function readFrozenPatch(changeDir) {
   } catch { return null }
 }
 
+/**
+ * flow done 冻结记录读取（2026-10-07-scope-audit-thin-patch-replay）：change-patch.json 是
+ * thin 轻量变更 flow done 时点冻结的归属面（files/baseline/head/totals/patchSha256）——thin
+ * 通道不落 execute --done 快照，本件即其对账级冻结记录。缺 json / files 非数组 → null
+ * （调用方回退实时开放区间，不出伪数据）。
+ */
+function readChangePatchMeta(changeDir) {
+  if (!changeDir) return null
+  try {
+    const meta = JSON.parse(readFileSync(join(changeDir, 'change-patch.json'), 'utf8'))
+    if (meta && typeof meta === 'object' && Array.isArray(meta.files)) return meta
+  } catch { /* 缺失/损坏 → null */ }
+  return null
+}
+
+/**
+ * 冻结 patch 正文读取（thin 回放数据源）：变更目录 change.patch；缺失/空 → null。
+ * @returns {string|null}
+ */
+function readChangePatchText(changeDir) {
+  if (!changeDir) return null
+  try {
+    const text = readFileSync(join(changeDir, 'change.patch'), 'utf8')
+    return text && text.trim() ? text : null
+  } catch { return null }
+}
+
+/**
+ * 冻结 patch 按段行数统计（thin 回放数据源）：`diff --git a/<old> b/<new>` 段头切分
+ * （正则与 filterPatchForFiles/slicePatchForFile 同款，取 b/ 新路径），段内 +/− 前缀行计数
+ * （+++ / --- 文件头与 \ 续行标记不计）；`new file mode` → new、`deleted file mode` →
+ * deleted、Binary/GIT binary patch → null 档——三档与 collectNumstatByPath 口径对齐。
+ * 自包含解析（不采 git numstat）：冻结面含 done 时点工作树件（治理工件/untracked），且不
+ * 依赖 git 对象库存活。
+ * @returns {Map<string, {additions: number|null, deletions: number|null, kind: 'binary'|'new'|'modified'|'deleted'}>}
+ */
+function parseFrozenPatchStats(patchText) {
+  const stats = new Map()
+  if (!patchText) return stats
+  let cur = null
+  const flush = () => {
+    if (cur && cur.path) {
+      stats.set(cur.path, cur.binary
+        ? { additions: null, deletions: null, kind: 'binary' }
+        : { additions: cur.additions, deletions: cur.deletions, kind: cur.kind })
+    }
+    cur = null
+  }
+  for (const line of String(patchText).split('\n')) {
+    if (line.startsWith('diff --git ')) {
+      flush()
+      const m = line.match(/^diff --git a\/(.+) b\/(.+)$/)
+      cur = m ? { path: toPosix(m[2]), additions: 0, deletions: 0, kind: 'modified', binary: false } : null
+      continue
+    }
+    if (!cur) continue
+    if (line.startsWith('new file mode')) cur.kind = 'new'
+    else if (line.startsWith('deleted file mode')) cur.kind = 'deleted'
+    else if (line.startsWith('Binary') || line.startsWith('GIT binary patch')) cur.binary = true
+    else if (line.startsWith('+') && !line.startsWith('+++')) cur.additions++
+    else if (line.startsWith('-') && !line.startsWith('---')) cur.deletions++
+  }
+  flush()
+  return stats
+}
+
 /**
  * patch 段过滤（quick-90015473）：全量 diff 按 `diff --git a/<old> b/<new>` 段头切分，
  * 只保留 files 集合内的段——json rows（退栈归属集）与 patch 同口径，多会话仓不把并行
@@ -315,12 +381,19 @@ function verifyPatchIntegrity(recordedSha, patchText) {
  * @param {{ baseRef: string }} opts
  * @returns {string|null} null=采集失败（调用方 fail-soft 不落伪 patch）
  */
-export function buildFrozenPatch(root, files, { baseRef } = {}) {
+export function buildFrozenPatch(root, files, { baseRef, headRef } = {}) {
   if (!root || !baseRef) return null
   const wanted = new Set((Array.isArray(files) ? files : []).map(toPosix).filter(Boolean))
   const parts = []
   try {
-    const r = safeGit(root, ['diff', '--no-color', baseRef], { timeout: 60 * 1000 })
+    // headRef（2026-09-28-split-guard-and-gate-report 评审 P2 清偿）：缺省 `git diff <baseRef>` 比对
+    // 的是**工作树**——共享主仓里并行会话对同文件的未提交 hunk 会漏进冻结件（本变更实证
+    // extractTestAnchors hunk 夹带）。传 headRef 时改为提交区间 diff（baseRef..headRef），工作树
+    // 在途改动不再入冻；调用方对「治理工件目录的未提交槽位编辑」等确需工作树口径的场景不传
+    // headRef（变更目录归本变更独占，无他会话面）。
+    const r = safeGit(root, headRef
+      ? ['diff', '--no-color', baseRef, headRef]
+      : ['diff', '--no-color', baseRef], { timeout: 60 * 1000 })
     // diff 采集失败 fail-closed（2026-09-27-thin-module-scope-persist 评审 P1 清偿：此前失败静默
     // 跳过 tracked 段，untracked 自拼 hunk 仍拼出非空 patch → patchStatus ok 的伪完整件——实证
     // core.bare 被误写 true 时 `git diff <ref>` 报「must be run in a work tree」，change.patch
@@ -965,6 +1038,9 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
       // execute --done 落盘，complete.js `...snap` 展开零改动自动携带）原样回放；旧快照无该键
       // → undefined（JSON.stringify 自动省略——单仓/旧快照零新增字段，additive 契约）。
       const snapRepos = Array.isArray(snap.repos) ? snap.repos : undefined
+      // 通道标注（2026-10-07-unify-close-trace）：新快照带 closedBy（flow done / execute --done）
+      // ——thin 快照回放不再误标 execute --done；旧快照无键缺省兼容。
+      const closeChannel = typeof snap.closedBy === 'string' && snap.closedBy ? snap.closedBy : 'execute --done'
       // 旧快照跨仓注记（R-07）：快照冻结于跨仓对账上线前（跨仓行恒 untouched 的 v1 ⊘ 形态、
       // 无 repos 键）——照旧回放不重算（「快照说什么是什么」契约不破），注记指明人工渠道
       // （该仓锚点锡点冻结在 execute-runs reviews，可人工 git diff 核实）。
@@ -1008,7 +1084,7 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
             : { foreignDeclared: [] },
           patchSha256: snap.patchSha256 || null,
           patchStatus: snap.patchStatus || null,
-          note: `${settleLabel}——execute --done 时点冻结快照${snap.savedAt ? '（' + String(snap.savedAt).replace('T', ' ').slice(0, 19) + ' 落盘）' : ''}：文件集封闭在 apply 时点，主仓后续新文件不进表；行数按锚 ${actual.baseAnchor.slice(0, 7)}→当前工作树 补采（同文件后续演进会计入）${legacyCrossNote}`,
+          note: `${settleLabel}——${closeChannel} 时点冻结快照${snap.savedAt ? '（' + String(snap.savedAt).replace('T', ' ').slice(0, 19) + ' 落盘）' : ''}：文件集封闭在收尾时点，主仓后续新文件不进表；行数按锚 ${actual.baseAnchor.slice(0, 7)}→当前工作树 补采（同文件后续演进会计入）${legacyCrossNote}`,
         }
       }
       return {
@@ -1026,7 +1102,64 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
           : { foreignDeclared: [] },
         patchSha256: snap.patchSha256 || null,
         patchStatus: snap.patchStatus || null,
-        note: `${settleLabel}——execute --done 时点冻结快照${snap.savedAt ? '（' + String(snap.savedAt).replace('T', ' ').slice(0, 19) + ' 落盘）' : ''}：范围封闭在 apply 时点，主仓后续改动不反映到本表；需要看当前工作区实时状态请跑 git status${legacyCrossNote}`,
+        note: `${settleLabel}——${closeChannel} 时点冻结快照${snap.savedAt ? '（' + String(snap.savedAt).replace('T', ' ').slice(0, 19) + ' 落盘）' : ''}：范围封闭在收尾时点，主仓后续改动不反映到本表；需要看当前工作区实时状态请跑 git status${legacyCrossNote}`,
+      }
+    }
+    // —— thin flow done 冻结记录回放（2026-10-07-scope-audit-thin-patch-replay）：thin 轻量变更
+    // flow done 只冻 change-patch.json + change.patch、不落 execute 快照——快照缺失时回读冻结件
+    // 出真实三态（存量归档立即受益），不再落「实时开放区间 → 干净树空 → 清单全行计划未动
+    // +0/−0」的失真链。文件集 = meta.files 过 filterDeliverableFiles（与 actual 侧同口径，
+    // 治理工件不进表）；行数自冻结 patch 按段统计（parseFrozenPatchStats，自包含）；三态按
+    // design 清单 pathMatches 判定（与主链路三态判定同款）；跨仓条目维持 v1 ⊘ untouched 形态
+    // （thin 冻结件只有主仓 patch，不假装对账过）。
+    const doneMeta = readChangePatchMeta(changeDirInfo.dir)
+    if (doneMeta && doneMeta.files.length > 0) {
+      const frozenFiles = filterDeliverableFiles([...new Set(doneMeta.files.map(toPosix).filter(Boolean))]).sort()
+      const patchOk = doneMeta.patchStatus === 'ok'
+      const segStats = patchOk ? parseFrozenPatchStats(readChangePatchText(changeDirInfo.dir)) : new Map()
+      const doneRows = []
+      const doneMatched = new Set()
+      for (const f of frozenFiles) {
+        // 段缺失（冻结面零 diff 文件）/ patch 采集失败 → 行数 null 档（—），不出伪数据
+        const st = segStats.get(f) || { additions: null, deletions: null, kind: 'modified' }
+        const row = { path: f, additions: st.additions, deletions: st.deletions, kind: st.kind }
+        if (!planDegraded) {
+          const entry = plannedEntries.find(e => pathMatches(f, e.path))
+          if (entry) {
+            doneMatched.add(entry.path)
+            row.planned = entry.operation || null
+            row.verdict = 'planned'
+          } else {
+            row.planned = null
+            row.verdict = 'unplanned'
+            const facility = classifyToolScaffold(f)
+            if (facility) row.facility = facility
+          }
+        }
+        doneRows.push(row)
+      }
+      // 计划未动补行：清单文件不在冻结面 → untouched 0/0（与主链路补行同款语义）
+      for (const e of plannedEntries) {
+        if (doneMatched.has(e.path)) continue
+        doneRows.push(e.repo
+          ? { path: e.path, planned: e.operation || null, additions: 0, deletions: 0, kind: 'modified', verdict: 'untouched', crossRepo: e.repo }
+          : { path: e.path, planned: e.operation || null, additions: 0, deletions: 0, kind: 'modified', verdict: 'untouched' })
+      }
+      const doneSettleLabel = changeDirInfo.archived ? '已归档' : 'execute 已收尾（分支已清理，待 verify/archive）'
+      const doneSavedAt = doneMeta.savedAt ? '，' + String(doneMeta.savedAt).replace('T', ' ').slice(0, 19) + ' 落盘' : ''
+      return {
+        ...base,
+        ok: true,
+        degradedReason: planDegraded,
+        baseAnchor: typeof doneMeta.baseline === 'string' && /^[0-9a-f]{7,40}$/.test(doneMeta.baseline) ? doneMeta.baseline : null,
+        totals: { files: doneRows.length, ...sumTotals(doneRows) },
+        rows: doneRows,
+        excluded: { foreignDeclared: [] },
+        patchSha256: doneMeta.patchSha256 || null,
+        patchStatus: doneMeta.patchStatus || null,
+        // --file 冻结切片消费（getFileDiff 唯一读取方）：指向 change.patch，sha256 校验 A-F01 同款
+        ...(patchOk ? { frozenPatchPath: join(changeDirInfo.dir, 'change.patch') } : {}),
+        note: `${doneSettleLabel}——flow done 时点冻结 patch 记录（change-patch.json + change.patch${doneSavedAt}）：文件集与行数封闭在 done 时点（thin 轻量变更无 execute 快照），主仓后续改动不反映到本表${patchOk ? '' : '；冻结 patch 当时采集失败——行数列不可得（—），文件集仍为 done 时点冻结面'}；需要看当前工作区实时状态请跑 git status`,
       }
     }
     // 快照缺失 → 实时开放区间兜底（下方主链路），note 追加漂移警告
@@ -1040,7 +1173,7 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
   // 已收尾但快照缺失（上方分支置位）：实时开放区间兜底，明示漂移语义——快照机制上线
   // （2026-09-10）前收尾的旧变更冻结记录无法重建，如实告知替代渠道。
   if (noSnapshotDrift) {
-    notes.push('快照缺失（变更已收尾——已归档或 execute 分支已清理；快照机制上线前收尾的变更无法重建冻结记录）——下表为实时开放区间（基点→当前工作树，含并行会话与后续演进，随主仓改动漂移），非本变更冻结范围；记录态参考 verify-result.md / git log')
+    notes.push('快照缺失（变更已收尾——已归档或 execute 分支已清理；快照与 flow done 冻结 patch 记录（change-patch.json）均无，无法重建冻结记录——快照机制与冻结件留档上线前收尾的变更即此形态）——下表为实时开放区间（基点→当前工作树，含并行会话与后续演进，随主仓改动漂移），非本变更冻结范围；记录态参考 verify-result.md / git log')
   }
 
   // —— 行数采集根与基点 ——

package/src/sentinel-assertions.js

@@ -52,7 +52,12 @@ function listReviewEvidence(changeDir, opts) {
 }
 
 /**
- * 假勾选三态判定（L0 收口拒收支点，下批接线）。
+ * 假勾选三态判定（L0 收口拒收支点）。
+ *
+ * 证据判据统一（2026-10-07-thin-tasks-v3，镜像豁免退役）：tasks.md 是 agent 的工作分解
+ * 队列，每格勾选都是 agent 的完成主张——一律按 per-task 证据判（提交消息含完整 token
+ * task-NN（负向前瞻，task-01 不证 task-010）或对应 review.json 在场）。机器种子与
+ * agent 改写行同判，不再区分「镜像/覆写」。
  *
  * @param {object} args
  * @param {string|null} args.changeDir 变更目录（推导 specBase 定位 execute-runs；null/探测
@@ -63,7 +68,7 @@ function listReviewEvidence(changeDir, opts) {
  * @param {{listReviewsImpl?: Function}} [args.opts] 注入面（测试替身）
  * @returns {{status:'complete'|'fake'|'none', claimTotal:number, checked:number, missing:string[]}}
  *   none=无完成主张（判集空或未全勾）；complete=全勾且零 missing；fake=全勾且有零证据
- *   任务（missing 列其 id，收口侧拒收依据）。
+ *   任务（missing 列其 id，收口侧拒收依据）
  */
 export function detectFakeCheckCompletion({ changeDir, tasksMd, commits, opts = {} } = {}) {
   const entries = [];
@@ -73,14 +78,15 @@ export function detectFakeCheckCompletion({ changeDir, tasksMd, commits, opts =
   }
   const claimTotal = entries.length;
   const checked = entries.filter((e) => e.checked).length;
+  const messages = (Array.isArray(commits) ? commits : [])
+    .map((c) => (typeof c === 'string' ? c : String((c && (c.message ?? c.subject)) || '')));
   if (claimTotal === 0 || checked < claimTotal) {
     return { status: 'none', claimTotal, checked, missing: [] };
   }
-  const messages = (Array.isArray(commits) ? commits : [])
-    .map((c) => (typeof c === 'string' ? c : String((c && (c.message ?? c.subject)) || '')));
   const reviews = listReviewEvidence(changeDir, opts);
   const missing = entries
     .filter((e) => {
+      if (!e.checked) return false;
       const re = taskTokenRe(e.id);
       const byCommit = messages.some((msg) => re.test(msg));
       const byReview = reviews.some((p) => p.includes(`/tasks/${e.id}/`));
@@ -91,24 +97,69 @@ export function detectFakeCheckCompletion({ changeDir, tasksMd, commits, opts =
 }
 
 /**
- * 勾选节奏检测（2026-09-26-thin-check-cadence）：watcher 事件流里 task-done 单拍跳 ≥2 格 =
- * 一把全勾（未按工作单元逐个勾）——thin-agent-tasks 纪律的收口侧 advisory 判定面（warn 不
- * 阻断，接线在 flow done ledger 子步；节奏是习惯问题非造假主张，L0 硬门另有其人）。
- * 纯函数：事件清单→最大跳格记录；无多格跳返回 null。detail 与 watcher inferEvents 生成
- * 格式成对（`checked N→M`）；解析失配（格式漂移/坏行/非 task-done）按无证据静默——fail-open。
+ * 勾选节奏检测（2026-09-26-thin-check-cadence；2026-10-07-thin-tasks-v3 采样去重）：
+ * 事件流里 task-done 单拍跳 ≥2 格 = 一把全勾（未按工作单元逐个勾）。
+ * 事件两源同流：`task tick` 命令直写的精确事件（source:'task-tick'，一次一格）与 watcher
+ * 3s 轮询的采样事件（快速连续 tick 被合并成一跳）。判最大跳以 CLI 精确事件为权威：
+ *   ① 采样事件落点计数 M 与任一 CLI 事件落点相同 → 整跳被 CLI 精确序列覆盖，剔除；
+ *   ② 其余采样事件起点按「小于其落点的最大 CLI 落点」抬高（CLI 已勾到的格不重复计入跳幅）。
+ * 纯函数：事件清单→最大跳格记录；无多格跳返回 null。detail 与事件生成格式成对
+ * （`checked N→M`）；解析失配（格式漂移/坏行/非 task-done）按无证据静默——fail-open。
  */
 export function detectBatchCheckCadence(events) {
-  let worst = null;
+  const taskEvents = [];
   for (const e of events || []) {
-    if (!e || e.kind !== 'task-done') continue;
+    if (e && e.kind === 'task-done') taskEvents.push(e);
+  }
+  const parse = (e) => {
     const m = /^checked (\d+)→(\d+)$/.exec(String(e.detail || ''));
-    if (!m) continue;
-    const from = Number(m[1]);
-    const to = Number(m[2]);
-    if (to - from < 2) continue;
-    if (!worst || to - from > worst.to - worst.from) worst = { from, to, detail: e.detail, ts: e.ts };
+    return m ? { from: Number(m[1]), to: Number(m[2]) } : null;
+  };
+  const cliParsed = [];
+  for (const e of taskEvents) {
+    if (e.source !== 'task-tick') continue;
+    const r = parse(e);
+    if (r) cliParsed.push(r);
+  }
+  const cliTargets = new Set(cliParsed.map((r) => r.to));
+  const maxCliBelow = (to) => {
+    let best = 0;
+    for (const r of cliParsed) if (r.to < to && r.to > best) best = r.to;
+    return best;
+  };
+  let worst = null;
+  for (const e of taskEvents) {
+    const r = parse(e);
+    if (!r) continue;
+    const isCli = e.source === 'task-tick';
+    if (!isCli && cliTargets.has(r.to)) continue; // 采样合并跳被 CLI 精确序列覆盖
+    const from = isCli ? r.from : Math.max(r.from, maxCliBelow(r.to));
+    if (r.to - from < 2) continue;
+    if (!worst || r.to - from > worst.to - worst.from) worst = { from, to: r.to, detail: e.detail, ts: e.ts };
   }
   return worst;
 }
 
+/**
+ * 单拍勾选门决策（2026-09-29-batch-tick-gate，纯函数）：检出单拍跳（batchTick 非 null）
+ * 时的收口动作裁决。镜像豁免分支退役（2026-10-07-thin-tasks-v3——任务面统一为 agent
+ * 工作分解，无镜像面）。四态（决策顺序即豁免优先序）：
+ *   'silent'   无单拍跳；
+ *   'bypass'   --allow-batch-tick 显式旁路——留痕放行（同意门先例）；
+ *   'advisory' 机器代勾可解释整跳（autopilotTicked >= 跳幅——governance-autopilot 代勾是
+ *              单拍多格机械写，非 agent 纪律面；代勾数不可解释最大跳时落到 reject——防「留
+ *              一格给代勾补、自身大跳蹭豁免」的对抗绕过，二轮评审 P3-E）；
+ *   'reject'   非旁路、代勾解释不了整跳——agent 一把勾，拒收。
+ * @param {{batchTick:object|null, nonMirrorCount?:number|null, allowBatchTick?:boolean, autopilotTicked?:number}} args
+ *   nonMirrorCount 保留为哨兵面未知信号（null → fail-open advisory）；镜像-only 语义已退役。
+ * @returns {{action:'silent'|'advisory'|'bypass'|'reject', reason:string}}
+ */
+export function resolveBatchTickAction({ batchTick, nonMirrorCount = null, allowBatchTick = false, autopilotTicked = 0 } = {}) {
+  if (!batchTick) return { action: 'silent', reason: 'no-batch-tick' };
+  if (allowBatchTick === true) return { action: 'bypass', reason: 'flag' };
+  if (nonMirrorCount === null) return { action: 'advisory', reason: 'sentinel-unknown' };
+  if (autopilotTicked >= batchTick.to - batchTick.from) return { action: 'advisory', reason: 'autopilot-ticked' };
+  return { action: 'reject', reason: 'agent-batch-tick' };
+}
+
 export default { detectFakeCheckCompletion, detectBatchCheckCadence };

package/src/stage-contract-engine.js

@@ -10,7 +10,7 @@
  *     (plan-postcheck 注入 LF-normalizing reader),引擎拿到什么判什么,不在引擎层二次引入差异。
  *   - regex 每次 new RegExp:manifest 存 {pattern, flags} 字符串,规避 lastIndex 状态坑
  *     (旧代码多处 /g 正则跨调用复用需手写 lastIndex=0,是潜在 bug)。
- *   - 内容规则(literal-any、literal-all、regex、contains-section、field-present、header-field、list-non-empty、
+ *   - 内容规则(literal-any、literal-all、literal-none、regex、contains-section、field-present、header-field、list-non-empty、
  *     min-lines/no-placeholder-line)在 target 文件不存在时自动 skip(不报错)——存在性由独立的
  *     file-exists 规则保证,避免"文件缺失"被内容规则重复报。
  *   - custom kind 引擎 skip(不计 errors/warnings),由调用方 validator 保留判定算法,
@@ -75,6 +75,9 @@ function dispatchPure(rule, entry) {
   switch (rule.kind) {
     case 'literal-any': return (rule.data.literals || []).some(s => scoped.includes(s))
     case 'literal-all': return (rule.data.literals || []).every(s => scoped.includes(s))
+    // literal-none(2026-09-29-brainstorm-closure-gates):「不得含字面量」判定——与 literal-any 互补,
+    // 服务 must-not-contain 契约(残留标记类:待确认/自审存疑等"在场即未闭合"语义)。
+    case 'literal-none': return !(rule.data.literals || []).some(s => scoped.includes(s))
     case 'regex': return new RegExp(rule.data.pattern, rule.data.flags || '').test(scoped)
     case 'contains-section': return hasAllSections(scoped, rule.data.sections || [])
     case 'no-placeholder-line': return hasNoPlaceholderLine(scoped, rule.data.patterns)

package/src/stage-contract-spec.js

@@ -25,11 +25,12 @@
  *               (小变更只产 design.md)。判定见 stage-contract-engine.js conditionHolds(fail-safe:ctx 字段缺失时 ne 成立)。
  *
  * 纯 kind(stage-contract-engine.dispatchPure 直接判定):
- *   file-exists / dir-exists / literal-any / literal-all / regex / contains-section /
+ *   file-exists / dir-exists / literal-any / literal-all / literal-none / regex / contains-section /
  *   no-placeholder-line / field-present / header-field / list-non-empty / min-lines / dir-non-empty
- *   —— 语义:若 target 文件不存在,内容类规则(literal-any、literal-all、regex、contains-section、…、list-non-empty、
- *   min-lines)自动 skip(不报错,存在性由独立的 file-exists 规则保证);file-exists/dir-exists
- *   则是"不存在即 fail"。
+ *   —— 语义:若 target 文件不存在,内容类规则(literal-any、literal-all、literal-none、regex、contains-section、…、
+ *   list-non-empty、min-lines)自动 skip(不报错,存在性由独立的 file-exists 规则保证);file-exists/dir-exists
+ *   则是"不存在即 fail"。literal-none 是「不得含字面量」判定(2026-09-29-brainstorm-closure-gates),
+ *   服务 must-not-contain 契约(残留标记类:在场即未闭合)。
  *
  * custom kind(引擎 skip,validator 保留判定算法,但 import 本 manifest 的 data + failMessage):
  *   见 CUSTOM_KINDS。这些是复杂条件校验(lifecycle 多层豁免 / 入口接线多步对账 / decisions 解析 /
@@ -44,6 +45,9 @@ const CUSTOM_KINDS = new Set([
   'entry-point-wiring',      // design.md 入口实例化 → task allowed_paths 覆盖对账(validatePlanOutputs)
   'id-traceability',         // FR/D 引用追踪(extractIds / warnMissingIds)
   'decision-blocker',        // decisions.md P0/P1 未决阻塞(parseDecisionRecords)
+  'decision-coverage',       // requirements.md 对 decisions.md 当前版本 D 的覆盖缺口点名(2026-09-29-brainstorm-closure-gates,validateBrainstormOutputs)
+  'doubt-closure',           // design.md「自审存疑：」应用形态标记行的闭合 token 判定(同上)
+  'risk-mitigation',         // design.md 风险登记表 R-xx 行应对策略列空/占位判定(同上)
   'cross-task-contract',     // task 卡片 provides/expects_from 对账(plan-postcheck)
   'design-file-coverage',    // design.md 文件清单 vs allowed_paths 覆盖(plan-postcheck)
   'task-id-continuity',      // task-NN id 连续性
@@ -151,6 +155,101 @@ const BRAINSTORM_RULES = [
     spec: 'tasks.md 至少有一个任务列表项(行首 `-` / `*` / `数字.`)',
     failMessage: 'tasks.md 没有任务列表项',
   },
+  // ── 闭环收口规则(2026-09-29-brainstorm-closure-gates)────────────────────────────
+  // 判据:开放可以,但每个开口必须能回答「谁、在哪个阶段、以什么证据关掉它」。六类无主开口全部
+  // 补机器收口,severity 全 warning 不阻断(存量零破坏——故障面/退役判据软警告棘轮先例,观测一个
+  // 周期误报率后再评估升 error)。纯 kind 走引擎,复杂判定 custom kind 留 validateBrainstormOutputs。
+  {
+    id: 'brainstorm.proposal.success-criteria',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'literal-any',
+    target: { root: 'change', path: 'proposal.md', scope: 'full' },
+    data: { literals: ['成功标准', 'Success Criteria', 'success criteria'] },
+    condition: { ctxField: 'scale', ne: 'small' },
+    spec: 'proposal.md 含「成功标准 / Success Criteria」章节(字面命中;问题→方案→成功标准主环最后一环——轻量道 flow start --input 对成功标准 0 条 exit 2,完整路径同理)',
+    failMessage: 'proposal.md 缺少「成功标准」章节(需字面命中其一:成功标准 / Success Criteria)——可验证的成功标准是收口验收面,轻量道同款要求',
+  },
+  {
+    id: 'brainstorm.design.no-placeholder',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'no-placeholder-line',
+    target: { root: 'change', path: 'design.md', scope: 'full' },
+    data: { patterns: ['待补充', 'TODO', 'TBD', '未分析', '根据项目情况', '根据实际情况', '按需填写', '待完善', '待设计', '待确认'] },
+    spec: 'design.md 无独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等——占位符在场=开口无人认领)',
+    failMessage: 'design.md 存在独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等)——占位符须替换为真实内容或删除该行',
+  },
+  {
+    id: 'brainstorm.proposal.no-placeholder',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'no-placeholder-line',
+    target: { root: 'change', path: 'proposal.md', scope: 'full' },
+    data: { patterns: ['待补充', 'TODO', 'TBD', '未分析', '根据项目情况', '根据实际情况', '按需填写', '待完善', '待设计', '待确认'] },
+    condition: { ctxField: 'scale', ne: 'small' },
+    spec: 'proposal.md 无独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等)',
+    failMessage: 'proposal.md 存在独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等)——占位符须替换为真实内容或删除该行',
+  },
+  {
+    id: 'brainstorm.requirements.no-placeholder',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'no-placeholder-line',
+    target: { root: 'change', path: 'requirements.md', scope: 'full' },
+    data: { patterns: ['待补充', 'TODO', 'TBD', '未分析', '根据项目情况', '根据实际情况', '按需填写', '待完善', '待设计', '待确认'] },
+    condition: { ctxField: 'scale', ne: 'small' },
+    spec: 'requirements.md 无独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等)',
+    failMessage: 'requirements.md 存在独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等)——占位符须替换为真实内容或删除该行',
+  },
+  {
+    id: 'brainstorm.tasks.no-placeholder',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'no-placeholder-line',
+    target: { root: 'change', path: 'tasks.md', scope: 'full' },
+    data: { patterns: ['待补充', 'TODO', 'TBD', '未分析', '根据项目情况', '根据实际情况', '按需填写', '待完善', '待设计', '待确认'] },
+    condition: { ctxField: 'scale', ne: 'small' },
+    spec: 'tasks.md 无独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等)',
+    failMessage: 'tasks.md 存在独立成行占位词(待补充/TODO/TBD/未分析/待完善/待设计/待确认等)——占位符须替换为真实内容或删除该行',
+  },
+  {
+    id: 'brainstorm.design.pending-confirm-residue',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'literal-none',
+    target: { root: 'change', path: 'design.md', scope: 'full' },
+    data: { literals: ['待确认'] },
+    spec: 'design.md 无「待确认」残留——design-init 决策追踪表预填的「待确认」须逐行补覆盖点后改「已覆盖」(确无决策记录时删除预填行或写「无决策记录」)',
+    failMessage: 'design.md 残留「待确认」——决策追踪表(design-init 预填)须逐行补覆盖点并把「待确认」改为「已覆盖」;确无决策记录时删除预填行或写「无决策记录」',
+  },
+  // decision-coverage(custom):requirements.md 必须引用 decisions.md 全部当前版本 D-xxx@vN
+  // (裸号词边界匹配,D-001 即算引用 D-001@v1,大小写不敏感——与 warnMissingIds 同语义)。
+  // 「剩余风险」行含裸号亦算归属(显式登记为剩余风险=开口有主)。算法留 validateBrainstormOutputs
+  // (复用 extractCurrentDecisionIds),匹配口径/failMessage 从本 manifest 同源。
+  {
+    id: 'brainstorm.requirements.decision-coverage',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'decision-coverage',
+    target: { root: 'change', path: 'requirements.md', scope: 'full' },
+    data: {},
+    spec: 'requirements.md 引用 decisions.md 的全部当前版本 D-xxx@vN(裸号 D-001 词边界匹配即算;未覆盖的在「决策覆盖矩阵」补行,或显式标注为剩余风险——被覆盖或显式登记为剩余风险都算归属,不出现才算开口)',
+    failMessage: 'requirements.md 未引用 decisions.md 中的 ${id} — 在「决策覆盖矩阵」补覆盖行,或在剩余风险中显式标注该决策未覆盖(每个 D 须有归属:被覆盖或显式登记为剩余风险)',
+  },
+  // doubt-closure(custom):「自审存疑：」应用形态标记行须含闭合 token。查带冒号的应用形态而非
+  // 裸词——design-init 自审 checklist 模板行含裸词,裸词判定必常驻误报。算法留 validator。
+  {
+    id: 'brainstorm.design.doubt-closure',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'doubt-closure',
+    target: { root: 'change', path: 'design.md', scope: 'full' },
+    data: {
+      markerPattern: { pattern: '自审存疑\\s*[:：]', flags: '' },
+      closureTokens: ['D-\\d+', 'R-\\d+', '已解决', '已闭合', '已确认', '不适用'],
+    },
+    spec: 'design.md 的「自审存疑：」标记行须含闭合 token(D-xxx/R-xx/已解决/已闭合/已确认)——已解决的改写为结论并引用 D/R,未解决的转 decisions.md D-xxx 或风险登记 R-xx;存疑标记不得原样带进 plan',
+    failMessage: 'design.md 存在未闭合的自审存疑:「${line}」——已解决的改写为结论并引用 D-xxx/R-xx,未解决的转 decisions.md 决策或风险登记 R-xx 后去标记;开放须有归属,存疑标记不得带进 plan',
+  },
+  // risk-mitigation(custom):风险登记表 R-xx 行应对策略列(行末单元格)非空且非占位。design-init
+  // 骨架预填「（待填应对策略）」——骨架行命中即提醒填语义;显式「接受」是合法闭合(接受=归属明确)。
+  {
+    id: 'brainstorm.design.risk-mitigation',
+    stage: 'brainstorm', source: 'validateBrainstormOutputs', severity: 'warning', kind: 'risk-mitigation',
+    target: { root: 'change', path: 'design.md', scope: 'full' },
+    data: {
+      rowPattern: { pattern: '^\\|\\s*(R-\\d+)', flags: '' },
+      placeholderCell: '待填|待补充|待定|TODO|TBD|仅占位|^\\s*[-—–]?\\s*$',
+      acceptToken: '接受',
+    },
+    spec: 'design.md 风险登记表每行 R-xx 的应对策略列(行末单元格)非空且非占位词(待填/待补充/待定/TODO/TBD)——每条风险须有应对;确实接受的风险显式写「接受：<理由>」(接受也是闭合),不得留空/占位',
+    failMessage: 'design.md 风险登记 ${id} 的应对策略列为空/占位——每条风险须有应对策略;确实接受的风险显式写「接受：<理由>」,不得留空或占位(风险无应对=开口无归属)',
+  },
   // lifecycle(custom kind):design.md 命中生命周期关键词时必须含契约表或紧邻豁免。判定算法留 validator
   // (trigger/exemption/table 三段短路),data + failMessage/exemptionPassedMessage 从本 manifest 同源。
   {